fix(bridge): make the app-icon object a real input of the mingw link

Editing an app-icon PNG rebuilt the .ico and the windres .o and then left the
link UP-TO-DATE, so the .exe silently kept the OLD embedded icon. Reproduced on
:apidemo - generateComposeNativeIco and compileComposeNativeIconResource both
re-ran, linkDebugExecutableMingwX64 reported UP-TO-DATE, and the executable's
md5 did not move.

The link was wired with a bare `dependsOn(windresTask)`, which only ORDERS the
two. The object's path reaches the linker as a `linkerOpts` STRING, so the path
is an input but its CONTENT never is - nothing about a changed .o could
invalidate the link.

Replaced with `inputs.files(windresTask)`, which carries the task dependency AND
puts the object's content into the up-to-date check. Verified: the link now
re-runs and the .exe changes when an icon PNG is edited, in both directions.

The .rgba window-icon blobs were never affected - they go into the data.kres Zip
via `from(dir)`, and a Copy spec is already a declared input.

Also annotates the three icon task types with @DisableCachingByDefault. They
had no cacheability declaration, which failed `validatePlugins` and with it
:compose-desktop-native-bridge:build; that failure predates this change.

.github/workflows/publish.yml

@@ -7,6 +7,9 @@ on:
   push:
     tags:
       - 'v*'
+  # Manual fallback: run with --ref <tag> so github.ref_name is the tag itself
+  # (PUBLISH_VERSION is derived from it).
+  workflow_dispatch:
 
 # Never overlap two publish runs for the same tag.
 concurrency:
@@ -18,10 +21,9 @@ jobs:
     strategy:
       fail-fast: false
       # Each host runs only the publish tasks Gradle actually generated for it.
-      # macOS also publishes the shared kotlinMultiplatform metadata module.
-      # No library module declares jvm() today — apps do their own JVM parity
-      # build against upstream Compose, so JVM isn't part of the publication.
-      # `target` is the Gradle K/N target token (Capitalised) — one per host,
+      # WINDOWS also publishes the shared kotlinMultiplatform metadata modules
+      # (see its matrix entry) + the jvm jar + the bridge plugin.
+      # `target` is the Gradle K/N target token (Capitalised) - one per host,
       # used for :demo / :apidemo linkReleaseExecutable<Target>. linuxArm64 is
       # skipped for the app build because SDL3 static libs on the ubuntu runner
       # are host-arch only; cross-compile would fail at link time.
@@ -32,7 +34,6 @@ jobs:
             target: MacosArm64
             exe_ext: kexe
             tasks: >-
-              publishKotlinMultiplatformPublicationToGitHubPackagesRepository
               publishMacosArm64PublicationToGitHubPackagesRepository
           - runner: ubuntu-22.04
             host: linux
@@ -45,8 +46,18 @@ jobs:
             host: windows
             target: MingwX64
             exe_ext: exe
+            # WINDOWS owns the root KotlinMultiplatform metadata modules: it is
+            # the ONLY host that declares every target (vHostSupportsMingw is
+            # host-gated), so only its generated .module files carry the full
+            # variant table - the macOS-published roots of v0.1.15 had NO
+            # mingwX64 variants and Windows consumers could not resolve them.
+            # The host-independent jvm jar (:material-symbols) and the bridge
+            # plugin ride along on the same job.
             tasks: >-
               publishMingwX64PublicationToGitHubPackagesRepository
+              publishKotlinMultiplatformPublicationToGitHubPackagesRepository
+              publishJvmPublicationToGitHubPackagesRepository
+              :compose-desktop-native-bridge:publishAllPublicationsToGitHubPackagesRepository
 
     runs-on: ${{ matrix.runner }}
 
@@ -91,29 +102,30 @@ jobs:
 
       # windows-2022 runners pre-install Chocolatey's mingw-w64 at C:\mingw64.
       # SDL3 >= 3.4 needs a C++ compiler for its GameInput backend (K/N's
-      # bundled mingw is C-only) — this pre-install covers that. The setjmp
+      # bundled mingw is C-only) - this pre-install covers that. The setjmp
       # intrinsic K/N's LLD can't resolve is aliased to msvcrt's _setjmpex at
       # link time via --defsym in sdl3.def.
 
-      # Build static SDL3 / SDL3_ttf / SDL3_image / FreeType from
-      # scripts/build-sdl/build-sdl.properties. Cached against the manifest +
-      # scripts so version bumps invalidate cleanly.
-      # `cache_version` is a manual bump for when the toolchain (runner OS,
-      # compiler flavour, K/N sysroot expectations) changes without any
-      # scripts/build-sdl/ file changing. Increment to force a rebuild.
+      # Build the static SDL3 lib (scripts/build-sdl/build-sdl.properties). Every
+      # target renders through Skia now, so all platforms need only base SDL3 for
+      # the main loop (windowing / input / audio / filesystem) - the from-scratch
+      # SDL renderer and its SDL3_ttf / SDL3_image / FreeType deps were removed.
+      # Cached against the manifest + scripts so version bumps invalidate cleanly;
+      # bump the `v3` key when the toolchain (runner OS, compiler flavour, K/N
+      # sysroot) changes without a scripts/build-sdl/ edit.
       - name: Cache libs/
         id: cache-libs
         uses: actions/cache@v4
         with:
           path: libs
-          key: sdl-libs-v2-${{ matrix.host }}-${{ hashFiles('scripts/build-sdl/**') }}
+          key: sdl-libs-v3-${{ matrix.host }}-${{ hashFiles('scripts/build-sdl/**') }}
 
-      - name: Build static SDL / TTF / image / FreeType
+      - name: Build static native deps
         if: steps.cache-libs.outputs.cache-hit != 'true'
         shell: bash
-        run: bash scripts/build-sdl/build-all.sh
+        run: python3 scripts/build-sdl/build-all.py
 
-      # src/vendor/ trees are gitignored — a fresh checkout has zero vendored
+      # src/vendor/ trees are gitignored - a fresh checkout has zero vendored
       # androidx.compose.* files. Sync copies them in from the upstream refs
       # pinned in scripts/compose-fork/compose.properties. Needs python3 + git;
       # both are pre-installed on every runner.
@@ -121,16 +133,84 @@ jobs:
         shell: bash
         run: bash scripts/compose-fork/sync.sh
 
-      # GitHub Packages sometimes returns 409 Conflict on a fresh upload when
-      # the same coordinate was recently deleted (soft-delete propagation).
-      # `--continue` lets Gradle finish the rest of the publish tasks past a
-      # single 409, and the outer retry re-runs the whole thing (Gradle skips
-      # already-uploaded artifacts). Two attempts is enough for the transient
-      # cases we've hit; the third pass falls through as a hard failure.
+      # GitHub Packages FORBIDS overwriting a file that already exists in a
+      # version, and maven-publish uploads each publication's files
+      # SEQUENTIALLY from the first one. So when an upload dies mid-publication
+      # (the v0.1.13 macOS run lost DNS mid-publish), a blind retry hits 409
+      # Conflict on the first already-uploaded file and aborts BEFORE reaching
+      # the missing tail files - the version is poisoned and can never
+      # complete. A 409 is therefore only benign when the publication had
+      # already completed; you can't tell from the 409 alone. The fix: between
+      # attempts, DELETE this host's package versions for the current release
+      # and re-upload from a clean slate. Each host owns DISJOINT package
+      # names (roots / -mingwx64 / -jvm / bridge on Windows, -macosarm64 on
+      # macOS, -linuxx64/-linuxarm64 on Linux), so parallel jobs never touch
+      # each other's uploads. Uses the run's GITHUB_TOKEN (packages: write);
+      # a 403 on delete just degrades to the old blind-retry behaviour.
       - name: Publish to GitHub Packages
         shell: bash
         run: |
           set -e
+          VER="${PUBLISH_VERSION#v}"
+          OWNER="${GITHUB_REPOSITORY%%/*}"
+          # Keep in sync with the module list in settings.gradle.kts.
+          MODULES="sdl-core ui ui-graphics ui-text ui-util ui-geometry ui-unit ui-backhandler ui-tooling-preview animation animation-core animation-graphics foundation foundation-layout material3 material-ripple desktop-native-window material-symbols navigation3-ui components-resources"
+          case "${{ matrix.host }}" in
+            macos)   SUFFIXES="-macosarm64" ;;
+            linux)   SUFFIXES="-linuxx64 -linuxarm64" ;;
+            windows) SUFFIXES="_ROOT_ -mingwx64" ;;
+          esac
+          # Published group per module - mirrors the per-area com.bitsycore groups
+          # in root build.gradle.kts. Project-only modules (sdl-core, material-symbols)
+          # fall through to com.bitsycore.compose.sdl; the GitHub Packages Maven
+          # package name is "<group>.<artifact>".
+          group_of() {
+            case "$1" in
+              ui|ui-graphics|ui-text|ui-util|ui-geometry|ui-unit|ui-backhandler|ui-tooling-preview)
+                                      echo "com.bitsycore.compose.ui" ;;
+              foundation|foundation-layout)                echo "com.bitsycore.compose.foundation" ;;
+              animation|animation-core|animation-graphics) echo "com.bitsycore.compose.animation" ;;
+              material3)              echo "com.bitsycore.compose.material3" ;;
+              material-ripple)        echo "com.bitsycore.compose.material" ;;
+              components-resources)   echo "com.bitsycore.compose.components" ;;
+              navigation3-ui)         echo "com.bitsycore.navigation3" ;;
+              desktop-native-window)  echo "com.bitsycore.compose" ;;
+              *)                      echo "com.bitsycore.compose.sdl" ;;
+            esac
+          }
+          host_packages() {
+            for m in $MODULES; do
+              g=$(group_of "$m")
+              for s in $SUFFIXES; do
+                if [ "$s" = "_ROOT_" ]; then echo "$g.$m"; else echo "$g.$m$s"; fi
+              done
+            done
+            if [ "${{ matrix.host }}" = "windows" ]; then
+              echo "com.bitsycore.compose.sdl.material-symbols-jvm"
+              echo "com.bitsycore.compose.sdl.compose-desktop-native-bridge"
+              echo "com.bitsycore.compose-desktop-native.bridge.com.bitsycore.compose-desktop-native.bridge.gradle.plugin"
+            fi
+          }
+          cleanup_host_versions() {
+            echo "Deleting this host's partially-published $VER package versions"
+            host_packages | while read -r pkg; do
+              vid=$(curl -s -H "Authorization: Bearer $GITHUB_TOKEN" \
+                "https://api.github.com/users/$OWNER/packages/maven/$pkg/versions?per_page=100" \
+                | jq -r --arg v "$VER" 'if type=="array" then ([.[] | select(.name==$v) | .id] | first // empty) else empty end')
+              [ -z "$vid" ] && continue
+              code=$(curl -s -o /dev/null -w "%{http_code}" -X DELETE \
+                -H "Authorization: Bearer $GITHUB_TOKEN" \
+                "https://api.github.com/users/$OWNER/packages/maven/$pkg/versions/$vid")
+              if [ "$code" != "204" ]; then
+                # Deleting the LAST version of a package is refused (400) -
+                # a package new in this release: drop the whole package.
+                code=$(curl -s -o /dev/null -w "%{http_code}" -X DELETE \
+                  -H "Authorization: Bearer $GITHUB_TOKEN" \
+                  "https://api.github.com/users/$OWNER/packages/maven/$pkg")
+              fi
+              echo "  $pkg@$VER -> HTTP $code"
+            done
+          }
           for attempt in 1 2 3; do
             echo "::group::Publish attempt $attempt"
             if ./gradlew ${{ matrix.tasks }} --continue --no-daemon --stacktrace; then
@@ -138,16 +218,48 @@ jobs:
               exit 0
             fi
             echo "::endgroup::"
-            [ $attempt -lt 3 ] && { echo "::warning::Publish attempt $attempt failed — sleeping 60s and retrying"; sleep 60; }
+            if [ $attempt -lt 3 ]; then
+              echo "::warning::Publish attempt $attempt failed - cleaning this host's $VER packages and retrying"
+              cleanup_host_versions || true
+              sleep 30
+            fi
           done
           echo "::error::Publish failed after 3 attempts"
           exit 1
 
-      # Release binaries for the host target — the binary plus the data.kres
-      # (bundled composeResources + fonts + subset icon-font). Each :demo /
-      # :apidemo has its linkReleaseExecutable<Target> task wired to auto-run
-      # the matching copy<Variant>ComposeResources<Target> so data.kres is
-      # produced next to the .kexe / .exe. On Linux only linuxX64 is built —
+      # Second target: the self-hosted Reposilite instance. Same publications,
+      # task names derived from the matrix by swapping the repository name.
+      # The releases repo has redeployment enabled, so a plain retry after a
+      # mid-upload failure is safe (no GitHub-Packages-style 409 poisoning).
+      - name: Publish to maven.bitsycore.com
+        shell: bash
+        env:
+          BITSYCORE_MAVEN_USER: ${{ secrets.BITSYCORE_MAVEN_USER }}
+          BITSYCORE_MAVEN_TOKEN: ${{ secrets.BITSYCORE_MAVEN_TOKEN }}
+        run: |
+          set -e
+          BITSY_TASKS=$(echo "${{ matrix.tasks }}" | sed 's/GitHubPackagesRepository/BitsycoreRepository/g')
+          for attempt in 1 2 3; do
+            echo "::group::Bitsycore publish attempt $attempt"
+            if ./gradlew $BITSY_TASKS --continue --no-daemon --stacktrace; then
+              echo "::endgroup::"
+              exit 0
+            fi
+            echo "::endgroup::"
+            if [ $attempt -lt 3 ]; then
+              echo "::warning::Bitsycore publish attempt $attempt failed - retrying"
+              sleep 30
+            fi
+          done
+          echo "::error::Bitsycore publish failed after 3 attempts"
+          exit 1
+
+      # Release binaries for the host target - the binary plus the data.kres
+      # (bundled composeResources + fonts + subset icon-font). Each app's
+      # linkReleaseExecutable<Target> auto-runs its data.kres zip task -
+      # :demo's own copy<Variant>ComposeResources<Target>, :apidemo's
+      # bridge-plugin package<Variant>ComposeResources<Target> - so data.kres
+      # is produced next to the .kexe / .exe. On Linux only linuxX64 is built -
       # linuxArm64 is skipped since the SDL3 static libs on the ubuntu runner
       # are host-arch (x64).
       - name: Build demo + apidemo release binaries
@@ -162,20 +274,29 @@ jobs:
         shell: bash
         run: |
           set -euo pipefail
-          # Lower-case first letter — gradle target tokens are Capitalised but
+          # Lower-case first letter - gradle target tokens are Capitalised but
           # the build/bin dir uses the plain target name (macosArm64 etc).
           target_dir=$(echo "${{ matrix.target }}" | awk '{print tolower(substr($0,1,1)) substr($0,2)}')
           version="${GITHUB_REF_NAME#v}"
           mkdir -p dist
-          # Windows Git Bash has no `zip`; every runner has JDK 21 → use `jar cf`
-          # which writes a valid ZIP file. `-C dir file` = enter dir then add
-          # `file` at the archive root, so the archive stays flat like `zip -j`.
           for app in demo apidemo; do
             src="$app/build/bin/$target_dir/releaseExecutable"
             zip_path="$(pwd)/dist/$app-$version-$target_dir.zip"
-            jar --create --no-manifest --file "$zip_path" \
-              -C "$src" "$app.${{ matrix.exe_ext }}" \
-              -C "$src" "data.kres"
+            files=("$src/$app.${{ matrix.exe_ext }}" "$src/data.kres")
+            # Windows Skia leg ships two runtime sidecars next to the exe - the
+            # skiko fork DLL and Skia's ICU data (icudtl.dat) - provisioned by the
+            # bridge plugin after linkReleaseExecutableMingwX64. The exe cannot run
+            # without them, so include them (and fail loudly if a provision regressed).
+            if [ "${{ matrix.exe_ext }}" = "exe" ]; then
+              for sidecar in skiko-windows-x64.dll icudtl.dat; do
+                if [ ! -f "$src/$sidecar" ]; then
+                  echo "::error::Missing Windows runtime sidecar: $src/$sidecar"; exit 1
+                fi
+                files+=("$src/$sidecar")
+              done
+            fi
+            python3 -c 'import sys,os,zipfile; z=zipfile.ZipFile(sys.argv[1],"w",zipfile.ZIP_DEFLATED,compresslevel=9); [z.write(f,os.path.basename(f)) for f in sys.argv[2:]]; z.close()' \
+              "$zip_path" "${files[@]}"
           done
           ls -la dist/
 

.gitignore

@@ -53,7 +53,7 @@ bin/
 
 ### Vendored Compose sources ###
 # Byte-for-byte verbatim copies from JetBrains/compose-multiplatform-core,
-# regenerated on demand by scripts/compose-fork/sync.sh. Not committed — only the
+# regenerated on demand by scripts/compose-fork/sync.sh. Not committed - only the
 # sync tooling (script + <module>/compose-fork.txt manifests + pinned ref + README)
 # is tracked.
 **/src/vendor/
@@ -61,3 +61,7 @@ bin/
 ### Python ###
 __pycache__/
 *.pyc
+
+# Probe artifacts written to the repo root by demo --nav3test / --searchesctest / --dialoganimtest
+/*.bmp
+/local.properties

CLAUDE.md

@@ -1,70 +1,134 @@
 # CLAUDE.md
 
 Guidance for Claude Code working in this repository. This is the primary
-context — read it first, then look at the files it points to.
+context - read it first, then look at the files it points to.
+
+## Documentation map
+
+- [README.md](README.md) - public overview + quickstart (bridge plugin,
+  `nativeComposeWindow`, sample apps).
+- Renderer - one Skia `RenderBackend` (Metal on macOS / OpenGL on Linux+Windows /
+  CPU-raster fallback) driving upstream's vendored GraphicsLayer + Canvas engine.
+  Retained per-node display lists: transform / alpha / clip changes REPLAY without
+  re-recording (only a content change or resize re-records; dirty-region rendering
+  is a non-goal). Text is a reduced-local port over Skia `skparagraph`. Read these
+  before touching renderer / graphics-actual / layer-engine code:
+  `SkiaRenderBackend.kt`, `RenderBackend.kt`, `GpuMode.kt`, `ComposeRootHost.kt`
+  (root host + snapshot-observation sweep - omitting `clearInvalidObservations()`
+  once leaked the whole graph), `ComposeOwner.kt`, and `SkiaParagraph.native.kt` /
+  `SkiaParagraphEngine.kt`. Open renderer/fidelity work lives in [PLAN.md](PLAN.md).
+- [TOOLING.md](TOOLING.md) - build/vendor/verify scripts and workflows
+  (build-sdl, sync + drift checks, parity, probe, profiler, coverage,
+  verify-mac) + the version map and the ref-bump / release runbooks.
+- [PLAN.md](PLAN.md) §2 - audited list of no-ops, stubs, and hardcodes left in the
+  port, with P0/P1/P2 severity, plus the road-to-1.0.0 fidelity / SDL / release work
+  (this subsumes the former TODO.md, which was never committed).
+- This file - architecture, module layout, vendoring rules, source-set
+  hierarchy, density flow, conventions, and common pitfalls.
 
 ## What this project is
 
-**ComposeNativeSDL3** — a Kotlin/Native port of Compose Multiplatform running
+**ComposeNativeSDL3** - a Kotlin/Native port of Compose Multiplatform running
 on SDL3, no JVM. Compiles to native binaries for macOS (arm64), Linux
 (x64/arm64), Windows (mingwX64).
 
-Rendering is pluggable behind one `RenderBackend`:
+Rendering is **Skia everywhere** behind one `RenderBackend` - Metal / OpenGL
+/ CPU raster:
 
-- **Skia** (via Skiko klibs) on macOS + Linux — Metal / OpenGL / CPU raster.
-- **SDL3** (`SDL3_ttf` + `SDL_RenderGeometry`) on Windows, and on macOS/Linux
-  when `-Prenderer=sdl3` is passed.
+- **macOS + Linux** link the OFFICIAL Skiko klibs from Maven.
+- **Windows (mingwX64)** links the bitsycore skiko FORK - skiko+Skia compiled
+  into `skiko-windows-x64.dll` with a flat extern-C surface, bound from K/N via
+  an embedded GNU import lib, published to https://maven.bitsycore.com/releases as
+  `com.bitsycore.skiko:skiko:0.150.1-mingw.2` (override with
+  `-PskikoMingwVersion`). The runtime DLL is auto-provisioned next to the exe by
+  the bridge plugin (`installWindowsSkiaDll`).
 
 Windowing, input, audio, filesystem access, and the OS-integration surface
 (file dialogs, clipboard, "open in Finder/Explorer"…) all go through
 **SDL3**. The runtime (`androidx.compose.runtime.*`: composition, snapshots,
 recomposer, `mutableStateOf`, `remember`, …) is the **official
-`org.jetbrains.compose.runtime` klibs from Maven** — this project only
+`org.jetbrains.compose.runtime` klibs from Maven** - this project only
 re-implements the layers on top (`androidx.compose.ui.*`, `.foundation.*`,
 `.animation.*`, `.material3.*`).
 
 ## Module layout
 
 Library modules mirror upstream Compose Multiplatform's `compose/` tree.
-Only `:window` is the SDL integration layer ("Compose SDL" — SDL3 main loop)
-and lives under `compose/sdl/`.
+The SDL layer is two modules: `:sdl-core` (the NAKED sdl3 cinterop + platform
+primitives - zero Compose dep, like `skiko`) at `sdl/sdl-core/`, and
+`:desktop-native-window` (the SDL3 main-loop shell + app entry point) at
+`compose/desktop/native/desktop-native-window/`. `:ui` depends on `:sdl-core` and its renderer
++ SDL↔Compose bridges pick the cinterop from it.
 
 One Gradle module per upstream artifact; the directory mirrors the upstream
-`compose/` path, the gradle path is kept short (redirected via `projectDir`).
+`compose/` path, and the gradle path mirrors the directory (no `projectDir`
+redirection).
 
 ```
 compose/
 ├── ui/
-│   ├── ui/                          → :ui        — androidx.compose.ui.* (ui + ui-graphics + ui-text) +
-│   │                                               com.compose.sdl.* — cinterops + BOTH renderer pipelines live
-│   │                                               here. ui-graphics/ui-text can't split off: their Canvas /
-│   │                                               Paragraph `expect`s are the renderers' `actual`s (same-module).
-│   ├── ui-util/                     → :ui-util       — androidx.compose.ui.util.* (+ Experimental/InternalComposeUiApi)
-│   ├── ui-geometry/                 → :ui-geometry   — androidx.compose.ui.geometry.*
-│   ├── ui-unit/                     → :ui-unit       — androidx.compose.ui.unit.*
-│   └── ui-backhandler/              → :ui-backhandler — androidx.compose.ui.backhandler.*
+│   ├── ui/                          → :compose:ui:ui        - androidx.compose.ui.* CORE (Modifier, LayoutNode,
+│   │                                               composition, semantics, input, focus) + com.compose.sdl.* -
+│   │                                               the Skia RenderBackend + GPU bridges + the SDL↔Compose
+│   │                                               bridges (events / clipboard / cursors / window). Depends on
+│   │                                               :ui-graphics, :ui-text, :sdl-core. (ui-graphics + ui-text +
+│   │                                               the sdl3 cinterop were split OUT - upstream layout.)
+│   ├── ui-graphics/                 → :compose:ui:ui-graphics - androidx.compose.ui.graphics.* + the Skia actuals
+│   │                                               (SkiaBackedCanvas/Path/Paint, GraphicsLayer, SkiaImageCache,
+│   │                                               painter/image + resource seams). → skiko; SDL-free.
+│   ├── ui-text/                     → :compose:ui:ui-text   - androidx.compose.ui.text.* + the skiko text engine
+│   │                                               (SkiaParagraph → NativeParagraphOps → SkiaFonts, IconFont,
+│   │                                               NamedFont). → :ui-graphics, skiko; SDL-free.
+│   ├── ui-util/                     → :compose:ui:ui-util       - androidx.compose.ui.util.* (+ Experimental/InternalComposeUiApi)
+│   ├── ui-geometry/                 → :compose:ui:ui-geometry   - androidx.compose.ui.geometry.*
+│   ├── ui-unit/                     → :compose:ui:ui-unit       - androidx.compose.ui.unit.*
+│   ├── ui-backhandler/              → :compose:ui:ui-backhandler - androidx.compose.ui.backhandler.*
+│   └── ui-tooling-preview/          → :compose:ui:ui-tooling-preview - androidx.compose.ui.tooling.preview.*
+│                                                     (the common @Preview + PreviewParameterProvider,
+│                                                     vendored verbatim; the Maven artifact ships no
+│                                                     mingwX64/linux klibs). IDE-only metadata - previews
+│                                                     render through the apps' jvm parity targets.
 ├── animation/
-│   ├── animation-core/              → :animation-core     — androidx.compose.animation.core.*
-│   ├── animation/                   → :animation          — androidx.compose.animation.* (non-core)
-│   └── animation-graphics/          → :animation-graphics — androidx.compose.animation.graphics.*
+│   ├── animation-core/              → :compose:animation:animation-core     - androidx.compose.animation.core.*
+│   ├── animation/                   → :compose:animation:animation          - androidx.compose.animation.* (non-core)
+│   └── animation-graphics/          → :compose:animation:animation-graphics - androidx.compose.animation.graphics.*
 ├── foundation/
-│   ├── foundation/                  → :foundation       — androidx.compose.foundation.*
-│   └── foundation-layout/           → :foundation-layout — androidx.compose.foundation.layout.*
+│   ├── foundation/                  → :compose:foundation:foundation       - androidx.compose.foundation.*
+│   └── foundation-layout/           → :compose:foundation:foundation-layout - androidx.compose.foundation.layout.*
 ├── material3/
-│   └── material3/                   → :material3   — androidx.compose.material3.*
+│   └── material3/                   → :compose:material3:material3   - androidx.compose.material3.*
 ├── material/
-│   └── material-ripple/             → :material-ripple — androidx.compose.material.ripple.*
-└── sdl/                             ("Compose SDL" — project modules, not upstream CMP artifacts)
-    └── window/                      → :window     — nativeComposeApp { Window(...) {} } multi-window
-                                                    shell + SDL3 main loop; nativeComposeWindow() wrapper
+│   └── material-ripple/             → :compose:material:material-ripple - androidx.compose.material.ripple.*
+└── desktop/native/desktop-native-window/ → :compose:desktop:native:desktop-native-window - nativeComposeApp { Window(...) {} }
+                                                    multi-window shell + SDL3 main loop; nativeComposeWindow()
+                                                    wrapper (project app-shell, not an upstream CMP artifact).
+                                                    Published as com.bitsycore.compose:desktop-native-window.
+
+sdl/
+└── sdl-core/                        → :sdl:sdl-core   - the NAKED sdl3 cinterop + platform primitives
+                                                    (zero Compose dep, like skiko); the single `sdl3` cinterop
+                                                    lives here. :ui depends on it. com.bitsycore.compose.sdl:sdl-core.
 
 utils/
-└── material-symbols/                → :material-symbols — codepoints + all three style objects
-                                                    (Outlined / Rounded / Sharp). Apps get one dep;
-                                                    the consumer Zip task bundles only the fonts used.
+└── material-symbols/                → :utils:material-symbols - codepoints + all three style objects
+                                                    (Outlined / Rounded / Sharp). COMMON API (usable from
+                                                    shared app code) + per-stack actuals: native renders
+                                                    via :foundation IconFontIcon (Skia), jvm() via Skiko directly
+                                                    (Typeface.makeClone per axes - upstream's FontCache
+                                                    drops variationSettings from its key). Its commonMain
+                                                    declares official Maven compose coords - the root
+                                                    build's FULL-COMMONIZATION BRIDGE substitutes the
+                                                    whole ui / foundation / animation / material3 /
+                                                    nav3-ui / components-resources family to project
+                                                    modules on native configs
+                                                    (:demo and :apidemo commonMains rely on the same
+                                                    bridge; :compose-desktop-native-bridge ships it to
+                                                    consumers). Apps get one dep; the consumer Zip task
+                                                    bundles only the fonts used (native) and
+                                                    jvmProcessResources stages the same fonts (jvm).
 
 components/
-└── resources/library/               → :components-resources — the OFFICIAL Compose resources
+└── resources/components-resources/  → :components:resources:components-resources - the OFFICIAL Compose resources
                                                     runtime (org.jetbrains.compose.components:
                                                     components-resources), VENDORED from the
                                                     compose-multiplatform UMBRELLA repo (the first
@@ -72,13 +136,61 @@ components/
                                                     no mingwX64/linux klibs. Platform layer is project
                                                     code: data.kres ResourceReader, pure-Kotlin
                                                     DomXmlParser (upstream's is Darwin NSXMLParser),
-                                                    SDL3_image decode via the :ui EncodedImageDecoder
-                                                    hook, NamedFont registration, SDL locale/theme env.
-                                                    Apps' JVM targets keep the Maven artifact — the
+                                                    image decode via the :ui EncodedImageDecoder hook
+                                                    (Skia), NamedFont registration, SDL locale/theme env.
+                                                    Apps' JVM targets keep the Maven artifact - the
                                                     generated Res accessors work against BOTH.
 
+koin/                → the Koin DI modules upstream stops publishing for desktop native.
+├── koin-core-viewmodel/             → :koin:koin-core-viewmodel   - org.koin.viewmodel.* + module DSL
+├── koin-compose/                    → :koin:koin-compose           - org.koin.compose.*
+├── koin-compose-viewmodel/          → :koin:koin-compose-viewmodel - org.koin.compose.viewmodel.*
+└── koin-compose-navigation3/        → :koin:koin-compose-navigation3 - org.koin.compose.navigation3.*
+                                                    VENDORED verbatim from InsertKoinIO/koin
+                                                    (KOIN_REF). koin-core ITSELF publishes mingwX64
+                                                    + linux and is a plain Maven dep - only these
+                                                    four stop at apple+android upstream. NOTE it is
+                                                    the NAV3 module, not koin-compose-viewmodel-
+                                                    navigation: that one sits on nav2's
+                                                    navigation-compose, which has no mingwX64/linux
+                                                    klibs under EITHER coordinate set.
+                                                    com.bitsycore.koin:<module>.
+
+coil/                → Coil 3 image loading. Upstream ships linux but NO mingwX64 for
+│                      core/network/svg, and NO desktop native at all for the compose
+│                      layer. VENDORED verbatim from coil-kt/coil (COIL_REF).
+├── coil-core/                       → :coil:coil-core            - coil3.* core, Skia-based decode
+├── coil/                            → :coil:coil                 - singleton ImageLoader facade
+├── coil-compose-core/               → :coil:coil-compose-core    - AsyncImage internals
+├── coil-compose/                    → :coil:coil-compose         - public compose entry points
+├── coil-svg/                        → :coil:coil-svg             - SVG via skiko SVGDOM
+├── coil-network-core/               → :coil:coil-network-core    - fetcher plumbing
+└── coil-network-ktor3/              → :coil:coil-network-ktor3   - Ktor 3 fetcher
+                                                    Upstream's nonAndroid / nonJvmCommon /
+                                                    nonJsCommon sets all apply here (no android /
+                                                    jvm / js target) but must stay ABOVE nativeMain
+                                                    - they declare expects whose actuals live in
+                                                    nativeMain. coil-core / coil-svg /
+                                                    coil-compose-core use org.jetbrains.skia
+                                                    directly, so they carry TWO PARALLEL skiko
+                                                    branches (official for macOS/Linux, the
+                                                    bitsycore fork for mingwX64) exactly like
+                                                    :compose:ui:ui-graphics. com.bitsycore.coil3:<m>.
+
+pulse/               → Pulse MVI. Upstream (bitsycore/pulse-mvi, PULSE_REF) targets
+│                      android / jvm / ios / js / wasm and publishes NO desktop-native
+│                      artifact, so all four modules are vendored. commonMain only.
+├── pulse/                           → :pulse:pulse            - MVI core (store/state/intents)
+├── pulse-viewmodel/                 → :pulse:pulse-viewmodel  - ViewModel binding
+├── pulse-savedstate/                → :pulse:pulse-savedstate - SavedStateHandle persistence
+└── pulse-compose/                   → :pulse:pulse-compose    - Compose bindings
+                                                    Published as com.bitsycore.pulse:<module>, NOT
+                                                    upstream's com.bitsycore.lib:<module> - the two
+                                                    must not collide; the bridge substitutes the
+                                                    upstream coord on native configs.
+
 navigation3/
-└── navigation3-ui/                  → :navigation3-ui — androidx.navigation3.ui.* + scene machinery,
+└── navigation3-ui/                  → :navigation3:navigation3-ui - androidx.navigation3.ui.* + scene machinery,
                                                     VENDORED verbatim from upstream (SET_FOLDER manifest).
                                                     Navigation 3's runtime layers (navigation3-runtime,
                                                     lifecycle-viewmodel-navigation3) are real Maven KMP
@@ -89,71 +201,140 @@ navigation3/
                                                     (700ms fades, predictive-pop spring/scaleOut) because
                                                     the upstream macos actual ships all-None (no animation).
 
-demo/                → :demo      — flagship showcase app (30+ screens) + the CLI probe suite.
+demo/                → :demo      - flagship showcase app (30+ screens) + the CLI probe suite.
                                     MULTIPLATFORM: also has a jvm() target running the SAME shared
                                     screens on stock JVM Compose Desktop (`./gradlew :demo:run`,
-                                    MainJvmKt) — the parity reference; differences vs native = port bugs
-apidemo/             → :apidemo   — Postman-style REST API manager
-scripts/             → vendor-sync + python helper scripts (compose-fidelity/coverage,
-                      material-symbols generate/subset) + compose-fork/;
-                      scripts/build-sdl/ = Windows static-lib build scripts (bash)
-libs/                → gitignored per-host static SDL3 / SDL3_ttf / SDL3_image / FreeType
-                      output of scripts/build-sdl/build-*.sh on Windows
+                                    MainJvmKt) - the parity reference; differences vs native = port bugs
+apidemo/             → :apidemo   - Postman-style REST API manager. MULTIPLATFORM like :demo
+                                    (`./gradlew :apidemo:run`): the whole UI lives in commonMain
+                                    against the official Maven coords; SDL-backed APIs go through
+                                    expect/actual seams (compat/Compat.kt - native actuals delegate
+                                    to com.compose.sdl, jvm actuals use AWT + upstream desktop).
+                                    mTLS / TLS-chain inspection stays native-only (bundled libcurl).
+                                    DOGFOODS the bridge plugin: data.kres packaging + app icon come
+                                    from compose.desktop.native {}; the font pipeline (Noto +
+                                    Material Symbols subsetting) comes from the shared buildSrc
+                                    helper (registerComposeFontBundling).
+buildSrc/            → shared build logic for the app modules: ComposeFontBundling.kt -
+                      registerComposeFontBundling { } (everything OPT-IN; no flag = no-op)
+                      registers downloadNotoFonts (bundleNotoSans / bundleNotoSansMono /
+                      autoDetectNotoSansMono), detects the Material Symbols styles the
+                      sources use (bundleMaterialSymbols), wires the font/ entries into
+                      every data.kres Zip (the bridge plugin's package* tasks; hand-rolled
+                      copy*ComposeResources* tasks also match) and stages the same fonts on
+                      the JVM classpath; hb-subset pipeline behind enableIconSubsetting
+                      (findMaterialSymbolsUsage + subsetMaterialSymbols<Style>).
+gradle-plugin/
+└── compose-desktop-native-bridge/ → the CONSUMER-side bridge as a published Gradle plugin
+                                    (id com.bitsycore.compose-desktop-native.bridge, applies to
+                                    Settings or Project). An INCLUDED build (pluginManagement.
+                                    includeBuild in settings.gradle.kts), NOT a subproject - a
+                                    plugins{} block can only resolve plugins from repositories or
+                                    included builds; :demo and :apidemo apply it from source
+                                    (dogfooding: data.kres packaging - and apidemo's app icon -
+                                    run through the plugin).
+                                    Three halves: (1) substitution - third-party apps declare
+                                    OFFICIAL CMP coords in commonMain and native configurations
+                                    swap in the published com.bitsycore.compose.sdl klibs
+                                    (version defaults to the plugin's own; override:
+                                    composeDesktopNative.version property; disable:
+                                    composeDesktopNative.substitution=false - set repo-wide in
+                                    gradle.properties since the root build's FULL-COMMONIZATION
+                                    BRIDGE substitutes to project modules in-repo); (2) data.kres
+                                    packaging (package<Variant>ComposeResources<Target> per native
+                                    executable, honours -PcompressResources); (3) the
+                                    compose.desktop.native { entryPoint / icon {} } DSL (.rgba
+                                    runtime icons + windres .exe embed - injected into
+                                    hand-declared executables too). Published by the WINDOWS
+                                    publish job.
+scripts/             → vendor-sync + python helper scripts (compose-coverage = API
+                      coverage/fidelity vs upstream, material-symbols generate/subset)
+                      + compose-fork/;
+                      scripts/build-sdl/ = static-lib build script (python)
+libs/                → gitignored per-host static SDL3 output of
+                      scripts/build-sdl/build-all.py on Windows
 ```
 
-Module PATHS stay short (`:ui`, `:foundation`, `:window`, …) —
-`settings.gradle.kts` redirects `projectDir` for each so build files across
-the repo stay terse. `androidx.collection` is a plain Maven dependency
-(`androidx.collection:collection`), not a module — same as other simple
+Module PATHS mirror the DIRECTORY 1:1 - `:compose:ui:ui`,
+`:compose:foundation:foundation`, `:compose:desktop:native:desktop-native-window`,
+`:sdl:sdl-core`, `:utils:material-symbols`, `:navigation3:navigation3-ui`,
+`:components:resources:components-resources`. There is NO `projectDir` redirection in
+`settings.gradle.kts`; a plain `include(...)` per module is the whole story, and
+the intermediate container projects (`:compose`, `:compose:ui`, …) hold no code.
+
+**INVARIANT: the leaf directory IS the published artifactId.** Don't break it to
+mirror an upstream directory name. KMP derives every target publication's
+coordinate as `<project.name>-<target>`, and a target DISABLED on the building
+host (all Apple targets on Windows/Linux) has no publication object to retarget
+afterwards - while the root `kotlinMultiplatform` metadata, which the WINDOWS
+publish job owns, still emits an `available-at` for it. A mismatched leaf
+therefore ships a root module pointing at a nonexistent `<leaf>-macosarm64`,
+breaking macOS consumers, and no `artifactId = …` override can reach it. Two
+directories are renamed away from upstream's layout to hold this:
+`compose/desktop/native/desktop-native-window` (upstream: `window`) and
+`components/resources/components-resources` (upstream: `library` + a hand-set
+artifactId). `scripts/compose-coverage.py`'s `kTargets` carries the
+upstream→local mapping for the latter.
+
+`androidx.collection` is a plain Maven dependency
+(`androidx.collection:collection`), not a module - same as other simple
 androidx KMP libs.
 
 ## Dependency graph
 
+Written with LEAF names for readability (`:ui` = `:compose:ui:ui`,
+`:foundation` = `:compose:foundation:foundation`, …); build files use the full
+path shown in the module layout above.
+
 ```
 :ui  ←  :animation-core  ←  :animation          ←  :foundation  ←  :material3  ← :demo, :apidemo
 :ui  ←  :foundation-layout  ←──────────────────────┘   ↑              ↑
                         :material-ripple  ←────────────┘──────────────┘
-:foundation, :animation-core  ←  :window ;  :foundation, :material3  ←  :material-symbols
+:foundation, :animation-core  ←  :desktop-native-window ;  :foundation, :material3  ←  :material-symbols
 ```
 
 All edges are `api`, so a consumer of `:foundation` / `:material3` transitively
 sees the split modules. Full DAG: `:ui-util → collection`; `:ui-geometry → :ui-util`;
 `:ui-unit → :ui-geometry, :ui-util`; `:ui-backhandler → :ui-util, navigationevent`;
-`:ui → :ui-util, :ui-geometry, :ui-unit, :ui-backhandler`; `:animation-core → :ui`;
+`:sdl-core → sdl3 cinterop (NAKED - no Compose)`;
+`:ui-graphics → :ui-geometry, :ui-unit, :ui-util, skiko`;
+`:ui-text → :ui-graphics, :ui-unit, :ui-util, skiko`;
+`:ui → :ui-graphics, :ui-text, :sdl-core, :ui-util, :ui-geometry, :ui-unit, :ui-backhandler`; `:animation-core → :ui`;
 `:foundation-layout → :ui`; `:animation → :animation-core, :foundation-layout`;
 `:foundation → :animation, :foundation-layout, :animation-core, :ui`;
 `:material-ripple → :foundation, :animation-core`;
 `:material3 → :foundation, :material-ripple, :animation-core, :foundation-layout`.
 
-`:ui` is the renderer/cinterop hub (the ui-graphics + ui-text `expect`s resolve to
-its SDL/Skia renderer `actual`s). The pure lower artifacts (`:ui-util`,
-`:ui-geometry`, `:ui-unit`, `:ui-backhandler`) are split out below it. Everything
-above `:ui` can only touch renderer / cinterop internals via its public surface.
-`:window` depends on `:ui` + `:foundation` (needs `LazyList`-style scaffolding to
+`:ui` is the Compose core + the Skia RenderBackend + the SDL↔Compose bridges; it
+sits on `:ui-graphics` / `:ui-text` (the graphics/text primitives + their skiko
+`actual`s, SDL-free) and the naked `:sdl-core` (sdl3 cinterop). The pure lower
+artifacts (`:ui-util`, `:ui-geometry`, `:ui-unit`, `:ui-backhandler`) are below.
+Everything above `:ui` touches renderer internals only via its public surface.
+`:desktop-native-window` depends on `:ui` + `:foundation` (needs `LazyList`-style scaffolding to
 install the popup / scaffold layer at the composition root).
 
-## Vendoring philosophy — read this before writing any `androidx.compose.*` code
+## Vendoring philosophy - read this before writing any `androidx.compose.*` code
 
 **Prefer vendoring verbatim from upstream Compose Multiplatform over hand-rolling anything.**
 
 Every module that ships `androidx.compose.*` code carries a
 `<module>/compose-fork.txt` manifest. Each one declares its upstream repo +
 pinned ref up top with `SET_REPO=<https-url>@<ref>`, where `<ref>` is normally a
-`<VARNAME>` resolved from `scripts/compose-fork/compose.properties` — a
+`<VARNAME>` resolved from `scripts/compose-fork/compose.properties` - a
 `NAME=value` file that version-tags every pinned ref in ONE place (e.g.
 `COMPOSE_CORE_REF` for compose-multiplatform-core, `COMPOSE_REF` for the
 compose-multiplatform umbrella repo that `:components-resources` vendors from).
-There is no implicit default — `SET_REPO` is required. `scripts/compose-fork/sync.sh`
+There is no implicit default - `SET_REPO` is required. `scripts/compose-fork/sync.sh`
 walks all manifests and copies each selected file byte-for-byte from the pinned
 checkout (each distinct repo sparse-cloned to `../cmp-ref[-<name>]`) into
-`<module>/src/vendor/{common,native,skikoRenderer,sdlRenderer}/kotlin/`. The
-`src/vendor/` tree is **gitignored** — you don't check it in, you re-sync
+`<module>/src/vendor/{common,native,skikoRenderer}/kotlin/`. The
+`src/vendor/` tree is **gitignored** - you don't check it in, you re-sync
 on demand.
 
 Manifests are **folder-style**: a `SET_FOLDER=<module>/src` line sets an upstream
 base, then `<sourceSet>/kotlin/ -> src/vendor/<area>/kotlin/` grabs a whole
 source set (every `.kt` under it). `!<sourceSet>/kotlin/<pkg>/<File>.kt` refuses
-one file inside a grabbed folder — use it for files hand-vendored + edited under
+one file inside a grabbed folder - use it for files hand-vendored + edited under
 `src/{commonMain,…}` so the folder copy doesn't shadow them, or for upstream
 files the port doesn't want. A plain `<src> -> <dest>` still pins (or renames on
 copy) a single file. Re-declare `SET_FOLDER` to draw from a second upstream module
@@ -162,17 +343,17 @@ manifest in place: commented `#     | src -> dest` lines under each folder
 directive list what it expands to, and a trailing `# >>> DIAGNOSTIC GAPS` block
 lists every upstream `.kt` under SET_FOLDER that no directive selects (grouped by
 source set) so new upstream files surface as comments to uncomment. That whole
-annotated tail is generated — never hand-edit it; edit only the directives up
+annotated tail is generated - never hand-edit it; edit only the directives up
 top and re-run sync.
 
 Two categories of code live in each module:
 
-1. **Vendored (in `src/vendor/…`)** — copied byte-for-byte from upstream.
+1. **Vendored (in `src/vendor/…`)** - copied byte-for-byte from upstream.
    Never hand-edit these. If upstream diverges, adjust the manifest or the
    pinned ref and re-sync. This is the bulk of the codebase (~1500 files
    across the modules).
-2. **Project code (in `src/commonMain/`, `src/nativeMain/`, `src/skikoRendererMain/`,
-   `src/sdlRendererMain/`)** — code we author (project actuals, glue between
+2. **Project code (in `src/commonMain/`, `src/nativeMain/`,
+   `src/skikoRendererMain/`)** - code we author (project actuals, glue between
    Compose and SDL3, project-specific extensions).
 
 ### The 5 rules for adding upstream Compose surface
@@ -190,93 +371,107 @@ Two categories of code live in each module:
    `src/vendor/native/kotlin/`).
 
 3. **If an upstream file needs a small edit to compile / behave
-   correctly for us, copy it locally and edit — MANUAL VENDORING,
+   correctly for us, copy it locally and edit - MANUAL VENDORING,
    NON-IDEMPOTENT.** Move it OUT of `src/vendor/` into the corresponding
    `src/{commonMain,nativeMain,…}` tree, add a header comment noting
    which upstream file it derived from and what changed, and comment
-   its line out of `compose-fork.txt`. Now it's a project file — the
-   next sync won't overwrite it, and future upstream changes to that
-   file need to be reconciled by hand. This is fine; do it when the
-   edit is small and the file is unlikely to churn upstream.
+   its line out of `compose-fork.txt`. **ALWAYS also add the
+   machine-readable provenance line** so the copy can be diffed against
+   its base and against later upstream versions:
 
-4. **Skiko-specific things go in `:ui/src/skikoRendererMain/`, with
-   an SDL3 equivalent in `:ui/src/sdlRendererMain/`.** When upstream
-   ships a `.skiko.kt` file that uses Skiko's Canvas / Paragraph / …,
-   the `.skiko.kt` variant is fine to vendor into `skikoRendererMain`.
-   Then hand-roll (or minimally vendor) the SDL3 counterpart in
-   `sdlRendererMain` — `SkiaCanvas.kt` ↔ `Sdl3Canvas.kt`,
-   `SkiaTextRenderer.kt` ↔ `Sdl3TextRenderer.kt` (using SDL3_ttf +
-   FreeType), `SkiaImageCache.kt` ↔ `Sdl3ImageCache.kt` (using SDL3_image).
+   ```
+   // VENDOR-BASE: <upstream-repo-relative-path> @ <pinned-tag>
+   // VENDOR-BASE(COMPOSE_REF): <path> @ <tag>     ← for umbrella-repo files
+   ```
+
+   A file that is a fresh REIMPLEMENTATION rather than a derived copy (same
+   package + signatures, different body - see the fallback rule at the end of
+   this section) gets `// VENDOR-REIMPL: <path> @ <tag>` instead. That marks it
+   as deliberately NOT drift-tracked: upstream edits to the counterpart need no
+   reconciling, only a SIGNATURE change does.
+   `scripts/compose-fork/audit-exclusions.py` classifies every `!` exclusion as
+   manual vendor / reimpl / orphan and FAILS on any local counterpart carrying
+   neither marker, so nothing rots invisibly.
+
+   `scripts/compose-fork/check-vendor-drift.py` reads the VENDOR-BASE lines at
+   every ref bump: it flags any file whose recorded base lags the current pin and
+   (with the local clone) reports whether the upstream base ACTUALLY
+   changed base..pin - i.e. whether the copy needs hand-reconciling or
+   just a ref re-stamp. Now it's a project file - the next sync won't
+   overwrite it, and future upstream changes to that file need to be
+   reconciled by hand. This is fine; do it when the edit is small and
+   the file is unlikely to churn upstream.
+
+4. **Skiko-specific things go in a `skikoRendererMain` source set.** When
+   upstream ships a `.skiko.kt` file that uses Skiko's Canvas / Paragraph / …,
+   the `.skiko.kt` variant is fine to vendor into `skikoRendererMain` - graphics
+   into `:ui-graphics` (`SkiaBackedCanvas.skiko.kt`, `SkiaImageCache.kt`, …),
+   text into `:ui-text` (`SkiaParagraphEngine.kt`), the render backend into
+   `:ui` (`SkiaRenderBackend.kt`). All native targets attach this source set;
+   mingwX64 layers its fork actuals on top under `skikoRendererMingwMain`.
 
 5. **Multi-OS project code goes through SDL3, not hand-rolled per-target
    ifdefs.** SDL3 already handles the platform differences for filesystem
    paths (`SDL_GetBasePath`, `SDL_GetPrefPath`), clipboard, cursor,
    fullscreen, high-DPI, subprocess launch, MessageBox, and more.
-   `file dialog / "reveal in Finder or Explorer" / app-data path` — do
+   `file dialog / "reveal in Finder or Explorer" / app-data path` - do
    it through SDL3 first, hand-roll the target-specific version only if
    SDL3 doesn't expose it (currently the file-open/save dialog uses
    SDL3's `SDL_ShowOpenFileDialog` / `SDL_ShowSaveFileDialog`).
 
 If a piece of upstream is too Compose-specific to make sense on our
 stack (e.g. Android AWT layer, iOS `UIView`, JVM `Toolkit`), do a fresh
-reimpl in project code — same signature (same package, same params) so
+reimpl in project code - same signature (same package, same params) so
 call sites don't care.
 
 ## Source-set hierarchy (:ui only)
 
-`:ui` owns cinterops + both renderer pipelines. Its source-set tree:
+`:ui` owns the Skia RenderBackend + GPU bridges. The SAME source-set tree is used
+by `:ui-graphics` / `:ui-text` for their skiko `actual`s (only the deps differ);
+the `sdl3` cinterop lives in `:sdl-core` (see below). `:ui`'s tree:
 
 ```
 commonMain
 └── nativeMain                                  (vendored .native.kt + project native code)
-      ├── skikoRendererMain                     (Skia drawing pipeline; Skiko on classpath)
-      │     ├── skikoRendererMacosMain          (macOS-only Skia actuals — Metal bridge)
-      │     └── skikoRendererLinuxMain          (Linux-only Skia actuals — OpenGL)
-      │            attached to: macosArm64Main / linuxX64Main / linuxArm64Main
-      │            ONLY when the Skia renderer is active for the target.
-      └── sdlRendererMain                       (SDL3 drawing pipeline + TTF/image/FreeType)
-            ├── sdlRendererMacosMain            (macOS-only SDL3 driver hint)
-            ├── sdlRendererLinuxMain            (Linux-only SDL3 driver hint)
-            └── sdlRendererMingwMain            (mingwX64-only SDL3 driver hint)
-                   attached to: mingwX64Main always; macOS/Linux when -Prenderer=sdl3.
+      ├── skikoRendererMain                     (Skia drawing pipeline; official Skiko on classpath)
+      │     ├── skikoRendererMacosMain          (macOS-only Skia actuals - Metal bridge)
+      │     └── skikoRendererLinuxMain          (Linux-only Skia actuals - OpenGL)
+      │            attached to: macosArm64Main / linuxX64Main / linuxArm64Main.
+      └── skikoRendererMingwSharedMain
+            └── skikoRendererMingwMain          (mingwX64-only Skia actuals - the bitsycore
+                                                 skiko FORK: skiko-windows-x64.dll bound via
+                                                 an embedded GNU import lib; OpenGL context)
+                   attached to: mingwX64Main.
 ```
 
-`createRenderBackend(…)` + `rendererPreferredGpuMode()` are declared identically
-in both `skikoRendererMain` and `sdlRendererMain`. `:window` calls them straight
-from `:ui` — no `expect`/`actual`, no factory layer — and the right impl
-resolves because **only one of the two renderer source sets is attached to a
-given target**. Under `-Prenderer=sdl3`, the `skikoRenderer*` source sets are
-**not even created**, so Gradle has nothing to warn about and Skiko is never
-pulled in.
+`createRenderBackend(…)` + `rendererPreferredGpuMode()` are `expect`s in
+`:ui`'s nativeMain with `actual`s in `skikoRendererMain` (shared by every native
+target). `rendererPreferredGpuMode()` picks Metal on macOS, OpenGL on
+Linux + Windows, with a Software (CPU raster) auto-fallback if the GPU context
+fails to come up.
 
-### Cinterop sibling-dependency gotcha
+### Cinterop
 
-`:ui` owns four cinterops in `src/nativeInterop/cinterop/`:
-`sdl3`, `sdl3_ttf`, `sdl3_image`, `freetype`. The `.def` files for `sdl3_ttf` /
-`sdl3_image` carry `depends = sdl3` so their `SDL_Surface` / `SDL_Color`
-references resolve to the *same* types `sdl3` produces (not duplicates inside
-`sdl3_image.SDL_Surface`). **Gradle does not automatically add a sibling
-cinterop's klib to a cinterop task's `-library` list**, so the manifest
-directive silently fails and you get cryptic
-`expected CPointer<sdl3.SDL_Surface>?, actual CPointer<sdl3_image.SDL_Surface>?`
-errors.
+The `sdl3` cinterop lives in the NAKED `:sdl-core` module
+(`sdl/sdl-core/src/nativeInterop/cinterop/sdl3.def`: SDL_Window / SDL_Event /
+SDL_GetBasePath / clipboard / dialogs / GL+Metal context / SDL_Renderer-for-CPU-
+raster). `:ui` depends on `:sdl-core` (`api`), so `:ui`'s renderer + SDL↔Compose
+bridges - and `:desktop-native-window` downstream - see `sdl3.*` and inherit SDL3's static-lib +
+linker-opt propagation (the `.def` bakes in `staticLibraries = libSDL3.a` + the
+per-OS `linkerOpts`, carried through the klib chain to the final exe, so apps
+link SDL just by depending on `:ui`/`:desktop-native-window`). `:sdl-core` has NO Compose
+dependency, so `:ui → :sdl-core` is cycle-free - the compose way (like `ui → skiko`).
 
-`:ui/build.gradle.kts` works around this by passing the sdl3 cinterop output
-klib path explicitly via `extraOpts("-library", vSdl3Klib)` on `sdl3_ttf` /
-`sdl3_image`, plus a task dependency
-(`cinteropSdl3_ttf*Target.dependsOn(cinteropSdl3*Target)`). If you ever add
-another `depends = sdl3` cinterop, add it to that list too.
-
-## Density flow (Option B — layout in physical pixels)
+## Density flow (Option B - layout in physical pixels)
 
 We use the **physical-pixel layout flow** on HiDPI. Concretely:
 
 - `SDL_WINDOW_HIGH_PIXEL_DENSITY` is set on the SDL window.
-- `LocalDensity` = the DPR (2.0 on Retina, 1.0 otherwise) — from
+- `LocalDensity` = the DPR (2.0 on Retina, 1.0 otherwise) - from
   `pixelWidth / windowWidth`.
 - Constraints passed to `rootNode.measure(…)` are the **physical pixel** size,
   not logical points.
-- `renderBackend.beginFrame(1f)` — no renderer-side scale; layout already ran
+- `renderBackend.beginFrame(1f)` - no renderer-side scale; layout already ran
   in physical pixels.
 - Pointer coords from SDL are logical points; they're multiplied by DPR
   before dispatch so the whole event pipeline is in the same physical-px
@@ -285,7 +480,7 @@ We use the **physical-pixel layout flow** on HiDPI. Concretely:
 Consequence: `Modifier.width(20.dp)` at density 2 → 40 physical pixels wide.
 `onSizeChanged { it.width }` reports physical pixels. If you're passing pixel
 integers into pixel-based modifiers, use the lambda forms
-(`Modifier.offset { IntOffset(x, y) }`) — they take pixels directly.
+(`Modifier.offset { IntOffset(x, y) }`) - they take pixels directly.
 Passing raw `px.dp` will double-scale on Retina.
 
 ## Building
@@ -299,130 +494,147 @@ Passing raw `px.dp` will double-scale on Retina.
 ./gradlew :demo:runDebugExecutableLinuxX64
 ./gradlew :apidemo:runDebugExecutableLinuxX64
 
-# Windows (from Windows — mingw cross-build from macOS/Linux fails at cinterop)
+# Windows (from Windows - mingw cross-build from macOS/Linux fails at cinterop).
+# Links the bitsycore skiko FORK from maven.bitsycore.com (com.bitsycore.skiko:skiko:
+# 0.150.1-mingw.2, override -PskikoMingwVersion); the bridge plugin drops
+# skiko-windows-x64.dll next to the exe (installWindowsSkiaDll).
 gradlew.bat :demo:runDebugExecutableMingwX64
 gradlew.bat :apidemo:runDebugExecutableMingwX64
 
-# Skiko-free build on macOS/Linux — SDL3 renderer everywhere
-./gradlew :demo:runDebugExecutableMacosArm64 -Prenderer=sdl3
-
-# Stock JVM Compose Desktop (any host) — the parity reference: the SAME shared
-# demo screens on upstream Compose; differences vs the native build = port bugs.
+# Stock JVM Compose Desktop (any host) - the parity reference: the SAME shared
+# screens on upstream Compose; differences vs the native build = port bugs.
 ./gradlew :demo:run
+./gradlew :apidemo:run
 ```
 
 ### System dependencies
 
-**macOS (default Skia build):** `brew install sdl3`. Only need `sdl3_ttf`
-if you set `-Prenderer=sdl3`. Skiko klibs come from Maven.
+SDL3 is **built from source as a static library on every OS** and linked
+straight into the executable - no brew/apt SDL packages. Build it once per host
+with `python scripts/build-sdl/build-all.py`. Per-host toolchain requirements
+and the step breakdown are in [TOOLING.md](TOOLING.md#native-libraries).
 
-**Linux (default Skia build):** `sudo apt install libsdl3-dev`. Same caveat
-for SDL3_ttf.
+Skia comes in through the Skiko klibs: the official Maven ones on macOS/Linux
+(no runtime .so/.dylib - Skia is statically inside the klib), and the bitsycore
+fork on Windows, whose `skiko-windows-x64.dll` the bridge plugin provisions next
+to the exe. So a macOS/Linux distributable is `<app>` + `data.kres`; a Windows
+one is `<app>.exe` + `data.kres` + `skiko-windows-x64.dll`.
 
-**Windows (mingwX64 — always uses SDL3 + SDL3_ttf + SDL3_image + FreeType):**
-these four libraries + image codecs are **linked statically into the
-executable** — no runtime DLLs, distributable is just `<app>.exe` +
-`data.kres`. They're not downloaded — `scripts/build-sdl/build-all.sh` (from Git
-Bash) builds them from source as static libs into a gitignored, in-repo `libs/`
-folder. Needs: git, cmake, mingw-w64 gcc/g++ on PATH, plus curl + python for
-ninja fetch. `scripts/build-sdl/build-all.sh` = `build-freetype.sh` → `build-sdl3.sh` →
-`build-sdl3-image.sh` → `build-sdl3-ttf.sh`.
-
-## Runtime bundling — data.kres
+## Runtime bundling - data.kres
 
 Every app ships `<app>.exe` + `data.kres` (a STORED zip alongside the
 executable, loaded via `SDL_GetBasePath()`). Contents:
 
 - App drawables + files under `composeResources/{drawable,files}/`
-- `font/NotoSans.ttf` — the default variable font, downloaded once by
-  `:ui:downloadNotoFonts` into `compose/ui/build/fonts/`. Pass
-  `-PbundleDefaultFont=false` to skip.
-- `font/NotoSansMono.ttf` — mono body font (apidemo only)
-- Material Symbols fonts for the styles the app **actually uses** — the
-  Zip task scans the app's Kotlin sources for `MaterialSymbolsOutlined` /
-  `Rounded` / `Sharp` and only bundles the fonts referenced.
-- `-PsubsetIcons=true` (default on): `scripts/subset-material-symbols.py`
-  scans app sources for `MaterialSymbols.<Name>` usage and hb-subsets each
-  bundled font down to just those glyphs. Needs `hb-subset` on PATH
-  (`brew install harfbuzz` / `apt install harfbuzz-utils`) — falls back
-  to the full font if absent.
+- `font/NotoSans.ttf` - the default variable font. Bundling it is the APP's
+  job: each app opts in via `registerComposeFontBundling { bundleNotoSans =
+  true; … }` (buildSrc - every flag is opt-in, no flag = no-op), which
+  registers its `downloadNotoFonts` task (into `<app>/build/fonts/`); the
+  library ships no download task. Pass `-PbundleDefaultFont=false` to skip.
+- `font/NotoSansMono.ttf` - `autoDetectNotoSansMono = true` bundles it when
+  `FontFamily.Monospace` appears in the app sources (demo);
+  `bundleNotoSansMono = true` forces it (apidemo's body font, loaded through
+  its own seam)
+- Material Symbols fonts for the styles the app **actually uses**
+  (`bundleMaterialSymbols = true`) - the Zip task scans the app's Kotlin
+  sources for `MaterialSymbolsOutlined` / `Rounded` / `Sharp` and only
+  bundles the fonts referenced.
+- `-PsubsetIcons=true` (default on, opted into per app via
+  `enableIconSubsetting = true` - apidemo yes, demo no):
+  `scripts/subset-material-symbols.py` scans app sources for
+  `MaterialSymbols.<Name>` usage and hb-subsets each bundled font down to
+  just those glyphs. Needs `hb-subset` on PATH (`brew install harfbuzz` /
+  `apt install harfbuzz-utils`) - falls back to the full font if absent.
 
 ## Vendor sync workflow
 
 ```bash
 # Sync every module's compose-fork.txt against the pinned upstream ref.
 scripts/compose-fork/sync.sh
-
-# Sync one module by direct manifest path (module names use ':' → '/' → skip
-# 'compose/' prefix — nested modules like compose/sdl/window pass the full path).
-scripts/compose-fork/sync.sh compose/ui/compose-fork.txt
-
-# Re-format a manifest (align columns, group by upstream folder).
-scripts/compose-fork/format-manifest.py --discover ../cmp-ref \
-    --manifest compose/ui/compose-fork.txt
 ```
 
-Upstream ref: `scripts/compose-fork/compose.properties` — set to a specific commit
-of `JetBrains/compose-multiplatform-core`. Bump the ref → re-sync → let the
-build tell you what broke.
+Upstream refs live in `scripts/compose-fork/compose.properties`, one `NAME=value`
+per repo, each pinned to a durable TAG. Five repos are vendored now:
+`COMPOSE_CORE_REF` (JetBrains/compose-multiplatform-core), `COMPOSE_REF` (the
+compose-multiplatform umbrella), `KOIN_REF` (InsertKoinIO/koin), `COIL_REF`
+(coil-kt/coil) and `PULSE_REF` (bitsycore/pulse-mvi). Each gets its own sibling
+sparse clone (`../cmp-ref`, `../cmp-ref-koin`, …). Bump the ref → re-sync → let the
+build tell you what broke. Per-module sync, manifest re-formatting, and the
+drift / vendor-clean guardrails are in
+[TOOLING.md](TOOLING.md#vendoring-upstream-compose).
 
-## Key files by area — start here when you need to find something
+## Key files by area - start here when you need to find something
 
 ### Renderer + main loop
-- `compose/sdl/window/src/nativeMain/…/ComposeWindow.kt` — main loop,
+- `compose/desktop/native/desktop-native-window/src/nativeMain/…/ComposeWindow.kt` - main loop,
   recomposer lifecycle, SDL event dispatch, composition-local seeding.
-- `compose/ui/ui/src/nativeMain/…/RenderBackend.kt` — the interface.
-- `compose/ui/ui/src/nativeMain/…/GpuMode.kt` — sealed renderer / driver picker.
-- `compose/ui/ui/src/skikoRendererMain/…/renderer/skia/SkiaRenderBackend.kt`.
-- `compose/ui/ui/src/sdlRendererMain/…/renderer/sdl/Sdl3RenderBackend.kt`.
-- `compose/ui/ui/src/sdlRendererMain/…/renderer/sdl/FreeTypeIcons.kt` —
-  variable-font axis rasterisation (SDL3_ttf has no axis-set API; we go
-  to FreeType directly for icon families).
+- `compose/ui/ui/src/nativeMain/…/RenderBackend.kt` - the interface.
+- `compose/ui/ui/src/nativeMain/…/GpuMode.kt` - sealed driver picker
+  (`Auto` / `Software` / `Skia.OpenGL` / `Skia.Metal`).
+- `compose/ui/ui/src/skikoRendererMain/…/renderer/skia/SkiaRenderBackend.kt` -
+  the Skia render backend (shared by every native target).
+- `compose/ui/ui/src/skikoRendererMingwMain/…` - mingwX64-only Skia actuals
+  bound against the skiko fork's flat extern-C surface.
 
 ### Layout / composition wiring
-- `compose/ui/ui/src/commonMain/…/node/ComposeRootHost.kt` — root LayoutNode
+- `compose/ui/ui/src/commonMain/…/node/ComposeRootHost.kt` - root LayoutNode
   host, hit-test, event dispatch, snapshot observer.
-- `compose/ui/ui/src/commonMain/…/node/impl/ComposeOwner.kt` — the
+- `compose/ui/ui/src/commonMain/…/node/impl/ComposeOwner.kt` - the
   project `Owner` implementation + `ProjectOwnedLayer` (graphicsLayer / clip /
   alpha bridge).
 - `compose/ui/ui/src/commonMain/…/node/NodeApplier.kt`.
 
-### Text
-- `compose/ui/ui/src/nativeMain/…/ui/text/SdlParagraph.native.kt` — the
-  bridged `Paragraph` implementation (measurement, hit-test, line metrics,
-  span painting).
-- `compose/ui/ui/src/nativeMain/…/ui/text/ParagraphFactories.native.kt` —
+### Text (all in `:ui-text` now)
+- `compose/ui/ui-text/src/nativeMain/…/ui/text/SkiaParagraph.native.kt` - the
+  `Paragraph` actual (skiko-free; the 30 interface methods over plain data),
+  driving the skiko engine through the `NativeParagraphOps` seam.
+- `compose/ui/ui-text/src/skikoRendererMain/…/renderer/skia/SkiaParagraphEngine.kt`
+  - `SkiaParagraphOps` (builds/queries the real skiko `skparagraph`) + `SkiaFonts`
+  (data.kres bytes → skiko Typeface; the port's family/variable-axis model).
+- `compose/ui/ui-text/src/nativeMain/…/ui/text/ParagraphFactories.native.kt` -
   actuals for the `Paragraph(…)` / `ParagraphIntrinsics(…)` factory family.
-- `compose/ui/ui/src/commonMain/…/text/TextMeasurer.kt` — `NativeTextMeasurer`
-  interface (per-renderer implementations: `SkiaTextRenderer` /
-  `Sdl3TextRenderer`).
 
 ### Icons
-- `compose/foundation/foundation/src/nativeMain/…/icons/IconFontIcon.kt` —
+- `compose/foundation/foundation/src/nativeMain/…/icons/IconFontIcon.kt` -
   codepoint-based `Icon` composable + `MaterialIconAxes` /
   `MaterialIconAxisDefaults`.
 - `utils/material-symbols/src/…/MaterialSymbols{Outlined,Rounded,Sharp}.kt`.
 
 ### Resources
-- `compose/ui/ui/src/commonMain/…/res/Res.kt` — the project's
+- `compose/ui/ui/src/commonMain/…/res/Res.kt` - the project's
   `androidx.compose.ui.res` reimpl (`Painter`, `ImageLoader`).
-- `compose/ui/ui/src/nativeMain/…/ResourceIO.kt` — opens `data.kres` once via
+- `compose/ui/ui/src/nativeMain/…/ResourceIO.kt` - opens `data.kres` once via
   `SDL_GetBasePath()` + parses central directory; each entry served by an
   `fseek + fread`.
 
 ### Apps
-- `demo/src/nativeMain/kotlin/Main.kt` — sidebar demo (`--gpu`, `--screen`,
+- `demo/src/nativeMain/kotlin/Main.kt` - sidebar demo (`--gpu`, `--screen`,
   `--screenshot`).
-- `apidemo/src/nativeMain/kotlin/Main.kt` — API manager entry.
-  `apidemo/src/nativeMain/kotlin/UiCompat.kt` — project-local
+- `apidemo/src/nativeMain/kotlin/Main.kt` - API manager entry.
+  `apidemo/src/nativeMain/kotlin/UiCompat.kt` - project-local
   `Dialog` / `DropdownMenu` / `DropdownMenuItem` / `TooltipBox` (m3 doesn't
   ship drop-in equivalents for our anchor / scrim patterns).
 
+## Tooling
+
+The full tooling reference is [TOOLING.md](TOOLING.md): the static-lib build,
+vendor sync + drift/clean guardrails, API coverage, the `verify-mac` runbook,
+the native-vs-JVM parity harness, the interaction probe, and the frame
+profiler. Quick rules of thumb:
+
+- Whole-project renderer/layout change → run **parity** (`scripts/parity/parity.py`),
+  the broad net.
+- Chasing one reported interaction → run the **probe** (`scripts/probe/`), targeted.
+- Slow frame → **profiler** first (`CDN_PROFILE=1`), optimize second.
+- Any renderer change → the **`verify-mac`** runbook gates it before commit.
+
+Open renderer / fidelity / release work is tracked in [PLAN.md](PLAN.md).
+
 ## Conventions
 
-Kotlin standard style — plain `camelCase` for parameters, local variables,
+Kotlin standard style - plain `camelCase` for parameters, local variables,
 and fields. **No `f`/`in`/`v` prefixes**, no SPIRTECH scheme (see the global
-CLAUDE.md — that scheme is C-only).
+CLAUDE.md - that scheme is C-only).
 
 Section headers inside a file, when useful:
 
@@ -439,106 +651,122 @@ In-function smaller scope:
 //  Name
 ```
 
-Function-level comments only where the name isn't self-documenting — avoid
+Function-level comments only where the name isn't self-documenting - avoid
 line-by-line commentary. Prefer KDoc (`/** … */`) over `/* … */` for docs
 that should surface in tooling.
 
 ## Common pitfalls
 
-- **State changes don't repaint the UI** — check
+- **State changes don't repaint the UI** - check
   `Snapshot.sendApplyNotifications()` is being called each frame in the main
   loop (`ComposeWindow.kt`). Without it, `mutableStateOf` writes never
   reach the recomposer.
-- **Physical-pixel modifiers double-scale on Retina** — under Option-B
+- **Physical-pixel modifiers double-scale on Retina** - under Option-B
   density, layout runs in physical pixels but `Modifier.width(20.dp)` still
   goes through `density.toPx()`. If you have a value already in physical
   pixels (from `onSizeChanged`), convert it back to Dp via
   `with(LocalDensity.current) { pxInt.toDp() }` before passing to
   `Modifier.width(…)`, or use pixel-based lambdas
   (`Modifier.offset { IntOffset(x, y) }`).
-- **Skia's `saveLayer(bounds, paint)`** — GPU backends allocate the offscreen
+- **Skia's `saveLayer(bounds, paint)`** - GPU backends allocate the offscreen
   to `bounds`. If content inside translates beyond those bounds, it gets
   clipped. `SkiaCanvas.saveLayer` passes a huge fixed bounds to sidestep this.
-- **`Modifier.alpha` clips to bounds** — upstream contract:
+- **`Modifier.alpha` clips to bounds** - upstream contract:
   `Modifier.alpha(x)` desugars to `graphicsLayer(alpha = x, clip = true)`.
   For a drag ghost that also translates, put `alpha` and `translationX` on
   the SAME `graphicsLayer(...)` so clip stays false.
-- **Cinterop `depends = sdl3`** — silently doesn't propagate; see the
-  gotcha section above.
-- **Configuration cache + `-Prenderer=`** — Gradle caches configuration;
-  toggling the renderer property may not invalidate it. Delete
-  `.gradle/configuration-cache/` between switches if you see weird
-  "couldn't find sdl3_ttf" errors.
-- **`Path()` in commonMain returns different actuals per renderer** —
-  the Skia renderer produces a `SkiaBackedPath` (wraps
-  `org.jetbrains.skia.Path`), the SDL renderer produces a project
-  `ProjectPath` (command-list based). `SkiaCanvas.toSkiaPath` handles
-  both — never assume the type without checking.
+- **Substituted Maven modules hide their transitives from common metadata** -
+  when the bridge swaps an official coord for a project module on native
+  configs, KGP's granular-metadata visibility check drops that Maven module's
+  TRANSITIVES from the commonMain classpath (symptom: `Unresolved reference
+  'Color'` / `Cannot access class ...` in `compileCommonMainKotlinMetadata`,
+  while per-target compilation is fine). Declare EVERY artifact the common
+  code touches DIRECTLY (ui-graphics, ui-text, ui-unit, …) and give each its
+  own bridge rule. Note only the WINDOWS publish job compiles common metadata
+  (it owns the root KotlinMultiplatform publications - the only host that
+  declares every target, so only its .module files carry the full variant
+  table; macOS-published roots left v0.1.15 without mingwX64 variants) -
+  test with `gradlew :<module>:compileCommonMainKotlinMetadata` before tagging.
 
 ## Useful Gradle tricks
 
-- `--args="--gpu=sdl3.opengl --screen=Buttons"` — pass CLI to the demo.
-- `--info` — see cinterop classpath + include paths actually used.
-- `--rerun-tasks` — force rebuild after toggling `-Prenderer=`.
+- `--args="--gpu=skia.opengl --screen=Buttons"` - pass CLI to the demo.
+- `--info` - see cinterop classpath + include paths actually used.
 - After a module rename or IC-cache mismatch: nuke
   `demo/build/kotlin-native-ic-cache` (or `apidemo/build/…`). Kotlin/Native
   pins module IDs into its klib metadata; a stale cache surfaces as
   `Unknown dependent library com.bitsycore.compose.sdl:core` (or
   whatever the old module name was).
 
-## Known Compatible — official Maven KMP artifacts used AS-IS
+## Known Compatible - official Maven KMP artifacts used AS-IS
 
 Before reimplementing or vendoring ANYTHING androidx, check Maven: a lot of
 the architecture stack publishes real Kotlin/Native desktop klibs
 (mingwX64 + linuxX64/arm64 + macosArm64) and runs on this port unmodified.
 Sometimes the GOOGLE coordinates (`androidx.*`) have the K/N variant,
-sometimes the JETBRAINS ones (`org.jetbrains.*`) — check both before
+sometimes the JETBRAINS ones (`org.jetbrains.*`) - check both before
 concluding an artifact "doesn't exist" for our targets.
 
 Verified in-tree (api-exposed by `:ui` unless noted):
 
-- `org.jetbrains.compose.runtime:runtime` / `runtime-saveable` 1.11.1 —
+- `org.jetbrains.compose.runtime:runtime` / `runtime-saveable` 1.11.1 -
   THE Compose runtime (composition, snapshots, recomposer). Never vendored.
 - `androidx.compose.runtime:runtime-retain` 1.11.1 (google coordinates).
 - `androidx.lifecycle:*` **2.11.0** (google): `lifecycle-runtime-compose`,
   `lifecycle-viewmodel`, `lifecycle-viewmodel-compose`,
-  `lifecycle-viewmodel-savedstate`, **`lifecycle-viewmodel-navigation3`** —
+  `lifecycle-viewmodel-savedstate`, **`lifecycle-viewmodel-navigation3`** -
   the whole ViewModel + SavedStateHandle + nav3-decorator stack needed ZERO
   reimplementation; only the window-side owners had to be provided (see
   caveats).
 - `androidx.savedstate:savedstate` / `savedstate-compose` **1.5.0** (google).
-- `androidx.navigation3:navigation3-runtime` **1.1.4** — backstack / NavEntry
+- `androidx.navigation3:navigation3-runtime` **1.1.4** - backstack / NavEntry
   / decorators. Only navigation3-UI (NavDisplay) lacks a K/N desktop artifact
   → vendored as `:navigation3-ui`.
-- `androidx.navigationevent:navigationevent-compose` 1.1.2 — predictive-back
+- `androidx.navigationevent:navigationevent-compose` 1.1.2 - predictive-back
   event plumbing (BackHandler, NavDisplay gestures).
-- `androidx.collection:collection` — plain Maven dep, not a module.
+- `androidx.collection:collection` - plain Maven dep, not a module.
+- `io.insert-koin:koin-core` **4.2.2** - the DI container itself publishes
+  mingwX64 + linux + macos. Only Koin's viewmodel / compose layers stop at
+  apple+android and are vendored (`koin/`).
+- `androidx.navigationevent:navigationevent-compose` 1.1.2 AND the jetbrains
+  `org.jetbrains.androidx.navigationevent:navigationevent-compose` 1.1.0 - BOTH
+  publish mingwX64 + linux + macos. Nothing to vendor here.
 - NOT compatible (vendored instead): `components-resources` (no mingw/linux
-  klibs → `:components-resources`), `navigation3-ui` (same → `:navigation3-ui`).
+  klibs → `:components:resources:components-resources`), `navigation3-ui` (same →
+  `:navigation3:navigation3-ui`), Koin's viewmodel/compose modules (→ `koin/`),
+  the whole Coil 3 stack (no mingwX64 anywhere; no desktop native at all for its
+  compose layer → `coil/`), and Pulse MVI (no desktop native → `pulse/`).
+- **Always check BOTH coordinate sets before concluding an artifact has no
+  desktop-native klibs.** `androidx.*` and `org.jetbrains.androidx.*` are
+  different artifacts with the same classes; sometimes only one carries the K/N
+  variant, and where both do, pick ONE - putting both on the path duplicates
+  every class. This port standardises on the GOOGLE `androidx.lifecycle:*`
+  coordinates, so vendored upstream code that referenced the jetbrains mirrors
+  is repointed at the google ones in the module's build file.
 - Infra: `kotlinx-coroutines-core`, `atomicfu`, `okio`,
   `kotlinx-serialization`.
 
-Caveats that make these work here (all already wired — listed so nobody
+Caveats that make these work here (all already wired - listed so nobody
 "fixes" them away):
 
 - The google `LocalViewModelStoreOwner` / `LocalSavedStateRegistryOwner` /
-  `LocalLifecycleOwner` are PLAIN composition locals — the JB HostDefault
+  `LocalLifecycleOwner` are PLAIN composition locals - the JB HostDefault
   mechanism (`compositionLocalWithHostDefaultOf`) does not exist in google
   artifacts. `WindowArchitectureOwner` (ComposeWindow.kt) provides all three
   per window, mirrors upstream desktop's DefaultArchitectureComponentsOwner,
   calls `enableSavedStateHandles()` at construction, and follows SDL focus /
   visibility (focused → RESUMED, unfocused → STARTED, minimised → CREATED).
-- The window composes its FIRST composition at CREATED and resumes after —
+- The window composes its FIRST composition at CREATED and resumes after -
   `enableSavedStateHandles()` callers running in composition require
   lifecycle ≤ CREATED. Related contract: `rememberViewModelStoreOwner()` with
   its default `savedStateRegistryOwner` THROWS at a RESUMED call site (same
-  on Android) — scope shared VMs to the window owner (`viewModel { }` outside
+  on Android) - scope shared VMs to the window owner (`viewModel { }` outside
   the entries, the `activityViewModels()` analog) instead.
-- nav3 entry decorators: saveable BEFORE viewmodel —
+- nav3 entry decorators: saveable BEFORE viewmodel -
   `listOf(rememberSaveableStateHolderNavEntryDecorator(),
   rememberViewModelStoreNavEntryDecorator())`.
 - `Dispatchers.Main.immediate` must run inline on the main thread
-  (Sdl3MainDispatcher) — androidx.lifecycle's main-thread enforcement
+  (Sdl3MainDispatcher) - androidx.lifecycle's main-thread enforcement
   round-trips through it; a queue-only Main deadlocks composition.
 - Regression probes: `demo --nav3test` (nav3 + ViewModels + lifecycle,
   composed late at RESUMED like the real sidebar flow), `--backtest`
@@ -546,4 +774,4 @@ Caveats that make these work here (all already wired — listed so nobody
 
 ## License
 
-MIT — see [LICENSE.md](LICENSE.md).
+MIT - see [LICENSE.md](LICENSE.md).

PLAN.md

@@ -0,0 +1,896 @@
+# ROAD TO 1.0.0
+
+**Objective:** get ComposeNativeSDL3 **as close to upstream Compose Multiplatform as
+possible** - vendor every file we can instead of rewriting, stay performant, and look
+faithful (ideally pixel-identical across macOS / Linux / Windows). The port is already at
+99% upstream API coverage with maximal vendoring and no steady-state perf gap on
+macOS/Metal; the remaining 1.0.0 work is **cross-platform rendering fidelity** (Windows
+skiko-fork divergences), **completing native-actual stubs**, and the release mechanics
+(1.12.0-stable re-pin + WIN-SMOKE).
+
+**Status / handoff:** the macOS/Linux-verifiable work is done and committed on `main` (see
+**"Landed toward 1.0.0"** below - don't redo it). The remaining blockers need a **Windows host**
+→ jump to **"▶ Continuing on Windows (mingwX64) - START HERE"**. This file is self-contained: it
+has the build/run commands, the exact confirm steps, the macOS baseline data to diff against, and
+per-task fixes. So on Windows you can say **"continue PLAN.md"** and have everything.
+
+## Definition of done for 1.0.0
+
+- [x] No text tofu on any platform - Windows tab fix **CONFIRMED on-device** (§1a, 2026-08-04:
+      literal `\t`→space, no `.notdef`); CJK / color-emoji / control chars render clean too (§1c).
+- [x] Fork-vs-official divergence surface (FontMgr, gamma, ICU) **audited on native Windows**
+      (2026-08-04): metrics == JVM (§1b), FontMgr fallback works (CJK + color emoji, §1c), ICU
+      classification works (§1c). Net - the fork's Skia matches upstream; the only deltas are its
+      thin extern-C bindings, handled in shared Kotlin (LineMetrics reconstruction). No fork-side
+      fix needed for 1.0.
+- [~] Native-actual fidelity blockers closed: float pointer coords **DONE**, screen-reader
+      no-op **DONE**, text context menu **RECONCILED - already works** via the legacy path
+      (§2). Date/time localization is P1 polish (formatter already works).
+- [x] Vendor hygiene stays clean: zero drift (all 10 manual vendors match pin), zero
+      commonMain rule-1 violations, zero vendored files touched this session - verified via
+      `check-vendor-drift.py`.
+- [~] SDL static lib slimmed to the used subsystem surface (§3) - **DONE + verified on
+      macOS/Metal**; other hosts pending WIN-SMOKE.
+- [ ] Refs re-pinned to Compose **1.12.0 stable**, JVM parity versions bumped, WIN-SMOKE
+      fidelity pass green on a real Windows host.
+- [x] `CLAUDE.md` documentation map consistent with tree - line-1 typo fixed; the stale
+      historical docs `RENDERER.md` + `SKIKO-MINGW-FEASIBILITY.md` removed (current renderer
+      essentials inlined into CLAUDE.md, the rest is in git history); all dead doc links
+      (TODO.md / RENDERER.md / SKIKO) removed or repointed to PLAN.md.
+
+## Landed toward 1.0.0 (this pass - all build + run verified on macOS/Metal)
+
+Everything below is committed; details + file refs are in the sections that follow.
+
+1. **Tab tofu fix** (§1a P0) - normalize `\t`→space before shaping so the Windows fork
+   can't render `.notdef`. Platform-independent, length-preserving.
+2. **HiDPI caret quantization fix** (§2 P0) - pointer/wheel coords carried as `Float`
+   end-to-end instead of truncated to `Int`.
+3. **Screen-reader no-op** (§2 P0) - `LocalPlatformScreenReader` defaults to inactive
+   instead of throwing.
+4. **SDL slimming** (§3) - 10 unused subsystems disabled in `build-all.py`; 6 now-dead
+   macOS frameworks dropped from `sdl3.def`. Rebuilt; demo + apidemo link, demo runs.
+5. **Context menu reconciled** (§2 P0) - confirmed already working via the vendored legacy
+   path; the 3 "NOP" seams are vestigial (disabled new API) - misleading TODOs corrected.
+6. **`CDN_TEXT_METRICS` diagnostic** (§1b) - env-gated line-metrics dump; macOS baseline
+   captured, hypothesis sharpened (fork likely drops lineHeight leading).
+7. **Doc hygiene** (§5) - removed the stale historical `RENDERER.md` +
+   `SKIKO-MINGW-FEASIBILITY.md` (renderer essentials folded into `CLAUDE.md`; rest in git
+   history), fixed the `CLAUDE.md` typo + all dead doc links; extracted the fork
+   FreeType-scaler lead into §1c before deleting. Vendor drift verified clean.
+
+**Windows pass (2026-08-04, this host - DPR 1).** On a real Windows host at last: (8) tab fix
+**CONFIRMED on-device** (§1a); (9) vertical metrics **RESOLVED** - native `--metricsprobe` heights
+== JVM `--metrics` exactly, feared "dropped leading" DISPROVEN (§1b); (10) fork `LineMetrics.
+ascent/descent` mis-decode **FIXED in shared Kotlin** (`SkiaParagraphOps.lineMetrics()`, guarded
+no-op on official skiko) - repairs Windows caret/selection; (11) fork FontMgr/ICU **AUDITED** - CJK
++ color-emoji + control-char fallback all work → the "empty FreeType stub" fear DISPROVEN (§1c);
+(12) `FontRasterizationSettings.native.kt` verified to mirror upstream VERBATIM + given a
+`VENDOR-BASE` provenance line; rasterization stays upstream-faithful per-OS (user decision). Net:
+the fork's Skia matches upstream - the only deltas are its thin extern-C bindings, fixed in shared
+Kotlin, **zero fork rebuild**.
+
+**Still not done - WIN-SMOKE interactive + release** (§5): interactive caret-height check (the one
+behavioral consequence of the LineMetrics fix), the `PrintWindow` probe, `compileCommonMainKotlin
+Metadata`, apiDump + publish FROM Windows, and the Compose 1.12.0-stable re-pin. **Deliberately
+deferred** (large/structural, rationale in-section): RTL, `PlatformFontLoader`, grapheme source-set
+move, date CLDR, brush/gradient text - plus the big **vendor-the-upstream-skiko-text-engine
+refactor (§6)**, sequenced after these fixes land.
+
+---
+
+## ▶ Continuing on Windows (mingwX64) - START HERE
+
+**Read this before doing anything.** This file is the single source of truth for the road to
+1.0.0. Everything in **"Landed toward 1.0.0"** above is **already implemented and committed on
+`main`** - do NOT redo it, just verify it on this host. Every open `[ ]` / `[~]` below is
+remaining work. The macOS/Linux side is done and verified; the remaining blockers need a **real
+Windows host** - the mingwX64 build cross-compiled from mac/Linux fails at cinterop, and the
+bitsycore skiko **fork** can only be rebuilt on Windows.
+
+**The Windows fidelity reference is skiko-on-JVM Compose Desktop on THIS Windows host**
+(`gradlew :demo:run` - also DirectWrite/system fonts), NOT macOS. mac↔Windows metric deltas are
+expected in upstream Compose Desktop too, so "matches Windows-JVM" is the acceptance bar, not
+"matches macOS".
+
+### Build / run (Windows shell, repo root)
+
+```bat
+gradlew.bat :demo:runDebugExecutableMingwX64      :: native demo (the port under test)
+gradlew.bat :apidemo:runDebugExecutableMingwX64   :: native apidemo (has the Session/Override buttons)
+gradlew :demo:run                                 :: JVM Compose Desktop = the FIDELITY REFERENCE
+gradlew :apidemo:run                              :: JVM apidemo reference
+```
+
+- The bridge plugin auto-drops `skiko-windows-x64.dll` next to the exe (`installWindowsSkiaDll`).
+  Fork coords `com.bitsycore.skiko:skiko:0.150.1-mingw.2` (override `-PskikoMingwVersion`).
+- `:demo` CLI flags (native AND jvm): `--screen=<Name>`, `--screenshot=<path.bmp>` (capture at
+  quiescence then quit), `--gpu=auto|software|skia.opengl`. `CDN_TEXT_METRICS=1` env var dumps
+  text metrics (§1b). `CDN_PROFILE=1` frame profiler. `:apidemo` has NO screenshot CLI - drive it
+  by hand for the button-metrics visual.
+- If an IC-cache error appears after any module churn: delete `demo\build\kotlin-native-ic-cache`.
+
+### ✅ Windows session results (2026-08-04, this host - DPR 1.0)
+
+Items 1–3 below are **DONE + verified on the shipped mingwX64 demo binary**; findings folded into
+§1a/§1b/§1c. Only 4–5 (WIN-SMOKE interactive gate + apiDump/publish) remain. TL;DR:
+
+- **§1a tab fix - CONFIRMED.** `--screen=BasicText` with `"start>a\tb<end\tcols\tand\tthere"`
+  rendered `start>a b<end cols and there` - every `\t` a SPACE, zero `.notdef`. (Structural proof
+  too: the whole module has exactly 2 `.addText(` sites, both `shapedText`.)
+- **§1b vertical metrics - RESOLVED, the feared bug is DISPROVEN.** Native `--metricsprobe` vs JVM
+  `--metrics` (same host, NotoSans, density 1): **every paragraph height + non-M3 baseline matches
+  JVM EXACTLY** (size 11→24). Leading is NOT dropped. Two residual deltas found (details in §1b):
+  (a) the fork's `LineMetrics.ascent/descent` are mis-decoded - **fixed in Kotlin** this session;
+  (b) M3 baseline drifts ≤0.77px (halfLeading, a shared-engine omission on ALL platforms, sub-pixel).
+- **§1c FontMgr/ICU - the "empty FreeType stub" fear is DISPROVEN.** Native render of CJK
+  (你好世界 日本語 한국어) + **full-COLOR emoji** (😀🎉🚀❤) + control chars (nbsp/zwsp/en-dash) = zero
+  tofu. Color emoji + CJK fallback prove `FontMgr.default` is a real DirectWrite-backed system
+  manager, not an empty custom FreeType one. Remaining §1c work is doc-only (capture `args.gn`).
+
+Reference commands actually used (both probes print `metrics:` lines; native runs a real window):
+```bat
+demo\build\bin\mingwX64\debugExecutable\demo.exe --metricsprobe    :: native/fork metrics
+gradlew :demo:run --args="--metrics"                               :: JVM/upstream metrics
+set CDN_TEXT_METRICS=1 && ...demo.exe --screen=Buttons             :: raw per-paragraph dump
+```
+(The JVM leg's screenshot flag is `--screenshot-all=<dir>`, not the native `--screenshot=<file>`.)
+
+### Ordered Windows work (do top-to-bottom; full detail in the numbered sections below)
+
+1. **[§1a] Confirm the tab fix - ✅ DONE** (see session results above). Rendered a literal-tab
+   string on the fork; all `\t`→space, no tofu. The `SkiaParagraphEngine.shapedText` normalization
+   holds; no bypass path exists (2 `.addText(` sites, both `shapedText`).
+
+2. **[§1b] Confirm/resolve vertical metrics - ✅ RESOLVED (feared bug DISPROVEN).** Used the
+   `--metricsprobe` (native) vs `--metrics` (JVM) pair, NOT the screenshot diff (the JVM leg has no
+   `--screenshot=<file>`; it dumps the same `metrics:` table). Every paragraph HEIGHT matches JVM
+   exactly (leading applied identically) → correct-by-reference. Only a ≤0.77px M3-baseline drift
+   remains (halfLeading, all platforms). Separately fixed the fork's broken `LineMetrics.ascent/
+   descent` in Kotlin. Full data in §1b.
+
+3. **[§1c] Audit the fork FontMgr / gamma / ICU - ✅ AUDITED (fallback WORKS).** CJK + color emoji +
+   control chars all render with zero tofu on the fork → `FontMgr.default` is a real system
+   (DirectWrite) manager with working glyph fallback, NOT an empty FreeType stub. Remaining: capture
+   the fork's REAL `args.gn` (`SK_GAMMA_*`, ICU packaging, freetype-vs-dwrite) into the fork repo so
+   drift is auditable (doc-only, not a code blocker).
+
+4. **[§5] WIN-SMOKE gate** (pre-ship): (1) the §1b metrics dump, (2) tab/control-char render clean,
+   (3) the Windows-only `PrintWindow` probe (`scripts/probe/`), (4) `gradlew
+   :<module>:compileCommonMainKotlinMetadata` (only the Windows job compiles common metadata).
+
+5. **[§5] apiDump + publish FROM Windows** (host-specific; only the Windows job carries the full
+   mingwX64 variant table). Then, when Compose **1.12.0 stable** ships, do the re-pin + version
+   bump. Release runbook: [TOOLING.md](TOOLING.md).
+
+---
+
+## 1. Cross-platform FIDELITY (headline)
+
+All Windows divergences live **below Kotlin** - the mingw source set reuses
+`src/skikoRendererMain/kotlin` byte-for-byte (`compose/ui/ui/build.gradle.kts:102-113`),
+the only mingw-unique file is `PlatformGpu.mingw.kt` (13 lines, GPU only). So every
+divergence is in the **fork's Skia binary**, in **`FontMgr.default`'s per-OS impl**, or in
+the **GPU backend**. The fork is external (`bitsycore/skiko`,
+`com.bitsycore.skiko:skiko:0.150.1-mingw.2`) and its GN args are **not verifiable from this
+tree** - recovering them is a prerequisite for several fixes below.
+
+**Fidelity reference for Windows is skiko-on-JVM Compose Desktop on Windows** (also
+DirectWrite), NOT macOS/Linux. macOS↔Windows metric deltas partly exist in upstream
+Compose Desktop too (per-platform font backends). Reframe V-items as "match JVM-Windows"
+acceptance tests, not "bugs vs macOS".
+
+### 1a. Windows tab-character tofu - HIGH CONFIDENCE (root cause traced)
+
+Kotlin sets `ParagraphStyle.replaceTabCharacters = true`
+(`compose/ui/ui-text/src/skikoRendererMain/kotlin/.../renderer/skia/SkiaParagraphEngine.kt:234-236`,
+exact mirror of upstream `ParagraphBuilder.skiko.kt:625`, CMP-6589). Works on
+macOS/Linux (official skiko honors the flag → `U+0009` replaced by space before shaping).
+On Windows the same call runs against the fork's flat extern-C DLL, which evidently does
+**not** wire the setter → raw `\t` reaches HarfBuzz → NotoSans has no tab glyph → `.notdef`
+box. Font fallback is a **red herring**: no font has a tab glyph, only tab→space
+replacement cures it.
+
+- [x] **P0** Confirm - ✅ DONE (Windows 2026-08-04): rendered a literal-tab string on the fork
+      (`--screen=BasicText`); every `\t` shows a SPACE, no `.notdef`. The fork renders everything
+      else clean too, so tab→space was the only gap. Structural backstop: the module has exactly 2
+      `.addText(` sites, both `shapedText` - no raw tab can reach skiko.
+- [x] **P0** Fix (ship now, author project code): in
+      `.../SkiaParagraphEngine.kt`, feed skiko a normalized copy - added
+      `private val shapedText = if (text.indexOf('\t') >= 0) text.replace('\t', ' ') else text`,
+      used at `addText` (no-span path) and via `shapedText.substring(segStart, segEnd)`
+      (span path); `text` kept for ALL length/index queries (`getRectsForRange`,
+      `getCursorRect`, `wordBoundary`, `lineMetrics`, span cut-points). Length-preserving so
+      every offset consumer stays correct; this is exactly what Skia's flag does internally →
+      upstream-faithful; makes behavior platform-independent (no fork rebuild needed).
+      Kept `replaceTabCharacters = true` (harmless/redundant elsewhere).
+      **DONE** - compiles clean on macosArm64. Windows tofu render still needs on-device
+      confirmation (WIN-SMOKE §5).
+- [ ] **P2** Long-term true fix (fork, out of tree): wire
+      `ParagraphStyle::setReplaceTabCharacters` through the fork's extern-C surface,
+      rebuild/republish `skiko-windows-x64.dll`, bump `-PskikoMingwVersion`. Do this *in
+      addition to* the Kotlin fix, not instead - it keeps the port thin. Can't be verified
+      in-tree.
+
+### 1b. macOS-vs-Windows vertical text metrics - ✅ RESOLVED (Windows 2026-08-04): heights match JVM, feared bug DISPROVEN
+
+**WINDOWS RESULT (2026-08-04).** All targets render through the SAME Skia, so metrics are expected
+to be similar - and they are. Native `--metricsprobe` (fork) vs JVM `--metrics` (upstream skiko) on
+this host (NotoSans, density 1) print IDENTICAL paragraph heights and non-M3 baselines for every
+size 11→24 (`cell`/`one`/`three`/`oneM3`/`threeM3`, `base1`/`base3` all match). The fork does NOT
+drop lineHeight leading - the hypothesis below is disproven. Two small deltas remained, both
+handled in SHARED Kotlin (no fork rebuild, keeping fork-reliance minimal):
+
+  1. **Fork `LineMetrics.ascent/descent` mis-decode → FIXED in Kotlin (this session).**
+     `CDN_TEXT_METRICS` showed the fork's per-line `ascent`/`descent` constant (18.837/5.163)
+     regardless of `fontPx`, while `baseline`/`height`/`width` are correct (mac scales them:
+     37.674@30px). This is the fork's flat extern-C LineMetrics binding, NOT a Skia difference.
+     Lines stack contiguously so true ascent = `baseline - lineTop`; `SkiaParagraphOps.lineMetrics()`
+     now rebuilds ascent/descent from the reliable baseline+height when they're internally
+     inconsistent (guard `|ascent-(baseline-lineTop)|>0.5` = no-op on official skiko). Repairs caret
+     height / getLineTop/Bottom / vertical hit-test on Windows. **Behavioral caret check → WIN-SMOKE.**
+  2. **M3 baseline drift ≤0.77px (halfLeading) - SHARED-engine omission, all platforms.** `base1M3`
+     differs native-vs-JVM by ≤0.77px in the 11→24 sweep (size 14 → 0.28px, sub-pixel), 2.19px in
+     the contrived `boundary 24/25` case. Root cause is NOT the fork: `SkiaParagraphEngine` maps
+     `LineHeightStyle.trim`→HeightMode but never wires `halfLeading`/`LineHeightStyle.Alignment`, so
+     macOS-native drifts from JVM by the same amount (parity tolerated it as sub-pixel). Fixable in
+     shared Kotlin (`textStyle.halfLeading` from the alignment); deferred pending a cross-platform
+     parity re-check (can't run mac parity from a Windows host).
+
+Native-fork metricsprobe vs JVM `--metrics` (this host) - identical except `base?M3`:
+```
+size=14 lh=20 cell=19 one=19 three=59 base1=14.898 base3=54.898 oneM3=20 threeM3=60 base1M3: 15.682 fork / 15.398 jvm
+size=24 lh=30 cell=33 one=33 three=93 base1=25.968 base3=85.968 oneM3=30 threeM3=90 base1M3: 23.546 fork / 24.312 jvm
+boundary 24/25 m3=25  base: 19.622 fork / 21.812 jvm
+```
+
+The vertical-layout code path is **identical** on all targets. The lineHeight/HeightMode
+path is a byte-faithful port of upstream and is NOT the cause: m3 `labelLarge` has
+lineHeight 20sp > fontSize 14sp with `LineHeightStyle.Default.trim == Both` →
+`HeightMode.DISABLE_ALL`, which collapses the single-line box to `fontAscent + fontDescent`
+of the font itself (`SkiaParagraphEngine.kt:244-249`, matches upstream
+`ParagraphBuilder.skiko.kt:631-646`). So box height is driven entirely by the font's
+reported ascent/descent.
+
+Root cause: **`FontMgr.default` resolves to a different Skia font scaler per build** for
+the *same* `font/NotoSans.ttf` bytes (`SkiaFonts.kt:38,44,50`) - CoreText on macOS,
+fontconfig/FreeType on Linux, DirectWrite (or FreeType, unverified) in the fork on Windows.
+Different backends select different metric tables (hhea `ascender/descender` vs OS/2
+`sTypoAscender/Descender` vs `usWinAscent/Descent`) and honor the OS/2 `USE_TYPO_METRICS`
+fs_selection bit differently. NotoSans is the textbook case (large top-heavy ascent).
+`SkiaParagraphEngine.kt:147-148` read `-defaultFont.metrics.ascent`/`.descent`;
+`:150-169 lineMetrics()` forwards skiko's numbers verbatim; `SkiaParagraph.native.kt:116,148-153`
+consume them. Contributors V2 (hinting Normal on Windows grid-fits vertically, CoreText
+ignores it) and V3 (subpixel/edging) are secondary and per-scaler.
+
+**Hypothesis, not confirmed:** whether Windows-native actually *diverges from
+Windows-JVM*. If it matches JVM-Windows it's correct-by-reference (not a bug), and the
+macOS↔Windows delta is expected upstream behavior.
+
+- [x] **P0** Confirm FIRST - ✅ RESOLVED (Windows 2026-08-04; heights == JVM, see WINDOWS RESULT
+      above). Diagnostic **LANDED**: `SkiaParagraphEngine.kt` dumps
+      `defaultFont.metrics.{ascent,descent,leading}`, `paragraph.height`,
+      `lineMetrics[0].{ascent,descent,baseline,height}`, `familyName` + `fontPx` per built
+      paragraph when `CDN_TEXT_METRICS=1` (mirrors the `CDN_PROFILE` env-flag convention).
+      Run `CDN_TEXT_METRICS=1 <app> --screen=Buttons` (native) and the JVM parity app on the
+      SAME host, diff the lines. macOS baseline captured (see below). **REMAINING (Windows
+      host):** compare Windows-native vs **skiko-JVM-Windows**. Expectation: `fontPx` +
+      lineHeight + heightMode identical, `metrics.ascent` differs by scaler.
+      **Acceptance test:** Windows-native == skiko-JVM-Windows (→ correct-by-reference, not a
+      bug); if they differ, it's a fork scaler fix (next item).
+
+      **macOS baseline captured (`--screen=Buttons`, DPR 2):** for the fontPx=30 button
+      labels ("Filled Button" / "OutlinedButton" / "TextButton"): font metrics
+      `ascent=-32.07 descent=8.79 leading=0` (font box = **40.86px**), but the line box is
+      `line0[ascent=37.67 descent=10.33 height=48.0]`, `paraHeight=48`. So macOS DOES apply
+      the lineHeight leading (48 > 40.86) and distributes it **asymmetrically - ~5.6px above,
+      ~1.5px below** → exactly the "extra space on top of the text" the report describes.
+      **SHARPENED HYPOTHESIS:** this is NOT a mac bug - it's correct lineHeight distribution.
+      The likely Windows story is the MIRROR of §1a: the fork's flat extern-C surface doesn't
+      wire the `ParagraphStyle` height/strut path, so Windows renders **tight to the font box
+      (~41px, no leading)** = the "fitted to text" look. **Sharpened WIN-SMOKE check:** for the
+      SAME label, compare `paraHeight` + `line0.height`. If macOS/JVM = 48 but Windows-native
+      ≈ 41, the fork drops lineHeight leading (fork fix: wire `heightMode`/strut, like
+      `replaceTabCharacters`); a Kotlin fallback is a manual `StrutStyle`. If Windows-native
+      == Windows-JVM, it's correct-by-reference.
+
+      **macOS baseline raw lines** (`CDN_TEXT_METRICS=1 demo --screen=Buttons`, DPR 2) - diff
+      Windows-native + Windows-JVM against these; the fontPx=30 rows are the cleanest signal:
+      ```
+      text='Filled Button'  fontPx=30.0  ascent=-32.070007 descent=8.789978 leading=0.0  paraHeight=48.0  line0[ascent=37.674 descent=10.326 baseline=37.674 height=48.0]
+      text='OutlinedButton' fontPx=30.0  ascent=-32.070007 descent=8.789978 leading=0.0  paraHeight=48.0  line0[ascent=37.674 descent=10.326 baseline=37.674 height=48.0]
+      text='TextButton'     fontPx=30.0  ascent=-32.070007 descent=8.789978 leading=0.0  paraHeight=48.0  line0[ascent=37.674 descent=10.326 baseline=37.674 height=48.0]
+      text='Outlined'       fontPx=28.0  ascent=-29.932007 descent=8.203980 leading=0.0  paraHeight=40.0  line0[ascent=31.395 descent=8.605  baseline=31.364 height=40.0]
+      ```
+      (family='Noto Sans' on all.) Expectation if correct: `fontPx`, `paraHeight`, `line0.height`
+      match JVM-Windows exactly; the raw `ascent`/`descent` may differ from these macOS numbers
+      because the Windows scaler is FreeType (§1c), but the LINE BOX must still match JVM-Windows.
+- [x] **P1** ~~If Windows-native != Windows-JVM: fix in the fork~~ - **N/A (2026-08-04):** heights
+      MATCH JVM-Windows exactly, so no fork scaler/FontMgr change is needed for vertical metrics.
+      The `makeFromData` typefaces already get the same metric-table selection as skiko-JVM-Windows.
+      The one residual (M3 halfLeading) is a shared-Kotlin fix, not a fork one.
+- [ ] **P2** (Optional, STRONGER than upstream) If cross-platform pixel-identity is
+      wanted over matching each host's stock Compose Desktop: build a single
+      FreeType/`SkFontMgr_Custom_Empty`-backed `SkFontMgr` used on ALL native targets for
+      the bundled fonts, so NotoSans yields identical ascent/descent everywhere.
+      Intentional departure from per-platform upstream behavior - decide deliberately.
+- [ ] **DO NOT** "fix" by injecting a default `LineHeightStyle` or clamping ascent in
+      `SkiaParagraphEngine.kt` - that desyncs from upstream `DISABLE_ALL` and masks, not
+      resolves, the metric divergence.
+
+### 1c. Other fork-vs-official divergences
+
+- [x] **P1** ~~`FontMgr.default` may be an empty/stub manager on the fork~~ - **DISPROVEN
+      (Windows 2026-08-04).** Native render of CJK (你好世界 日本語 한국어) + **full-COLOR emoji**
+      (😀🎉🚀❤) + control chars = zero tofu. Color emoji + CJK fallback are impossible with an empty
+      custom FreeType manager, so the fork's `FontMgr.default` IS a real DirectWrite-backed system
+      manager with working glyph enumeration/fallback. No fork change needed. `SkiaFonts.kt` wiring
+      stays as-is.
+- [x] **P1** `FontMgrWithFallback` - ANALYZED + fallback now VERIFIED on Windows. The port
+      does `setDefaultFontManager(fontMgr)` [system] + `setAssetFontManager(provider)`
+      [bundled] (`SkiaFonts.kt:49-52`). This is **functionally equivalent** for missing-glyph
+      fallback on macOS/Linux/Windows-JVM: skiko's shaper tries the asset provider (bundled
+      Noto + aliases) first, then the default/system manager for CJK/emoji fallback, which
+      resolves because the system FontMgr has those fonts. Rewriting to
+      `setDefaultFontManager(FontMgrWithFallback(provider))` risks a macOS fallback
+      regression with no observable gain, and I can't visually verify CJK/emoji fallback on
+      this host. **The real gap was thought to be Windows-fork-only** (fork `FontMgr.default`
+      empty stub → no system fallback) - but that's **DISPROVEN (2026-08-04):** CJK + color-emoji
+      fallback works on native Windows too (item above). So the setDefault/setAsset wiring is fine
+      on ALL targets. **Decision:** leave the Kotlin as-is; nothing to fix in the fork here. Re-open
+      only if a CJK/emoji fallback bug is actually observed.
+- [x] **P2** ~~ICU/unicode data packaged differently in the fork~~ - **VERIFIED OK (2026-08-04).**
+      Rendered U+00A0 (nbsp → visible space), U+200B (zwsp → zero-width/collapsed), en-dash, and
+      U+0009 (tab, pre-replacement) on native Windows: all classified/handled correctly, no tofu.
+      The force-exported `uloc_*_skiko` symbols do their job; skunicode classification works. (This
+      is also why HarfBuzz shaping + skparagraph bidi work at all - ICU data is present via
+      icudtl.dat.)
+- [~] **P2** Text gamma/AA edges: a Skia **build-time constant**
+      (`SK_GAMMA_EXPONENT`/`SK_GAMMA_CONTRAST`/`SK_GAMMA_APPLY_TO_A8`), NOT a GL-vs-Metal
+      runtime difference. **Note (2026-08-04):** native Windows text AA looked clean in the render
+      (no visible AA anomaly), so no fork gamma fix is pursued for 1.0. Still worth capturing the
+      fork's values in the fork repo (see the args.gn item below). **Kotlin-side rasterization
+      settled:** the `RASTER_EDGING/HINTING/SUBPIXEL` in `SkiaParagraphEngine` come from
+      `FontRasterizationSettings.PlatformDefault`, which was verified (2026-08-04) to reproduce
+      upstream Compose Desktop's per-OS defaults VERBATIM (Win/mac=Normal hinting, Linux=Slight).
+      **User decision:** keep the upstream-faithful per-OS behavior (match each platform's stock
+      CMP), NOT a forced uniform cross-platform look. So there is no SDL_TTF-era gamma hack left to
+      strip - Skia is configured exactly as upstream does it.
+- [x] **GL-vs-Metal AA/gamma/color-space - RULED OUT as a primary cause.** Both bridges
+      create the surface `colorSpace = null` (`SkiaGLBridge.kt:68-74`,
+      `SkiaMetalBridge.kt:133-139`) - identical un-color-managed legacy blending. Only
+      deltas are cosmetic-correct: `RGBA_8888`/`BOTTOM_LEFT` (GL) vs `BGRA_8888`/`TOP_LEFT`
+      (Metal) - channel order + Y-flip, matched to buffers. Windows uses OpenGL
+      (`PlatformGpu.kt:20`), same backend as Linux, so GL-vs-Metal can't explain a
+      Windows-vs-Linux gap at all. Deprioritized - no action.
+- [~] **P1** The fork's Skia build config (GN args). **Lead extracted from git history**
+      (the old `SKIKO-MINGW-FEASIBILITY.md`, deleted as stale - its build recipe lives in
+      `git show bdb5c64d^:SKIKO-MINGW-FEASIBILITY.md`): the fork's Route-1a recipe builds Skia
+      with **`skia_use_freetype`**, i.e. the Windows text scaler is **FreeType**, not
+      DirectWrite and not macOS CoreText - a concrete reason the SAME NotoSans bytes yield
+      different ascent/descent on Windows (different metric-table selection) AND why fork
+      `FontMgr.default` may not enumerate Windows system fonts for glyph fallback (FreeType
+      has no system fontmgr without fontconfig). **CAVEAT:** that's the *recommended recipe*,
+      not a verified dump of the shipped `0.150.1-mingw.2` GN args. **REMAINING:** whoever
+      rebuilds the fork should capture the real `args.gn` (`SK_GAMMA_*`, ICU packaging,
+      freetype-vs-dwrite) alongside the fork sources so drift is auditable - NOT as a doc in
+      this repo (kept lean); a comment in the fork repo or `build-sdl.properties`-style pin.
+
+---
+
+## 2. VENDORING & upstream-fidelity debt
+
+Vendor hygiene is **release-ready**: `check-vendor-drift.py` reports all 10 manual vendors
+match pin `v1.12.0-beta03+dev4483`; zero commonMain rule-1 violations (the 3 authored
+`androidx.compose.*` files in commonMain are all provenance-tracked Rule-3 vendors). The
+macosMain DIAGNOSTIC GAP families (`ui/ui` 12, `foundation` 23: `CoreTextField.macos.kt`,
+`SelectionManager.macos.kt`, `PlatformClipboard.macos.kt`, …) are **correctly excluded**
+(AppKit/NSView; the port uses SDL) - keep them in gaps. **Do not spend 1.0.0 effort
+re-vendoring.** The debt is **completing native-actual stubs**.
+
+### P0 - blocks fidelity/correctness
+
+- [~] **P0** Text context menu (right-click copy/paste/select-all) - **RECONCILED: already
+      works, no reimplementation.** Static trace confirmed the menu is wired end-to-end
+      through the vendored LEGACY path: text-level `ContextMenuArea` (`ContextMenu.native.kt`)
+      → `CommonContextMenuArea` (`vendor/common/.../text/CommonContextMenuArea.kt`) → (native
+      `ComposeFoundationFlags.isNewContextMenuEnabled = false`, so the legacy branch) →
+      `contextmenu.ContextMenuArea` → `contextMenuGestures`/`onRightClickDown`
+      (`isSecondaryPressed`) → `ContextMenuPopup` → `Popup.native.kt` (hosted by
+      `LocalPopupHost` at the app root). Items are real: `TextFieldSelectionManager` /
+      `SelectionManager.contextMenuBuilder` emit Cut/Copy/Paste/SelectAll with real actions.
+      SDL right-click → `PointerButton.Secondary` (`SDL3EventMapper.kt`) →
+      `isSecondaryPressed` (`PointerEventBridge`). The three "NOP" seams belong to the
+      DISABLED *new* context-menu API and are unreachable - **DONE:** their misleading
+      `TODO(CMP-7819)` comments corrected to say so, in all three files.
+      **REMAINING:** an interactive right-click smoke check (no headless driver here - fold
+      into manual/WIN-SMOKE). Known limitation, not a breakage: Paste enablement is
+      plain-text-only (`ClipboardPasteState.hasClip = hasText`, see P2 below).
+- [ ] **P1** DatePicker/TimePicker localization - VERIFIED current state:
+      `material3/.../internal/PlatformDateFormat.native.kt` is a real kotlinx-datetime
+      formatter that DOES honor CLDR patterns/skeletons (renders "Jul 29, 2026" /
+      "July 2026" correctly - the agent's "always yyyy-MM-dd" finding was stale). Genuine
+      remaining gaps, all narrower than a correctness blocker: field NAMES English-only
+      (`:29 weekdayNames`, `:147-154 MONTH_NAMES/ABBR` - no CLDR data bundled), `:27
+      firstDayOfWeek=1` fixed Sunday, `:67 is24HourFormat()=true` fixed, `:46 parse()`
+      ISO-8601-only. Upstream `darwinMain` uses `NSDateFormatter` (not portable). **Fix
+      (author):** bundle a CLDR subset or K/N i18n lib for localized names + locale-aware
+      first-day/24h; also unblocks `CalendarLocale.native.kt:20` (fixed `"en"`). Ships
+      readable English dates today - polish, not a P0 gate.
+- [x] **P0** Float pointer coordinates - `SDL3EventMapper.kt` `.toInt()`-truncated SDL's
+      Float `mb.x`/`mb.y`/`mm.x`/`mm.y` and the wheel `mouse_x/y` before the DPR multiply in
+      `ComposeWindow.kt`. On 2× displays a click at logical 100.9 → physical 200 not ~201,
+      quantizing the caret to 2px steps near glyph edges. **DONE:** widened
+      `LegacyPointerEvent.x/y` and `AppEvent.MouseWheel.x/y` to `Float`, dropped the
+      `.toInt()` at the three mapper construction sites, and removed the now-redundant
+      `.toFloat()` at the two `ComposeWindow` read sites. Consumers fully contained (verified
+      by grep). Builds + runs clean on macosArm64.
+
+### P1 - quality / parity
+
+- [ ] **P1** RTL text unsupported - `ui-text/.../SkiaParagraph.native.kt:112`
+      `textDirection = ResolvedTextDirection.Ltr` fixed field; `getParagraphDirection()`
+      (`:202`) always Ltr. Bidi run direction (`:204`) does read box direction (partial
+      machinery). Root cause: `text/intl/Locale.native.kt isRtl()` unimplemented. Fix
+      (author) tied to P1.2 engine.
+- [ ] **P1** `PlatformFontLoader` NOP - `ui-text/.../font/FontFamilyResolver.native.kt`
+      `SdlPlatformFontLoader.loadBlocking`/`awaitLoad` NOP;
+      `PlatformFontFamilyTypefaceAdapter.resolve` returns `Immutable(Unit)`. Raw androidx
+      `Font(bytes)`/`ResourceFont` don't load (compose-resources `Font()` works). Upstream
+      `SkiaFontLoader.skiko.kt` is the vendorable reference. This is the long-deferred P3.2
+      font resolver - **high-risk L**, parity harness wouldn't exercise it. Scope
+      deliberately for 1.0.0 (accept-and-document vs attempt). **NOW ALSO GATES §6** - the
+      2026-08-04 spike found the verbatim engine-vendor routes font resolution through this NOP, so
+      implementing this loader (so `SkiaFonts`' icon/variable-axis model rides upstream's seam) and
+      the §6 engine-vendor are ONE effort. Do them together, with macOS/Linux verification.
+- [ ] **P1** `CharHelpers.skiko.kt` grapheme-break logic - the ONE cheap selective-vendor
+      win from the hand-rolled text engine. Fixes `findPrecedingBreak`/`findFollowingBreak`
+      splitting emoji/combining marks in `StringHelpers.native.kt:31` +
+      `CharHelpers.native.kt:14`. (Giving `:foundation` a `skikoRenderer` source set would
+      unblock this + `DragAndDropSource.skiko` - L-effort structural move, per §13a.)
+- [~] **P1** `Serif`/`Cursive` generic families - RE-SCOPED after reading `SkiaFonts.kt`.
+      They do NOT silently collapse to sans: `baseTypeface()` routes `generic:serif` /
+      `generic:cursive` through `resolveGeneric()` → `fontMgr.matchFamilyStyle()` over a
+      per-OS candidate list (`genericFamilyAliases`: Times/Noto Serif/… on each host), only
+      falling back to the bundled default if NONE is installed. So serif/cursive already
+      render as a real serif/cursive wherever the OS ships one (all three target OSes do).
+      The only true gap is **cross-platform pixel-identity** / a host with no serif installed,
+      which needs a BUNDLED Noto Serif - an app-level opt-in (buildSrc `downloadNotoFonts` +
+      data.kres size cost), not a library correctness bug. **Decision:** leave library
+      resolution as-is; offer bundled-serif as an opt-in later if an app needs it.
+- [x] **P1** Document the hand-rolled text engine as an **accepted architectural
+      deviation** - **DONE:** rationale header added to the top of
+      `ui-text/compose-fork.txt` (the exact place someone would go to "fill" the gaps),
+      explaining the reduced local engine, the flat-source-set reason, and that RTL /
+      stroke-DrawStyle / grapheme reductions are tracked here (§2), not fixed by vendoring.
+      Also reflected in `SkiaParagraphEngine.kt`'s header and CLAUDE.md's renderer summary.
+
+### P1/P2 - reduced-coverage + accessibility
+
+- [ ] **P1** Text paint path handles only `SolidColor`
+      (`SkiaParagraph.native.kt:253-256`) - no brush/gradient text fill, `drawStyle`
+      (stroke), or non-`SrcOver` blendMode. Part of the reduced style coverage; extend on
+      the local engine.
+- [ ] **P1** `SkiaParagraphEngine.kt:150-164` span segmentation drops partial `SpanStyle`
+      overlaps (keeps only fully-covering `start<=segStart && end>=segEnd`). Documented
+      divergence (`b63-upstream-text-mingw.md`) - widen to true interval segmentation.
+- [~] **P1** Accessibility absent - `ComposeOwner.kt:~340` builds a `semanticsOwner` never
+      traversed to any OS a11y API; `SemanticsRegion.native.kt intersect()/difference()`
+      hardcode `false`. Not vendorable (NSAccessibility/UIA/AT-SPI). **Decision for 1.0.0:
+      out of scope for desktop.** The full a11y pipeline stays P2/out.
+      - [x] **P0** No-op `PlatformScreenReader` - `CompositionLocals.native.kt`
+        `LocalPlatformScreenReader` default no longer throws (`error(...)`); it returns an
+        `InactivePlatformScreenReader` (`isActive = false`) so a11y-gated vendored code
+        degrades to "no reader present" instead of crashing. **DONE** - builds + runs clean.
+- [ ] **P2** `SkiaFonts.kt` fidelity: `resolveCache` unbounded (font-cache half of P3.4
+      deferred); variation key passes `null` density (`:65,78`) so density-dependent `opsz`
+      in sp resolves wrong. `NamedFont.equals/hashCode` axis identity reportedly fixed -
+      re-verify.
+
+### P2 - cosmetic / edge
+
+- [ ] **P2** `BlendMode.Multiply` renders wrong - opaque cyan×yellow reads back blue;
+      likely Metal premultiply in graphics-layer flatten, not the `toSkia()` map. Isolate on
+      the Skia draw path.
+- [ ] **P2** Drag-OUT of window NOP - `ui/.../draganddrop/Sdl3DragAndDropOwner.kt:39`
+      `requestDragAndDropTransfer`; `DragAndDropSource.native.kt:36` no drag-shadow. SDL3
+      has no portable start-drag → needs NSDraggingSession/DoDragDrop/XDND per-OS.
+      Drop-INTO works. Accepted 1.0 gap (SDL platform limit) - document.
+- [ ] **P2** `NativeStringDelegate.native.kt:17` `toUpper/toLowerCase` ignore `locale`
+      (Turkish i). Upstream `darwin` unvendorable (NSString).
+- [ ] **P2** Prefetch scheduler NOP - `platform/PrefetchLocals.native.kt:18`, lazy lists
+      skip ahead-of-time composition (scroll-in jank).
+- [ ] **P2** `ClipboardPasteState.hasClip` aliased to `hasText`
+      (`TextFieldSelectionState.native.kt:43`) - image-only clipboard undetected.
+- [ ] **P2** `ComposeOwner.kt` gaps: `autofill`/`autofillManager` null (`:324`),
+      `hapticFeedBack` NOP (`:279`), deprecated `clipboardManager` NOP (`:287`, real
+      `LocalClipboard` works), `textToolbar` stub (`:311`, touch-gated). No multi-monitor
+      enumeration (`SDL_GetDisplays` unused). Most match upstream desktop - verify, then
+      leave or fill.
+- [x] **P2** `installGlobals()` → `registerGenericFonts()`: VERIFIED not a hot-path cost -
+      `registerGenericFonts()` already early-returns on a `fRegistered` flag
+      (`GenericFonts.kt:20-26`), so the per-event call is a single boolean check, not a
+      re-register. Original premise inaccurate; no change needed. (Minor residue: the
+      `ImeBridge.onSessionActiveChange` lambda is reassigned per event - negligible, left
+      as-is since it repoints per active window.)
+
+---
+
+## 3. SDL slimming
+
+Static lib built from source per host (`scripts/build-sdl/build-all.py`, ref
+`release-3.4.12`); linked into the exe via `sdl3.def` (`staticLibraries=libSDL3.a`). Today
+only tests/examples + Windows D3D12/GPU are off (`build-all.py:311-319`). `SDL_Init` uses
+**`SDL_INIT_VIDEO` only** (`SDL3Backend.kt:49`).
+
+**USED (keep ON):** Video/window, Events, Clipboard, Dialog (file open/save - no cheaper
+substitute; Linux uses portal/zenity, keep deps), OpenGL + Metal contexts, Render (2D CPU-
+raster blit path: `SkiaSurfaceBridge` uploads to `SDL_Texture` + `SDL_RenderPresent`),
+Filesystem, Cursor, Locale, System theme, Text input/IME, OpenURL, timing/hints.
+
+**UNUSED (disable - zero references, no transitive need):** Audio, Joystick (→disables
+Gamepad), Haptic, HIDAPI, Sensor, Power, Camera, GPU API, Offscreen video driver, virtual
+joystick.
+
+- [x] **P1** Added to `build-all.py` shared `vExtra`: `-DSDL_AUDIO=OFF`,
+      `-DSDL_JOYSTICK=OFF`, `-DSDL_HAPTIC=OFF`, `-DSDL_HIDAPI=OFF`, `-DSDL_SENSOR=OFF`,
+      `-DSDL_POWER=OFF`, `-DSDL_CAMERA=OFF`, `-DSDL_GPU=OFF`, `-DSDL_OFFSCREEN=OFF`,
+      `-DSDL_VIRTUAL_JOYSTICK=OFF`. Promoted `-DSDL_GPU=OFF` from the Windows-only branch to
+      the shared list; kept the per-host `-DSDL_RENDER_D3D12=OFF` (Windows). (Skipped
+      `-DSDL_DISABLE_INSTALL_DOCS` - not a real SDL3 option; the build's `cmake --install`
+      is relied upon.) All ten confirmed zero-reference by grep before disabling.
+- [~] **P1** After the flag change, rebuild + run apps to confirm no regression.
+      **DONE on macOS/Metal:** `build-all.py` rebuilt libSDL3.a clean with the new flags;
+      `:demo` links + runs to a settled screenshot (TextField screen, no visual regression);
+      `:apidemo` links clean too. **PENDING:** both apps on Linux + Windows hosts (fold into
+      WIN-SMOKE §5). If audio/gamepad is ever needed by a consumer app, re-enable the flag
+      and rebuild the static lib (build-time only).
+- [x] **P2** Prune now-unreferenced macOS frameworks from `sdl3.def`. **DONE:** verified
+      against the regenerated `libs/SDL3/lib/pkgconfig/sdl3.pc` `Libs:` line (source of
+      truth), which after slimming no longer references `CoreAudio`, `AudioToolbox`,
+      `AVFoundation`, `GameController`, `ForceFeedback`, or weak `CoreHaptics` - removed all
+      six from `linkerOpts.osx` (kept `CoreMedia`, which the `.pc` still lists). Demo relinks
+      clean. (Left Linux `linkerOpts` alone - those `-l` entries serve Skia/GL/X11, not the
+      disabled SDL subsystems.)
+- [ ] **P2** (higher-risk, flag-don't-apply) Render-driver pruning to software-only. Only
+      the CPU-raster fallback uses `SDL_Render`; GL/Metal go direct. But
+      `SDL_CreateRenderer(window, null)` (`SDL3Backend.kt:117`) lets SDL pick the first
+      driver - with only software present it picks software (fine) but couples the fallback
+      to that assumption. **Conservative: leave render drivers alone.**
+
+**Do NOT** add `-DSDL_DISABLE_INSTALL` - the build relies on `cmake --install`
+(`build-all.py:342`) to stage `libSDL3.a` + headers. `SDL_DYNAMIC_API` auto-disables for
+static builds (no flag needed). **Risk:** a future consumer app needing SDL audio/gamepad
+requires a static-lib rebuild (build-time, not a code change).
+
+---
+
+## 4. Performance
+
+Prior PLAN Phases 0–3 landed; §12 measurement showed **no steady-state perf gap on
+macOS/Metal**. Remaining perf question (if any) is Windows-GL or heavy-interaction
+specific. Retained-layer engine is byte-for-byte upstream - not the gap.
+
+- [ ] **P2** WON'T-FIX confirmed, keep as-is (don't relitigate): P0.4 per-frame full-surface
+      clear + P0.6 per-frame Metal drawable reacquire (`CAMetalDrawable` single-use per
+      frame, matches upstream `MetalRedrawer`).
+- [ ] **P2** P2.2 upstream `GlobalSnapshotManager` invalidation-driven scheduling -
+      deferred; coalescing half done by P1.3; full manager is skiko-windowing-coupled
+      (an explicit renderer non-goal - skiko-windowing-coupled). Leave deferred unless a
+      Windows-GL perf gap surfaces.
+- [ ] **P2** `SkiaImageCache` font-cache half of P3.4 - evicted typefaces stay referenced by
+      live paragraphs + `TypefaceFontProvider` (no clean unregister) so eviction frees no
+      memory. Native-resource lifecycle backstop is the periodic `GC.collect()` nudge (top-
+      level `Paragraph` a live `Text` holds has no Compose dispose seam). Accept for 1.0 or
+      add a provider-unregister path.
+- [ ] **P2** P4.1 second-renderer manual-vendor reversal (restore upstream RenderNode
+      shadows via `SkiaGraphicsContext.setLightingInfo` + relocate
+      `prepareTransformationMatrix`; deltas D2–D6). Buys vendoring cleanliness at
+      shadow-lighting/hit-test regression risk (current `NativeShadowCanvas` shadows render,
+      draw=0.08ms). Low ROI - deferred, needs full verify-mac + parity.
+- [ ] **P2** Profile the shipped **Windows-GL** binary (`CDN_PROFILE=1`) under heavy
+      interaction before ship (present phase is vsync-capped by display refresh - profile on
+      the target monitor). Only open perf unknown.
+
+---
+
+## 5. API coverage / release mechanics
+
+API coverage vs upstream is **99%** (8665/8751 decls via `compose-coverage.py`). Misses are
+AppKit/UIKit/web host actuals (N/A), `ImageComposeScene`/`renderComposeScene` (test util),
+and the `ui-text.platform` font layer (= P3.2 font resolver). The 1076 "extra" decls are
+umbrella-repo modules the tool can't compare + version skew, not invented surface.
+
+- [ ] **P0** Re-pin refs to Compose **1.12.0 stable** when it ships (currently
+      `v1.12.0-beta03+dev4483` - no clean beta03 tag on Maven). Bump both
+      `scripts/compose-fork/compose.properties` refs, re-sync (`scripts/compose-fork/sync.sh`),
+      let the build surface breakage.
+- [ ] **P0** Bump `vComposeJvmVersion` in `:demo` / `:apidemo` / `:material-symbols` (JVM
+      parity leg currently forced to beta02 by documented skew - native leads).
+- [ ] **P1** Run `check-vendor-drift.py` after the ref bump - re-stamp `VENDOR-BASE` on the
+      10 manual vendors, hand-reconcile any that actually changed base..pin.
+- [~] **P0** WIN-SMOKE fidelity pass (Windows host only, pre-ship gate): the Mac runbook
+      cannot cover the shipped mingwX64 binary. Assert: (1) NotoSans `FontMetrics` dump
+      native-vs-JVM-Windows (§1b acceptance) - **✅ DONE 2026-08-04 (`--metricsprobe`==`--metrics`)**;
+      (2) `\t`/control-char render clean (§1a) - **✅ DONE**; (3) the Windows-only `PrintWindow`
+      probe - pending (interactive); (4) the common-metadata publish job - compile gate now
+      **✅ GREEN (2026-08-04, see the fix below)**; the actual publish + downstream-consume smoke
+      still owed. Remaining: (3) `PrintWindow` probe + the interactive caret-height check for the
+      §1b LineMetrics fix.
+- [ ] **P0** apiDump is **host-specific** - do NOT commit macOS dumps. Only the **Windows
+      publish job compiles common metadata** (owns the root KotlinMultiplatform publications
+      - the only host declaring every target, so only its `.module` files carry the full
+      variant table; macOS-published roots left v0.1.15 without mingwX64 variants). Test
+      `gradlew :<module>:compileCommonMainKotlinMetadata` before tagging; publish from
+      Windows.
+- [x] **P0** **FIXED (2026-08-04) - common-metadata compile is now GREEN** (`compileCommonMainKotlin
+      Metadata` across all modules → BUILD SUCCESSFUL). Was RED, blocking the Windows publish.
+      Running `:material3:compileCommonMainKotlinMetadata` (or the aggregate) had failed at
+      `:foundation:compileNativeMainKotlinMetadata` (pulled in via `:foundation:allMetadataJar`):
+      `Scrollbar.skiko.kt` + `v2/Scrollbar.skiko.kt` - `Declaration annotated with
+      '@OptionalExpectation' can only be used in common module sources`
+      (`OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE`). **Root cause:** upstream keeps these
+      `.skiko.kt` files in `skikoMain`, which INCLUDES the JVM-desktop target, so `@JvmName`/
+      `@JvmStatic`/`@file:JvmName` resolve; the port vendors them into **native-only `nativeMain`**
+      (no JVM target under it), so those JVM annotations are orphaned and the *metadata* compile
+      rejects them (per-target compile tolerates them - that's why the APPS build fine, but the
+      publish's `allMetadataJar` recompiles nativeMain metadata and dies). `:ui` and below pass;
+      `:foundation` is the first break. **Blast radius:** 14 vendored native files use `@Jvm*`
+      (`grep -rE "@file:JvmName|@JvmName|@JvmStatic" .../src/vendor/native .../src/nativeMain`); 11
+      are in the GITIGNORED, sync-regenerated `src/vendor/native/` tree, so per-file edits DON'T
+      survive a re-sync. **Fix (build/sync-level, not per-file):** either (a) a `sync.sh`
+      post-step that injects `@file:Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE")`
+      (or strips `@Jvm*`, which are no-ops with no JVM library target) into vendored native files -
+      there's precedent: `components-resources/…/ResourceState.blocking.kt` already carries that
+      suppress; or (b) a KGP-level relaxation of the native metadata compilation. Needs a real
+      publish + downstream-consume verification after. Dedicated effort - likely THE reason the
+      Windows metadata publish never went green.
+      **FIX APPLIED (2026-08-04):** the root turned out narrower - sync.py ALREADY injects the K2
+      `@file:Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE", "LESS_VISIBLE_TYPE_ACCESS_IN_INLINE")`
+      into every `src/vendor/` .kt (`sync.py:313`), so the regenerated tree was fine. The only gap
+      was the two COMMITTED manual vendors in `src/nativeMain` that sync doesn't regenerate:
+      `foundation/…/Scrollbar.skiko.kt` + `v2/Scrollbar.skiko.kt`. Added the identical `@file:Suppress`
+      to both (provenance comment updated; `check-vendor-drift` still clean). Full
+      `compileCommonMainKotlinMetadata` now green. **Remaining before publish:** run the actual
+      publish + a downstream-consume smoke (the compile gate is necessary, not proof the `.module`
+      variant table is complete).
+- [ ] **P1** Version bump to `1.0.0` across published coords once the above are green.
+- [x] **P0** Doc-hygiene blocker: `CLAUDE.md` documentation map referenced `RENDERER.md`,
+      `SKIKO-MINGW-FEASIBILITY.md`, and `TODO.md`. **DONE:** removed `RENDERER.md` +
+      `SKIKO-MINGW-FEASIBILITY.md` (stale/historical - current renderer essentials inlined in
+      CLAUDE.md's doc map, the rest recoverable from git history); fixed the `CLAUDE.md`
+      line-1 `ean` typo; dropped the `TODO.md` link (never committed) → its content is PLAN.md
+      §2. `git grep` confirms no remaining links to any deleted doc.
+
+---
+
+## 6. Vendor the upstream skiko text engine (next major refactor - approved 2026-08-04)
+
+**Goal:** honour "VENDOR ALL WE CAN". Delete the hand-rolled reduced text engine
+(`SkiaParagraph.native.kt` + `NativeParagraphOps` seam + `SkiaParagraphEngine.kt` +
+`FontRasterizationSettings.native.kt` port) and vendor upstream's skiko text subsystem VERBATIM.
+
+**Why it was hand-rolled (the REAL reason, not SDL_TTF):** `Paragraph` is `expect sealed interface`
+(`vendor/common/…/Paragraph.kt:56`) whose `actual` sits in the **skiko-FREE `nativeMain`**, so a
+sealed implementer can't touch skiko → the hand seam. `nativeMain` is skiko-free because it's the
+shared parent of the **official-skiko** (mac/linux, `libs.skiko`) and **fork-skiko** (mingw,
+`com.bitsycore.skiko:skiko`) legs - two different artifacts, so the shared parent can carry neither.
+
+**Why it's feasible NOW (all-skiko + srcDir reuse):** every native leg already reaches
+`src/skikoRendererMain/kotlin` (mingw via `kotlin.srcDir(...)` in `skikoRendererMingwSharedMain`,
+`ui-text/build.gradle.kts:54`), and the fork exposes the SAME `org.jetbrains.skia.*` Kotlin API. So
+the `Paragraph` **actual + engine can move DOWN into the skiko source set** (served to all targets)
+instead of skiko-free `nativeMain` - which lets upstream's skiko files compile as-is.
+
+**⚠️ SPIKE FINDING (2026-08-04) - the real gate is the FONT LOADER, not the source-set move.**
+A read-only feasibility map (no code changed) found two layers:
+- **Layer 1 - source-set / sealed move: FEASIBLE.** The `actual sealed interface Paragraph`
+  (`vendor/native/Paragraph.native.kt:36`, signature-only mirror) + its implementer + the 11 factory
+  actuals can move to `skikoRendererMain` (all leaves reach it; sealed same-source-set holds). Just
+  mechanical.
+- **Layer 2 - font model: THIS is the blocker, and it's the SAME task as §2-P1 `PlatformFontLoader`.**
+  Upstream's engine (`SkiaParagraphIntrinsics.skiko.kt:38,61`) resolves typefaces through
+  `FontFamily.Resolver` → `PlatformFontLoader`. The port's `SdlPlatformFontLoader`
+  (`font/FontFamilyResolver.native.kt:30-49`) is a **NOP** (`loadBlocking`/`awaitLoad`→`Unit`,
+  `resolve`→`Immutable(Unit)`). The port's hand-rolled engine exists precisely to BYPASS that NOP by
+  resolving through `SkiaFonts` (icon fonts + variable axes + data.kres bytes). So vendoring the
+  upstream engine verbatim routes font resolution through the NOP → **all text goes blank/tofu**
+  until the loader is real.
+- **Consequence:** the verbatim engine-vendor REQUIRES first implementing upstream's font-loader path
+  (vendor `SkiaFontLoader.skiko.kt` as the reference) so the port's `SkiaFonts` icon/variable-axis
+  model rides upstream's `PlatformFontLoader`/`FontLoadResult` seam. This is the deferred high-risk P1
+  in §2 - it and this §6 are one effort. **Intermediate option:** vendor the engine files but keep
+  `SkiaFonts` via a Rule-3 edit at the one resolve call site (vendors most files verbatim, 1–2 stay
+  hand-reconciled). **Verification needs macOS + Linux hosts** (parity), so this is a dedicated
+  effort, not a Windows-only session - do it with mac access, on its own branch.
+
+**Plan (spike on a branch, verify on THIS Windows host - build + render mingwX64):**
+1. Move the `Paragraph`/`ParagraphIntrinsics` **actuals** into `skikoRendererMain` (reused by mingw
+   via the existing `srcDir`). Confirm the `expect sealed` actual is accepted there for every leaf
+   target (the b63 memo hit a sealed-in-`nativeMain` wall - test whether hosting the actual in the
+   skiko set clears it; the sealed same-module rule is per-target-compilation, which should hold).
+2. Vendor VERBATIM into `src/vendor/skikoRenderer/`: `SkiaParagraph.skiko.kt`,
+   `ParagraphBuilder.skiko.kt`, `SkiaParagraphIntrinsics.skiko.kt`, `SkiaTextPaint.skiko.kt`,
+   `ParagraphLayouter.skiko.kt`, `PlatformFont.skiko.kt`, `FontRasterizationSettings.skiko.kt`,
+   `TextStyle.skiko.kt`; add them to `ui-text/compose-fork.txt`; delete the hand-rolled files.
+3. Reconcile the ~7 hierarchy-crossing `expect/actual` pairs the inverted layout needed; keep the
+   `SkiaFonts` family/variable-axis model (it's the port's real value-add) behind upstream's seams.
+4. **Fork-only Rule-3 edit:** upstream's code calls `paragraph.lineMetrics` - the fork's extern-C
+   binding mis-decodes ascent/descent (§1b finding). Either carry the guarded reconstruction (from
+   `SkiaParagraphOps.lineMetrics()`) into the vendored `SkiaParagraph.skiko.kt` as a Rule-3 edit, or
+   fix it in the fork DLL. **Bonus:** vendoring `ParagraphBuilder.skiko.kt` verbatim wires
+   `halfLeading` → the §1b M3-baseline drift disappears for free.
+5. Verify: mingwX64 build + `--screen=BasicText/Buttons/AnnotatedString` render clean +
+   `--metricsprobe` == JVM `--metrics`. Then macOS/Linux verify + parity (needs those hosts).
+
+**Sequencing:** AFTER the current shared-Kotlin fixes land (this session). If the sealed-actual move
+proves infeasible, fall back to keeping the seam but at least converting the hand files to tracked
+Rule-3 vendors (like `FontRasterizationSettings.native.kt` now has a `VENDOR-BASE` line).
+
+## Accepted 1.0.0 gaps (documented, not fixed)
+
+Drag-OUT of window (SDL platform limit; drop-IN works), full accessibility pipeline (out of
+scope for desktop 1.0 - but ship the non-throwing `PlatformScreenReader` no-op), the
+hand-rolled text engine as an architectural deviation (§2 P1), per-focus
+`SDL_StartTextInput/StopTextInput`, `loadImageBitmap`/`loadSvgPainter` (JVM `InputStream`
+signatures, N/A on K/N).
+
+## 7. Post-1.12.0 open items (opened 2026-09-12)
+
+### 7a. JVM parity reference used a DIFFERENT default font than native - ✅ FIXED
+
+Symptom (apidemo, `SourceTag` in `InheritanceUi.kt`): the "Session" / "Pack" pill is
+`Box(padding(horizontal = 5.dp, vertical = 1.dp)) { Text(fontSize = 9.sp) }` - no explicit
+vertical centering, so the pill's look is entirely decided by where the glyphs sit inside the
+Text node's measured paragraph box. On the JVM leg the label looks vertically centred in the
+pill; on native it does not.
+
+**Not a centering bug - a font-resolution divergence.** The two stacks render that label in
+two different typefaces, which have different ascent / descent / line-gap, so the glyph run
+sits at a different height inside an equally-tall box:
+
+- NATIVE: `FontFamily.Default` resolves to the BUNDLED **NotoSans** -
+  `SkiaFonts.defaultTypeface` (`compose/ui/ui-text/src/skikoRendererMain/.../SkiaFonts.kt`)
+  loads `font/NotoSans.ttf` from data.kres and registers it as "the fallback for every
+  unresolved family".
+- JVM: nothing registers NotoSans as the default. `apidemo/src/jvmMain/kotlin/Fonts.jvm.kt`
+  only defines `monoFontFamily`; `jvmProcessResources` stages the .ttf on the classpath but
+  never installs it. So `FontFamily.Default` is Skiko's SYSTEM default (Segoe UI on Windows).
+
+This is a defect in the PARITY HARNESS, not (necessarily) in the renderer: every `Text` that
+doesn't name a `fontFamily` is being compared against a different typeface, so any such
+difference is uninterpretable. It likely masks or manufactures other "port bugs".
+
+**Fixed** by giving apidemo a `defaultFontFamily` expect/actual (`Fonts.kt`) that loads the
+bundled `font/NotoSans.ttf` on BOTH legs - native through `IconFont.register` +
+`namedFontFamily`, jvm from the classpath copy `jvmProcessResources` already stages - and
+stamping it across the M3 `Typography` (`withDefaultFontFamily`), since typography styles
+carry their own `fontFamily` and overriding `LocalTextStyle` alone would not reach them.
+
+This is the SAME treatment `:demo`'s parity leg already had (see the `notoSans` /
+`notoTypography` block in `demo/src/jvmMain/kotlin/MainJvm.kt`, commented "so the parity %
+measures real divergence, not 'different default typeface'"). apidemo had simply never been
+given it. Verified: the SourceTag pill is now vertically centred on both stacks.
+
+### 7a-bis. apidemo drift check is now mechanised - and two residuals found
+
+`:apidemo` had no way to capture itself, so drift could only be eyeballed. Both legs now take
+`--screenshot=<path>`:
+
+    apidemo.exe --screenshot=out.bmp                              # native: GPU readback
+    ./gradlew :apidemo:run --args=--screenshot=out.png            # jvm: ImageComposeScene
+
+Both render OFFSCREEN to quiescence (virtual 60fps clock, infinite animations frozen via
+upstream's `InfiniteAnimationPolicy`, capture after 3 quiet frames), mirroring `:demo`'s
+parity path. Neither needs a visible window, so the capture is immune to occlusion - a
+screen-scrape approach was tried first and grabbed whatever happened to be in front.
+
+First run after the font fix, 1240x820: **2.9% of pixels differ at all, 2.1% by >32/255.**
+Two residuals, neither a text-metrics bug:
+
+- **Inherited lineHeight leading distribution - ✅ FIXED.** The port never forwarded
+  `topRatio` to skiko. Upstream's `ParagraphBuilder.skiko.kt` sets `res.topRatio = topRatio`
+  on EVERY SkTextStyle, sourced from `LineHeightStyle.Alignment.topRatio`; the port set
+  `ts.height` and `heightMode` but left `topRatio` alone, so skiko fell back to its own
+  default (-1 = split the extra leading proportionally to the font's ascent:descent). For a
+  line box much taller than the glyphs that pushes them visibly DOWN - while Material 3's
+  type styles ask for `Alignment.Center` (topRatio 0.5).
+
+  One line in `SkiaParagraphEngine.kt`'s SkTextStyle builder, with `Alignment.Proportional`
+  as the fallback exactly like upstream, so text specifying no lineHeightStyle is unchanged.
+  `topRatio` is present on both the official skiko and the bitsycore mingw fork.
+
+  Measured on apidemo (1240x820), whole window, native vs jvm:
+
+    |                    | differ | >32/255 |
+    |--------------------|--------|---------|
+    | before             | 2.94%  | 2.14%   |
+    | after              | 1.52%  | 0.29%   |
+
+  The Session/Pack pills are now pixel-identical. This ALSO killed the "constant ~2px
+  vertical offset" logged alongside it - that was the same bug compounding through stacked
+  text rows, not an independent issue: shifting the jvm capture now makes the match WORSE
+  (0.29% at +0px vs 2.13% at +1px), where before +2px halved the error. The residual 0.29%
+  is rasterizer AA.
+
+- **Icon-font glyphs rendered LOW - ✅ FIXED.** Material Symbols sat 2-4px lower on native
+  than on jvm, the offset scaling with icon size (~13% of it). Cause: the JVM actual centres
+  the glyph explicitly (`y = height/2 - (ascent+descent)/2`), while `IconFontIcon` placed
+  `IconText` in a Box at the DEFAULT TopStart alignment - and the glyph's natural text box is
+  taller than the nominal icon size. Fixed by centring, with
+  `wrapContentSize(unbounded = true)` so the text measures at its natural size first:
+  `Modifier.size()` imposes FIXED constraints, so without it nothing overflows and
+  contentAlignment is a no-op (a first attempt without it changed literally nothing).
+  gear/download/lock are now pixel-exact; the eye is 1px off from half-pixel rounding (odd
+  glyph height centred in an even box; jvm draws at a float y, native placement is integer).
+  Whole-window >32/255 drift 0.29% -> 0.17%.
+
+- **Missing glyph in the session header.** The leading icon next to "Untitled session"
+  renders as a `.notdef` TOFU on jvm and as NOTHING on native - so the glyph is absent from
+  the subsetted Material Symbols font on both, and the two stacks just disagree on how to
+  draw a missing glyph. The gear icon beside it is fine, so the icon-font path works; this
+  is almost certainly `enableIconSubsetting` missing a NON-LITERAL `MaterialSymbols.<Name>`
+  reference that `findMaterialSymbolsUsage` cannot see. Check that call site, and consider
+  making the native side draw .notdef too so a missing glyph is never silent.
+
+### 7b. Vendor Koin + Coil3 + Pulse MVI (requested 2026-09-12) - ✅ DONE
+
+Target-availability audit against Maven Central (the deciding fact - re-check on every
+version bump, and check BOTH the google and jetbrains coordinate sets before concluding an
+artifact "has no desktop klibs"):
+
+| Artifact | mingwX64 | linuxX64/arm64 | macosArm64 | Action |
+|---|---|---|---|---|
+| `androidx.navigationevent:navigationevent-compose` 1.1.2 | YES | YES | YES | **none - already used as-is** |
+| `org.jetbrains.androidx.navigationevent:navigationevent-compose` 1.1.0 | YES | YES | YES | **none** |
+| `io.insert-koin:koin-core` 4.2.2 | YES | YES | YES | none - Maven as-is |
+| `io.insert-koin:koin-core-viewmodel` 4.2.2 | no | no | YES | VENDOR |
+| `io.insert-koin:koin-compose` 4.2.2 | no | no | YES | VENDOR |
+| `io.insert-koin:koin-compose-viewmodel` 4.2.2 | no | no | YES | VENDOR |
+| `io.insert-koin:koin-compose-viewmodel-navigation` 4.2.2 | no | no | YES | VENDOR |
+| `io.coil-kt.coil3:coil-core` 3.6.2 | no | YES | YES | VENDOR (mingw gap) |
+| `io.coil-kt.coil3:coil` 3.6.2 | no | YES | YES | VENDOR (mingw gap) |
+| `io.coil-kt.coil3:coil-network-core` 3.6.2 | no | YES | YES | VENDOR (mingw gap) |
+| `io.coil-kt.coil3:coil-network-ktor3` 3.6.2 | no | YES | YES | VENDOR (mingw gap) |
+| `io.coil-kt.coil3:coil-svg` 3.6.2 | no | YES | YES | VENDOR (mingw gap) |
+| `io.coil-kt.coil3:coil-compose-core` 3.6.2 | no | no | YES | VENDOR |
+| `io.coil-kt.coil3:coil-compose` 3.6.2 | no | no | YES | VENDOR |
+
+NOTE the original premise that navigationevent-compose lacks desktop-native artifacts is
+WRONG - both coordinate sets publish mingwX64 + linux + macos, and the port already consumes
+`androidx.navigationevent:navigationevent-compose:1.1.2` unmodified ("Known Compatible" in
+CLAUDE.md, exercised by `demo --backtest`). Nothing to vendor there.
+
+**Landed** as `koin/` (4 modules, `com.bitsycore.koin`), `coil/` (7 modules,
+`com.bitsycore.coil3`) and `pulse/` (4 modules, `com.bitsycore.pulse`) - 202 files vendored
+verbatim across three new pinned repos (`KOIN_REF=4.2.2`, `COIL_REF=3.6.2`,
+`PULSE_REF=0.3.7`), ZERO local source edits. All build for mingwX64 + linuxX64/arm64, are
+BCV-dumped, publish, and carry bridge substitution rules so consumers keep declaring the
+official coordinates.
+
+Three things worth remembering from doing it:
+
+- **nav2 is a dead end here.** koin-compose-viewmodel-navigation needs nav2's
+  `navigation-compose`, which has no mingwX64/linux klibs under either coordinate set.
+  Vendored `koin-compose-navigation3` instead - it needs only koin-compose +
+  navigation3-runtime, matching this port's nav3 story.
+- **Upstream `non*` source sets must stay ABOVE nativeMain, not merge into it.** Several
+  declare `expect`s whose `actual`s live in upstream nativeMain; collapsing both into one
+  source set makes them siblings, which is a hard error.
+- **A shared-metadata compilation is a real compile.** Coil's nonAndroid code uses
+  `org.jetbrains.skia.*` directly, so the INTERMEDIATE source set holding it needs skiko on
+  its own classpath - and since mingwX64 needs the FORK while macOS/Linux need the official
+  build, the two cannot share an intermediate. coil-core / coil-svg / coil-compose-core
+  therefore carry two PARALLEL branches over the same srcDirs, the shape
+  :compose:ui:ui-graphics already used. Kotlin emits no metadata compilation for the
+  single-target fork branch, so they never collide.
+
+Also hit the granular-metadata trap (CLAUDE.md "Common pitfalls") in coil-compose-core:
+every artifact the shared code touches must be declared DIRECTLY and get its own bridge
+rule, or `compileCommonMainKotlinMetadata` loses its transitives on the Windows publish job.
+
+REMAINING (deliberate): upstream Koin/Coil/Pulse reference the
+`org.jetbrains.androidx.lifecycle:*` mirrors while this port standardises on the GOOGLE
+`androidx.lifecycle:*` coords. The build files repoint them, but a consumer that pulls the
+jetbrains mirrors in itself will get duplicate `unique_name` klib warnings at metadata
+compile. Harmless today; if it ever becomes an error, force the google coords repo-wide.

README.md

@@ -1,196 +1,293 @@
-[![Kotlin](https://img.shields.io/badge/Kotlin-2.4.0-blue.svg?style=flat&logo=kotlin)](https://kotlinlang.org)
+[![Kotlin](https://img.shields.io/badge/Kotlin-2.4.20-blue.svg?style=flat&logo=kotlin)](https://kotlinlang.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE.md)
 
 # Compose Desktop Native
 
-A Kotlin/Native port of **Compose Multiplatform** running on **SDL3** for
-windowing and input — **no JVM**. Compiles to native binaries for macOS
-(arm64), Linux (x64/arm64), Windows (mingwX64).
+Run [Compose Multiplatform](https://github.com/JetBrains/compose-multiplatform)
+as a native binary, with no JVM. Compose Desktop Native compiles to a single
+executable for macOS (arm64), Linux (x64/arm64), and Windows (mingwX64), using
+[SDL3](https://libsdl.org) for windowing and input.
 
-Rendering is pluggable behind one `RenderBackend`:
+<img src="screenshots/demo.png" width="100%" alt="Compose Desktop Native demo" />
 
-- **Skia** (via Skiko klibs) on macOS + Linux — Metal / OpenGL / CPU raster.
-- **SDL3** (`SDL3_ttf` + `SDL_RenderGeometry`) on Windows, and on macOS/Linux
-  when `-Prenderer=sdl3` is passed.
+## How it works
 
-The Compose **runtime** is the official
-`org.jetbrains.compose.runtime:runtime` klibs from Maven — this project
-re-implements the layers on top of it (`androidx.compose.ui.*`,
-`.foundation.*`, `.animation.*`, `.material3.*`) by **vendoring
-upstream Compose Multiplatform verbatim** whenever possible and hand-rolling
-project actuals + SDL3 / Skia glue only where needed.
+- **The runtime is the real one.** Composition, snapshots, and the recomposer
+  are the official `org.jetbrains.compose.runtime` klibs from Maven, never
+  reimplemented.
+- **The UI layers are vendored upstream.** `androidx.compose.ui`, `foundation`,
+  `animation`, and `material3` are copied from Compose Multiplatform verbatim
+  wherever they compile as is, with project code filling in only the native glue.
+  The same treatment extends to ecosystem libraries that stop short of
+  Kotlin/Native desktop - Koin, Coil 3 and Pulse MVI are vendored and rebuilt for
+  these targets, and you still declare their official coordinates.
+- **Rendering is Skia everywhere.** macOS and Linux link the official Skiko
+  klibs (Metal / OpenGL); Windows links the bitsycore Skiko fork, which ships
+  Skiko and Skia together in `skiko-windows-x64.dll`.
+- **The platform is SDL3.** Windowing, input, audio, filesystem, file dialogs,
+  and clipboard all go through SDL3, so one code path covers every OS.
+- **Lean distributables.** SDL3 is built as a static library and linked in. On
+  macOS and Linux a distributable is just the executable plus a `data.kres`
+  resource bundle; on Windows it also ships `skiko-windows-x64.dll` next to the
+  exe (auto-provisioned by the bridge plugin).
 
-## Module layout
+| Platform | Gradle target | Renderer |
+|----------|---------------|----------|
+| macOS arm64 | `macosArm64` | Skia (Metal) - official Skiko |
+| Linux x64 / arm64 | `linuxX64` / `linuxArm64` | Skia (OpenGL) - official Skiko |
+| Windows | `mingwX64` | Skia - bitsycore Skiko fork |
 
-One Gradle module per upstream Compose artifact — the directory tree mirrors
-upstream's `compose/` layout, gradle paths stay short via `projectDir`
-redirects.
+## Quickstart
 
-```
-compose/
-├── ui/
-│   ├── ui/               → :ui              (androidx.compose.ui.* + renderers + cinterops)
-│   ├── ui-util/          → :ui-util
-│   ├── ui-geometry/      → :ui-geometry
-│   ├── ui-unit/          → :ui-unit
-│   └── ui-backhandler/   → :ui-backhandler
-├── animation/
-│   ├── animation-core/   → :animation-core
-│   ├── animation/        → :animation
-│   └── animation-graphics/ → :animation-graphics
-├── foundation/
-│   ├── foundation/       → :foundation
-│   └── foundation-layout/ → :foundation-layout
-├── material3/material3/  → :material3
-├── material/material-ripple/ → :material-ripple
-└── sdl/                  (project modules — the SDL integration layer)
-    └── window/           → :window          (nativeComposeApp { Window(...) } + SDL3 main loop,
-                                              per-window Lifecycle/ViewModelStore/SavedState owners)
-
-utils/
-└── material-symbols/    → :material-symbols (codepoints + Outlined/Rounded/Sharp icon fonts)
-
-components/
-└── resources/library/    → :components-resources (vendored official compose resources runtime —
-                                              painterResource/stringResource/Res codegen; the Maven
-                                              artifact ships no mingwX64/linux klibs)
-
-navigation3/
-└── navigation3-ui/       → :navigation3-ui  (vendored NavDisplay + scene machinery — the one
-                                              Navigation 3 layer without a K/N desktop artifact)
-
-demo/     → :demo     (showcase + CLI probe suite; multiplatform — the same screens
-                       also build for stock JVM Compose Desktop as a parity reference)
-apidemo/  → :apidemo  (Postman-style REST client)
-```
-
-## demo — widget & feature showcase
-
-<img src="screenshots/demo.png" width="100%" alt="ComposeNativeSDL3 demo" />
-
-`:demo` is a full tour of the re-implemented Compose + Material 3 surface —
-30+ sidebar screens covering buttons, text fields, layout, modifiers, shapes,
-images, state & recomposition, scrolling & lazy lists, dialogs, icons, canvas,
-graphics layers, custom layout, animation and gestures.
-
-```bash
-./gradlew :demo:runDebugExecutableMacosArm64      # macOS  (Skia / Metal)
-./gradlew :demo:runDebugExecutableLinuxX64        # Linux  (Skia / OpenGL)
-gradlew.bat :demo:runDebugExecutableMingwX64      # Windows (SDL3)
-./gradlew :demo:run                               # stock JVM Compose Desktop (parity reference)
-```
-
-The same shared screens drive both stacks — the JVM target runs them on
-upstream Compose Desktop unchanged, so any visual or behavioural difference
-against the native build is a porting bug, not a demo artifact.
-
-CLI: `--gpu=…`, `--screen=<Name>` (one screen, no sidebar),
-`--screenshot=out.bmp --frames=N`, `--width=W --height=H`.
-
-## apidemo — API Manager
-
-<img src="screenshots/apidemo.png" width="100%" alt="ComposeNativeSDL3 API Manager" />
-
-`:apidemo` is a Postman-style REST client built entirely on the library:
-request collections (**packs**, nested sub-packs, linked copies), a
-**Session → Pack → Request** inheritance ladder for variables / headers /
-query params / client certs, syntax-highlighted JSON / XML / YAML / HTML body
-editors, a response viewer with timing, size and TLS-chain inspection, mTLS
-client certificates, drag-and-drop tree management, request history and
-file-based sessions.
-
-```bash
-./gradlew :apidemo:runDebugExecutableMacosArm64
-./gradlew :apidemo:runDebugExecutableLinuxX64
-gradlew.bat :apidemo:runDebugExecutableMingwX64
-```
-
-Add `-Prenderer=sdl3` on macOS/Linux to drop Skiko and use the pure-SDL3
-renderer everywhere.
-
-## Minimal app
+### A window
 
 ```kotlin
 import androidx.compose.material3.Text
 import com.compose.sdl.nativeComposeWindow
 
 fun main() = nativeComposeWindow(title = "Hello") {
-    Text("Hello from ComposeNativeSDL3")
+    Text("Hello from Compose Desktop Native")
 }
 ```
 
-The lambda runs with a `ComposeWindowScope` receiver exposing
-`window: ComposeNativeWindow` (`setTitle` / `setSize` / `minimize` /
-`maximize` / `setFullscreen` / `close` / …); the same handle is reachable
-from any nested composable via `LocalComposeNativeWindow.current`.
+The content lambda runs with a `ComposeWindowScope` receiver that exposes
+`window: ComposeNativeWindow` (`setTitle`, `setSize`, `minimize`, `maximize`,
+`setFullscreen`, `close`). The same handle is reachable from any nested
+composable via `LocalComposeNativeWindow.current`.
 
-Add these to your module's `commonMain.dependencies`:
+For multiple windows, wrap them in `nativeComposeApp`, where the set of
+`Window(...)` calls is state driven (Compose Desktop style):
 
 ```kotlin
-implementation(project(":window"))            // window + main loop
-implementation(project(":material3"))         // Material 3 widgets
-implementation(project(":material-symbols"))  // icon-font composables (optional)
+fun main() = nativeComposeApp {
+    Window(title = "Main", onCloseRequest = ::exitApplication) { /* ... */ }
+    if (showInspector) {
+        Window(title = "Inspector", onCloseRequest = { showInspector = false }) { /* ... */ }
+    }
+}
 ```
 
+Each window gets its own `Lifecycle`, `ViewModelStore`, and `SavedStateRegistry`
+owners, driven by real SDL focus and visibility events, so ViewModels and
+saved state behave as they do on Android.
+
+### Building in this repo
+
+```kotlin
+commonMain.dependencies {
+    implementation(project(":compose:desktop:native:desktop-native-window")) // window shell + main loop
+    implementation(project(":compose:material3:material3"))   // Material 3 widgets
+    implementation(project(":utils:material-symbols"))        // icon-font composables (optional)
+}
+```
+
+### Building from your own project: the bridge plugin
+
+The klibs publish to [maven.bitsycore.com](https://maven.bitsycore.com/releases)
+(no auth) and GitHub Packages (authenticated fallback) under per-area coordinates that mirror
+upstream - `com.bitsycore.compose.ui:ui`, `com.bitsycore.compose.foundation:foundation`,
+… (the `com.bitsycore` fork of each `org.jetbrains.compose.*`). Apply
+the bridge Gradle plugin once, declare the **official** Compose Multiplatform
+coordinates, and the plugin swaps in the port's klibs on native desktop targets
+while android, jvm, iOS, and wasm keep resolving the official artifacts.
+
+```kotlin
+// build.gradle.kts, official coordinates everywhere
+plugins {
+    kotlin("multiplatform")
+    id("org.jetbrains.compose")
+    id("com.bitsycore.compose-desktop-native.bridge") version "<release>"
+}
+
+commonMain.dependencies {
+    // The plugin exposes the exact Compose versions the port tracks, so you
+    // never hand-match them (material3 is versioned separately upstream).
+    implementation("org.jetbrains.compose.runtime:runtime:${composeDesktopNative.composeRuntime}")
+    implementation("org.jetbrains.compose.ui:ui:${composeDesktopNative.compose}")
+    implementation("org.jetbrains.compose.foundation:foundation:${composeDesktopNative.compose}")
+    implementation("org.jetbrains.compose.material3:material3:${composeDesktopNative.composeMaterial3}")
+}
+```
+
+**One repository, no credentials.** `https://maven.bitsycore.com/releases`
+carries both the port's artifacts and the bitsycore skiko fork
+(`com.bitsycore.skiko`), which the Windows (mingwX64) target renders through;
+macOS/Linux pull the official skiko from Maven Central instead. The exact
+`repositories {}` snippet and version pinning:
+[gradle-plugin/compose-desktop-native-bridge/README.md](gradle-plugin/compose-desktop-native-bridge/README.md).
+
+For a complete project that applies the bridge and builds one shared UI for
+Android, JVM, and native desktop, see the example repo:
+[bitsycore/compose-desktop-native-bridge-example](https://github.com/bitsycore/compose-desktop-native-bridge-example).
+
+## Sample apps
+
+Both live in `commonMain` and also build for stock JVM Compose Desktop, which
+serves as the visual and behavioural reference: any difference against the
+native build is a porting bug.
+
+**`:demo`** is a tour of the re-implemented Compose and Material 3 surface,
+30-plus screens covering text, layout, shapes, images, state, lazy lists,
+dialogs, canvas, graphics layers, animation, and gestures.
+
+```bash
+./gradlew :demo:runDebugExecutableMacosArm64   # macOS (Skia / Metal)
+./gradlew :demo:runDebugExecutableLinuxX64     # Linux (Skia / OpenGL)
+gradlew.bat :demo:runDebugExecutableMingwX64   # Windows (Skia / Skiko fork)
+./gradlew :demo:run                            # JVM Compose Desktop (reference)
+```
+
+**`:apidemo`** is a Postman-style REST client built entirely on the library:
+request collections, a session inheritance ladder, syntax-highlighted body
+editors, a response viewer with timing and TLS-chain inspection, and mTLS
+client certificates.
+
+<img src="screenshots/apidemo.png" width="100%" alt="Compose Desktop Native API Manager" />
+
+```bash
+./gradlew :apidemo:runDebugExecutableMacosArm64
+./gradlew :apidemo:run                         # JVM Compose Desktop (reference)
+```
+
+## Modules
+
+One Gradle module per upstream artifact, and the Gradle path mirrors the
+directory (`:compose:ui:ui`, `:compose:foundation:foundation`, …). The renderer
+lives in `:compose:ui:ui` and the `sdl3` cinterop in `:sdl:sdl-core`;
+`:compose:desktop:native:desktop-native-window` is the SDL integration layer.
+
+Most of the androidx architecture stack (lifecycle, viewmodel, navigation3,
+savedstate, navigationevent) ships real Kotlin/Native desktop klibs and runs on
+the port unmodified. Where an ecosystem library stops short of Kotlin/Native
+desktop, this repo vendors it verbatim from upstream and rebuilds it for these
+targets, so you keep writing against the official coordinates:
+
+| Vendored | Why | Published as |
+|----------|-----|--------------|
+| Compose `ui` / `foundation` / `animation` / `material3` | the port itself | `com.bitsycore.compose.*` |
+| `components-resources`, `navigation3-ui` | no mingwX64 / linux klibs | `com.bitsycore.compose.components`, `com.bitsycore.navigation3` |
+| **Koin** viewmodel + compose modules | apple + android only upstream (`koin-core` itself is fine) | `com.bitsycore.koin` |
+| **Coil 3** (whole stack) | no mingwX64 anywhere; no desktop native at all for its compose layer | `com.bitsycore.coil3` |
+| **Pulse MVI** | no desktop-native artifact upstream | `com.bitsycore.pulse` |
+
+The bridge plugin substitutes each of these on native desktop configurations, so
+app code declares `io.insert-koin:koin-compose`, `io.coil-kt.coil3:coil-compose`
+and so on exactly as it would anywhere else. The full module map, dependency
+graph, and the list of compatible artifacts are in [CLAUDE.md](CLAUDE.md).
+
+## Pinned versions
+
+Everything below is pinned in exactly two files -
+[`gradle/libs.versions.toml`](gradle/libs.versions.toml) (Maven coordinates) and
+[`scripts/compose-fork/compose.properties`](scripts/compose-fork/compose.properties)
+(the upstream git refs the vendored sources are copied from) - plus
+[`scripts/build-sdl/build-sdl.properties`](scripts/build-sdl/build-sdl.properties)
+for SDL3. A release tracks one Compose Multiplatform version; the table is the
+contract.
+
+**Version policy.** Anything Compose Multiplatform integrates is pinned to what
+CMP ships - for the androidx mirrors, the *Jetpack* version CMP's release notes
+map its `org.jetbrains.androidx.*` artifact to, since this port consumes the
+google coordinates. Anything CMP does not integrate is pinned to the latest
+release. Deliberate exceptions are commented in the catalog; there is currently
+one (`savedstate`, below).
+
+### Toolchain
+
+| | Version | Notes |
+|---|---|---|
+| Kotlin | **2.4.20** | Newer than the 2.3.20 CMP 1.12.0 is built with. Kotlin/Native consumes older klibs fine, and the whole port builds clean on 2.4.20 with no klib API diff, so there is no reason to hold back. |
+| Compose Multiplatform | **1.12.0** | The vendored sources are the `v1.12.0` tag of both upstream repos, and the JVM parity leg forces the same version - no dev-build skew. |
+| SDL3 | **release-3.4.16** | Built from source as a static lib per host (`scripts/build-sdl/build-all.py`), linked into the executable. |
+| Skiko | **0.150.1** | macOS / Linux use the official `org.jetbrains.skiko`. |
+| Skiko (Windows fork) | **0.150.1-mingw.2** | `com.bitsycore.skiko:skiko` - Skiko + Skia in `skiko-windows-x64.dll`. Same Skia base as the official build. Public repo, no auth. |
+
+### Compose libraries
+
+The port republishes each vendored artifact under a `com.bitsycore` group that
+mirrors the upstream one, so the fork of any given coordinate is obvious. Apply
+the bridge plugin and you keep declaring the **official** coordinate.
+
+| Library | Official coordinate | Port coordinate |
+|---|---|---|
+| Runtime | `org.jetbrains.compose.runtime:runtime*:1.12.0` | *not forked - the official klibs serve every target* |
+| UI | `org.jetbrains.compose.ui:ui*:1.12.0` | `com.bitsycore.compose.ui:ui*` |
+| Foundation | `org.jetbrains.compose.foundation:foundation*:1.12.0` | `com.bitsycore.compose.foundation:foundation*` |
+| Animation | `org.jetbrains.compose.animation:animation*:1.12.0` | `com.bitsycore.compose.animation:animation*` |
+| Material Ripple | `org.jetbrains.compose.material:material-ripple:1.12.0` | `com.bitsycore.compose.material:material-ripple` |
+| Material3 | `org.jetbrains.compose.material3:material3:1.12.0-alpha03` | `com.bitsycore.compose.material3:material3` |
+| Resources | `org.jetbrains.compose.components:components-resources:1.12.0` | `com.bitsycore.compose.components:components-resources` |
+| Navigation3 UI | `org.jetbrains.androidx.navigation3:navigation3-ui` | `com.bitsycore.navigation3:navigation3-ui` |
+| Window shell | *no upstream equivalent* | `com.bitsycore.compose:desktop-native-window` |
+| SDL layer | *no upstream equivalent* | `com.bitsycore.compose.sdl:sdl-core` |
+
+Material3 rides its own release train upstream: `1.12.0-alpha03` **is** the
+version Compose Multiplatform 1.12.0 ships (Jetpack Material3 1.5.0-alpha22).
+
+### Ecosystem libraries
+
+Vendored because upstream stops short of Kotlin/Native desktop. The bridge
+substitutes them on native desktop targets only.
+
+| Library | Official coordinate | Port coordinate | Why |
+|---|---|---|---|
+| Koin | `io.insert-koin:koin-compose*:4.2.2` | `com.bitsycore.koin:*` | apple + android only upstream |
+| Koin core | `io.insert-koin:koin-core:4.2.2` | *not forked* | already ships mingwX64 + linux |
+| Coil 3 | `io.coil-kt.coil3:coil*:3.6.2` | `com.bitsycore.coil3:*` | no mingwX64 anywhere; no desktop native at all for the compose layer |
+| Pulse MVI | `com.bitsycore.lib:pulse*:0.3.7` | `com.bitsycore.pulse:*` | no desktop-native artifact upstream |
+
+Koin's `koin-compose-viewmodel-navigation` is deliberately **not** provided: it
+needs Navigation 2's `navigation-compose`, which has no mingwX64 or linux klibs
+under either coordinate set. Use `koin-compose-navigation3`.
+
+### AndroidX, used as-is
+
+These publish real Kotlin/Native desktop klibs and run on the port unmodified -
+nothing is vendored or substituted. The port standardises on the **google**
+`androidx.*` coordinates; do not also pull the `org.jetbrains.androidx.*`
+mirrors or you will have every class twice.
+
+| Library | Coordinate |
+|---|---|
+| Lifecycle / ViewModel | `androidx.lifecycle:lifecycle-*:2.11.0` |
+| SavedState | `androidx.savedstate:savedstate*:1.5.0` (CMP builds against 1.4.0; lifecycle 2.11.0 requires it only as a *minimum*, so 1.5.0 resolves cleanly and gives consumers the newer API) |
+| Navigation3 runtime | `androidx.navigation3:navigation3-runtime:1.2.0-alpha04` |
+| Navigation Event | `androidx.navigationevent:navigationevent-compose:1.1.2` |
+| Collection | `androidx.collection:collection:1.5.0` |
+| Graphics Shapes | `androidx.graphics:graphics-shapes:1.1.0` |
+
+### Infrastructure
+
+| Library | Version |
+|---|---|
+| kotlinx-coroutines | 1.11.0 |
+| kotlinx-serialization | 1.11.0 |
+| kotlinx-datetime | 0.8.0 |
+| kotlinx-io-okio | 0.9.1 |
+| Okio | 3.18.2 |
+| Ktor | 3.5.2 |
+
 ## Building
 
-- **macOS:** `brew install sdl3` (Skia is the default; Skiko klibs come from
-  Maven).
-- **Linux:** `sudo apt install libsdl3-dev`.
-- **Windows:** SDL3, SDL3_ttf, SDL3_image and FreeType are built from source
-  as **static** libraries by `scripts/build-sdl/build-all.sh` into the gitignored
-  in-repo `libs/`, then linked into the executable — the Windows
-  distributable is just `<app>.exe` + `data.kres`, no runtime DLLs.
-
-## Vendoring
-
-The bulk of the `androidx.compose.*` code is vendored byte-for-byte from
-`JetBrains/compose-multiplatform-core` and lives under
-`<module>/src/vendor/` (gitignored — you re-sync on demand). Each module
-carries a `compose-fork.txt` manifest listing which upstream files it pulls
-in.
+Build the native libraries once per machine, then build any app target:
 
 ```bash
-scripts/compose-fork/sync.sh                           # sync every module
-scripts/compose-fork/sync.sh compose/ui/compose-fork.txt   # one module
+python3 scripts/build-sdl/build-all.py         # SDL3 (static)
+./gradlew :demo:runDebugExecutableMacosArm64
 ```
 
-Upstream ref pinned in `scripts/compose-fork/compose.properties`; manifests can
-pin additional upstream repos inline (`SET_REPO=<url>@<ref>` — the resources
-runtime vendors from the compose-multiplatform umbrella repo this way).
+Every host needs `git`, `cmake`, and Python 3. Per host: macOS needs the Xcode
+command line tools; Linux needs gcc/g++ and the X11 / Wayland / audio dev
+headers; Windows needs a mingw-w64 g++ on PATH. See [TOOLING.md](TOOLING.md) for
+the full build and verification workflow.
 
-See [CLAUDE.md](CLAUDE.md) for the full architecture, source-set hierarchy,
-vendoring rules, density flow (physical-pixel Option B), and per-area file
-map.
+## Documentation
 
-## Known Compatible — official artifacts that just work
-
-A surprising amount of the androidx architecture stack ships real
-Kotlin/Native desktop klibs (mingwX64, linuxX64/arm64, macosArm64) and runs
-on this port **unmodified** — no reimplementation, no vendoring. Sometimes
-the Google coordinates (`androidx.*`) carry the K/N variant, sometimes the
-JetBrains ones (`org.jetbrains.*`) — check both.
-
-Verified working in-tree:
-
-| Artifact                                                        | Notes                                                                                      |
-|-----------------------------------------------------------------|--------------------------------------------------------------------------------------------|
-| `org.jetbrains.compose.runtime:runtime`, `runtime-saveable`     | the Compose runtime itself — never reimplemented                                           |
-| `androidx.compose.runtime:runtime-retain`                       | google coordinates                                                                         |
-| `androidx.lifecycle:lifecycle-runtime-compose`                  | `LocalLifecycleOwner`, `rememberLifecycleOwner`, `repeatOnLifecycle`                       |
-| `androidx.lifecycle:lifecycle-viewmodel(-compose, -savedstate)` | full ViewModel + SavedStateHandle stack                                                    |
-| `androidx.lifecycle:lifecycle-viewmodel-navigation3`            | per-entry ViewModel scoping for Navigation 3                                               |
-| `androidx.savedstate:savedstate`, `savedstate-compose`          |                                                                                            |
-| `androidx.navigation3:navigation3-runtime`                      | backstack / NavEntry / decorators (only the UI layer needed vendoring → `:navigation3-ui`) |
-| `androidx.navigationevent:navigationevent-compose`              | predictive back / BackHandler plumbing                                                     |
-| `androidx.collection:collection`                                |                                                                                            |
-
-The window layer supplies what these expect from a host: per-window
-`LifecycleOwner` (driven by real SDL focus/visibility events — focused →
-RESUMED, unfocused → STARTED, minimized → CREATED), `ViewModelStoreOwner`
-(the `activityViewModels()` analog, `SavedStateHandle`-enabled) and
-`SavedStateRegistryOwner`, plus a `Dispatchers.Main` with a true `immediate`.
-ViewModels scope per nav entry, per window, or anywhere in between — same
-semantics as Android.
+- [TOOLING.md](TOOLING.md): building the native libs, vendoring, and verification.
+- [CLAUDE.md](CLAUDE.md): architecture, source-set hierarchy, vendoring rules,
+  density flow, and a per-area file map.
+- [gradle-plugin/compose-desktop-native-bridge](gradle-plugin/compose-desktop-native-bridge/README.md):
+  consuming the port from another build.
 
 ## License
 

TOOLING.md

@@ -0,0 +1,257 @@
+# Tooling
+
+Helper scripts and workflows used to build, vendor, and verify Compose Desktop
+Native. Each has a focused job; the deeper ones link to their own README.
+
+For architecture, source-set layout, and vendoring rules, see
+[CLAUDE.md](CLAUDE.md).
+
+## Native libraries
+
+SDL3 is built from source as a static library and linked straight into the
+executable - the windowing, input, and platform-integration layer. One script
+does it on every OS. Output lands in the gitignored `libs/`; the version is
+pinned in `scripts/build-sdl/build-sdl.properties`.
+
+```bash
+python3 scripts/build-sdl/build-all.py            # sdl3
+python3 scripts/build-sdl/build-all.py sdl3       # rebuild the step
+```
+
+Needs `git`, `cmake`, and Python 3 on every host (`ninja` is fetched when
+absent). Run it once per machine, or after bumping the pinned version.
+
+The static lib is built **slim**: the port uses SDL only for video/window,
+events, clipboard, file dialogs, GL/Metal contexts, the CPU-raster `SDL_Render`
+blit, filesystem, cursor, locale, theme, and text input/IME. `build-all.py`
+disables every unused subsystem - audio, joystick, haptic, hidapi, sensor,
+power, camera, GPU, offscreen, virtual-joystick (all zero-reference), plus
+tests/examples and the Windows D3D12 driver. If a consumer app ever needs one of
+these (e.g. SDL audio), re-enable its `-DSDL_*` flag in `build-all.py` and
+rebuild - a build-time change, no code edit.
+
+## Vendoring upstream Compose
+
+Most `androidx.compose.*` code is copied byte for byte from
+`JetBrains/compose-multiplatform-core` into each module's gitignored
+`src/vendor/`. A `compose-fork.txt` manifest per module lists which upstream
+files it pulls; the pinned ref lives in `scripts/compose-fork/compose.properties`.
+
+```bash
+scripts/compose-fork/sync.sh                             # re-sync every module
+scripts/compose-fork/sync.sh compose/ui/ui/compose-fork.txt   # one module
+```
+
+Reach for this after a fresh checkout or a ref bump. Details:
+[scripts/compose-fork/README.md](scripts/compose-fork/README.md).
+
+Guardrails that keep the vendor tree honest:
+
+```bash
+python3 scripts/compose-fork/check-vendor-clean.py     # src/vendor matches the pinned refs
+python3 scripts/compose-fork/check-vendor-drift.py     # hand-edited "manual vendors" match their pin
+python3 scripts/compose-fork/audit-exclusions.py       # every `!` exclusion is classified
+```
+
+`check-vendor-clean` fails if a hand-edit ever leaks into `src/vendor/`.
+`check-vendor-drift` reads the `// VENDOR-BASE:` header on every edited copy and,
+using the local upstream clone, reports whether the base actually changed since
+the pin (needs reconciling) or is merely stale (safe to re-stamp).
+
+`audit-exclusions` covers the other half: a manifest `!` line takes a file OUT of
+the verbatim sync, and the local replacement is either a derived copy
+(`// VENDOR-BASE:`, drift-tracked) or a fresh reimplementation
+(`// VENDOR-REIMPL:`, deliberately not tracked - only a SIGNATURE change matters).
+It classifies each one, flags any local counterpart carrying NEITHER marker
+(invisible to the drift check, silently rotting) and any copy that has become
+identical to upstream (drop it and re-vendor), and exits non-zero on an
+unclassified file. Run all three on every ref bump.
+
+### Coverage against upstream
+
+How much of upstream's public API the port covers is measured, not guessed.
+
+```bash
+./gradlew apiDump && python3 scripts/compose-coverage.py   # per-module coverage tables
+python3 scripts/compose-coverage.py --missing ui-text      # list uncovered declarations
+```
+
+## Verification
+
+### One-command gate
+
+`verify-mac.sh` is the runbook to run after any renderer or layout change. On
+macOS or Linux it exercises the Skia renderer and exits non-zero on any
+failure:
+
+```bash
+scripts/verify-mac.sh
+```
+
+It runs: the vendor drift and clean checks, a build of `:demo` and `:apidemo`,
+the interaction probes, the parity sweep, a memory soak, and a frame-time spot
+check. The Windows target is verified separately (see below).
+
+### Parity: native vs JVM
+
+`:demo` renders the same shared screens on two stacks: this port, and stock JVM
+Compose Desktop. `parity.py` screenshots every screen on both and pixel-diffs
+them, so a screen that diverges is a porting bug. It gates against per-screen
+golden baselines.
+
+```bash
+python3 scripts/parity/parity.py                 # all screens
+python3 scripts/parity/parity.py Buttons Shapes  # a subset
+python3 scripts/parity/parity.py --no-build      # reuse the last renders
+```
+
+How to read the diff and the percentage: [scripts/parity/README.md](scripts/parity/README.md).
+
+### Interaction probe
+
+`probe.py` launches a native window, sends window-relative input (click, hover,
+hold), and captures the client area. It packages the rigs used to reproduce
+interaction bugs. Windows-only. Details:
+[scripts/probe/README.md](scripts/probe/README.md).
+
+### Frame profiler
+
+Set `CDN_PROFILE=1` (or `CDN_PROFILE=<path>`) and run any app. Every couple of
+seconds it writes per-phase main-loop timings (events, app pump, render, with
+draw sub-phases and per-frame draw counters) to a file. `CDN_FORCERENDER=1`
+renders every frame so steady-state timings read on an otherwise idle screen.
+
+```bash
+CDN_PROFILE=1 CDN_FORCERENDER=1 ./demo/build/bin/macosArm64/debugExecutable/demo.kexe
+```
+
+Note: `present` is vsync-blocking, so profile on the target refresh rate before
+drawing conclusions about a frame-rate gap.
+
+### Text metrics diagnostic
+
+Set `CDN_TEXT_METRICS=1` and run any app to dump, per built paragraph, the font
+scaler's `ascent`/`descent`/`leading`, the resolved `familyName` + `fontPx`, and
+the resulting paragraph line box (`paraHeight`, `line0[ascent/descent/baseline/
+height]`). Its job is the mac-vs-Windows vertical-spacing question (PLAN.md §1b):
+the SAME `NotoSans.ttf` bytes go through a different Skia `FontMgr` scaler per
+host (CoreText / fontconfig-FreeType / DirectWrite), which can pick different
+metric tables. Run it on native AND on the JVM parity app on the SAME host and
+diff the lines - Windows-native must match skiko-JVM-Windows.
+
+```bash
+CDN_TEXT_METRICS=1 demo.kexe --screen=Buttons --screenshot=/tmp/b.bmp
+```
+
+### Demo probes
+
+`:demo` ships headless regression probes driven by CLI flags, used by the
+verify runbook and in isolation:
+
+```bash
+demo.kexe --nav3test        # Navigation 3 + ViewModel + lifecycle
+demo.kexe --backtest        # predictive-back / BackHandler
+demo.kexe --clicktest       # pointer -> upstream clickable
+demo.kexe --scrolltest      # wheel -> scrollable
+demo.kexe --multiwintest    # multi-window lifecycle
+demo.kexe --soaktest        # memory soak (CDN_SOAK_SCREEN, CDN_SOAK_STATIC, CDN_SOAK_CYCLES)
+```
+
+### Windows smoke
+
+The Mac runbook cannot cover the Windows target. Before shipping, on a Windows
+host: build the mingwX64 executables, run `scripts/probe/`, and run a publish
+dry run (only Windows compiles the full common-metadata variant table).
+
+```bat
+gradlew.bat :demo:runDebugExecutableMingwX64
+gradlew.bat :apidemo:runDebugExecutableMingwX64
+```
+
+mingwX64 renders through Skia via the **bitsycore skiko fork**, consumed from
+the PUBLIC `https://maven.bitsycore.com/releases` (no credentials) as
+`com.bitsycore.skiko:skiko:0.150.1-mingw.2` (macOS/Linux use official Skiko). The runtime `skiko-windows-x64.dll` is auto-provisioned next
+to the executable by the bridge plugin - no manual copy. The fork itself is
+published by a separate GitHub Actions workflow in the fork repo, out of band
+from this repo's release flow.
+
+## Consuming the port
+
+To build a third-party app against the published klibs, apply the bridge Gradle
+plugin and declare official Compose Multiplatform coordinates; the plugin swaps
+in the port's klibs on native desktop targets. Setup:
+[gradle-plugin/compose-desktop-native-bridge/README.md](gradle-plugin/compose-desktop-native-bridge/README.md).
+
+## Versioning and releasing
+
+### Version map
+
+Versions live in a few places, some of which move in lockstep. There is no
+single file to edit; know which axis you are changing.
+
+| Version | Where | Notes |
+|---------|-------|-------|
+| Project release version | The git tag `vX.Y.Z`. `PUBLISH_VERSION` (from the tag) feeds `vPublishVersion` in `build.gradle.kts`, which strips the leading `v`. Groups mirror upstream per area (`com.bitsycore.compose.<area>:<module>`, e.g. `com.bitsycore.compose.ui:ui`); project-only modules use `com.bitsycore.compose.sdl` and `:desktop-native-window` is `com.bitsycore.compose` - see `groupFor()` in the root build. | Set by the tag, not edited by hand. A non-publish build is `0.0.0-SNAPSHOT`. |
+| Vendored Compose (native side) | `COMPOSE_CORE_REF` and `COMPOSE_REF` in `scripts/compose-fork/compose.properties`, plus `compose` in `gradle/libs.versions.toml`. | Pin to a durable tag (not a `+dev` commit upstream may GC). Re-sync after changing. |
+| Vendored ecosystem libs | `KOIN_REF`, `COIL_REF`, `PULSE_REF` in the same file, plus `koin` / `coil` in `gradle/libs.versions.toml`. | Same rule: durable tags. Each repo gets its own sibling sparse clone (`../cmp-ref-koin`, `../cmp-ref-coil`, `../cmp-ref-pulse-mvi`). Re-sync, then `apiDump` - these modules are BCV-validated like the rest. |
+| JVM parity forcing | `compose` / `composeMaterial3` / `composeRuntime` in `gradle/libs.versions.toml` (read by `demo`, `apidemo`, `material-symbols` and the root build's forcing map). | Must be a version PUBLISHED to Maven Central. It may lag the vendored native ref (a documented skew) until the matching version is published; at v1.12.0 they are in lockstep. |
+| Skiko | `skiko` (official) and `skikoMingw` (the fork) in `gradle/libs.versions.toml`; keep the fork's `-mingw.N` base equal to `skiko`. | macOS/Linux use official Skiko (`org.jetbrains.skiko`); mingwX64 uses the bitsycore fork (`com.bitsycore.skiko:skiko:0.150.1-mingw.2` from the public maven.bitsycore.com), published out of band by the fork repo's own workflow. Must expose the `org.jetbrains.skiko.node` `RenderNode` / `GraphicsContext` API the vendored compose-core uses (the fork keeps upstream's `org.jetbrains.skiko.*` package names; only the Maven coord is rebranded). Verify with a throwaway `skikoRendererMain` compile if unsure. |
+| SDL3 | `scripts/build-sdl/build-sdl.properties`. | Rebuild `libs/` with `build-all.py` after any change. |
+| Bridge substituted version | Defaults to the bridge plugin's own published version; consumers override with the `composeDesktopNative.version` Gradle property. | The plugin publishes with the release tag, so a consumer on the matching plugin version resolves the right klibs automatically. |
+
+### Bump the upstream Compose ref
+
+Run this on each upstream bump; it is the flow that keeps the sync tax low.
+
+1. Edit the relevant `*_REF` in `compose.properties` - `COMPOSE_CORE_REF` /
+   `COMPOSE_REF` for Compose, `KOIN_REF` / `COIL_REF` / `PULSE_REF` for the
+   ecosystem libs (and the matching entry in `libs.versions.toml` if the
+   coordinate version moved).
+2. `scripts/compose-fork/sync.sh`
+3. `python3 scripts/compose-fork/check-vendor-drift.py`. For any manual vendor
+   whose upstream base actually changed, reconcile by hand; otherwise re-stamp
+   its `// VENDOR-BASE:` header to the new ref. Then
+   `python3 scripts/compose-fork/audit-exclusions.py` - a newly-identical copy
+   should go back to verbatim vendoring, and an unclassified one needs a marker.
+   Finish with `./gradlew apiDump` and review the klib API diff.
+4. Build and fix any fallout.
+5. `scripts/verify-mac.sh` (green, including the soak and parity gates).
+6. If a matching Compose version is now published to Maven, bump
+   `vComposeJvmVersion` in demo/apidemo/material-symbols to close the skew.
+7. Run WIN-SMOKE on a Windows host.
+8. Re-seed parity baselines only if metrics legitimately moved
+   (`parity.py --update-baselines`), and record why.
+
+### Cut a release
+
+1. Complete the ref-bump flow above and confirm it is green. For a STABLE
+   release, `vComposeJvmVersion` should match the vendored ref (no skew).
+2. On a Windows host, run `gradlew :desktop-native-window:compileCommonMainKotlinMetadata`.
+   Only Windows compiles the full common-metadata variant table, and the root
+   KotlinMultiplatform publications live there; a macOS-only publish leaves the
+   roots without mingwX64 variants (this bit v0.1.15).
+3. Refresh the klib API baselines: on a Windows host (JDK 21, matching CI) run
+   `./gradlew apiDump` and commit any diff. Not a hard gate yet - the API is
+   pre-stable and `apiCheck` isn't wired - but regenerating each release keeps
+   the baselines honest so the eventual gate is a no-op. `macosArm64` is inferred
+   from the linux/mingw ABIs (accurate for the target-independent Compose
+   surface); `:sdl-core` (cinterop) and `:material-symbols` (generated icon maps)
+   are excluded via `apiValidation.ignoredProjects`. Best host: Windows - it
+   builds the mingw slice (the fork's unique surface) for real and only infers
+   macos; the macos ABI is target-independent for the tracked pure-Kotlin modules.
+4. `git tag vX.Y.Z && git push origin vX.Y.Z`. This triggers `.github/workflows/publish.yml`.
+
+What the publish job does, so you can read a failure:
+
+- Each host publishes only its own target's publications to GitHub Packages
+  under their per-area `com.bitsycore.compose.*` coords. Windows additionally publishes the root
+  KotlinMultiplatform metadata, the `jvm` publication, and the bridge plugin
+  (only Windows declares every target).
+- The `MODULES` list in the workflow must stay in sync with the modules in
+  `settings.gradle.kts`.
+- A partial publish (for example a dropped connection mid-upload) deletes this
+  host's half-published versions for the tag and retries, so a rerun is safe.
+- The demo and apidemo release binaries are zipped and attached to the GitHub
+  Release for the tag.
+
+4. Verify a consumer build against the new version resolves through the bridge.

apidemo/build.gradle.kts

@@ -1,76 +1,75 @@
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
-import org.jetbrains.kotlin.gradle.plugin.mpp.NativeBuildType
-
-// :apidemo — a Postman-style REST API manager built on the compose-desktop-native
-// stack. Uses Ktor with the Curl engine on every desktop target (bundled
-// libcurl: Schannel on Windows, OpenSSL on macOS/Linux),
-// kotlinx.serialization for the savable "packs", and okio for file I/O.
+import com.bitsycore.compose.sdl.build.registerComposeFontBundling
 
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
     alias(libs.plugins.kotlin.plugin.compose)
     alias(libs.plugins.compose.multiplatform)
     alias(libs.plugins.kotlin.plugin.serialization)
+    id("com.bitsycore.compose-desktop-native.bridge")
 }
 
-// Skip mingwX64 on non-Windows hosts; see root build.gradle.kts.
-val vHostSupportsMingw: Boolean by rootProject.extra
+val isHostMingwCompatible = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+// ==================
+// MARK: Targets
+// ==================
 
 kotlin {
-    linuxArm64()
-    linuxX64()
-    macosArm64()
-    if (vHostSupportsMingw) mingwX64()
+    jvm()
 
-    targets.withType<KotlinNativeTarget>().all {
-        val isMingw = name == "mingwX64"
-        val isLinux = name.startsWith("linux")
-        val isApple = name.startsWith("macos") || name.startsWith("ios")
-        binaries.executable {
-            if (buildType == NativeBuildType.RELEASE) {
-                // --gc-sections is a GNU ld/lld flag; Apple's ld64 rejects it
-                // (it dead-strips at -O anyway). Only pass it on GNU-ld targets.
-                if (!isApple) linkerOpts("-Wl,--gc-sections")
-                compilerOptions {
-                    freeCompilerArgs.add("-opt")
-                }
-            }
-
-            entryPoint = "apidemo.main"
-            // SDL3 + SDL3_ttf + SDL3_image + FreeType + image codecs come from
-            // :ui's cinterop klibs (staticLibraries directive in each .def); the
-            // system libs they need are in sdl3.def's linkerOpts.<target>. Only
-            // shell-level flags and app-specific extras (crypt32 for mTLS) live
-            // here. Ktor's Curl engine bundles its own libcurl + TLS stack.
-            if (isMingw) linkerOpts(
-                // crypt32: client-cert (mTLS) import into the Windows cert store
-                // (CertOpenStore / PFXImportCertStore / CertAddCertificateContextToStore…).
+    buildList {
+        add(linuxArm64())
+        add(linuxX64())
+        add(macosArm64())
+        if (isHostMingwCompatible) add(mingwX64())
+    }.forEach {
+        it.binaries {
+            executable {
+                when {
+                    target.name == "mingwX64" -> linkerOpts(
+                        // crypt32: client-cert (mTLS) import into the Windows cert store.
                         "-lcrypt32",
-                // Code-shrink: drop unused sections and strip symbols.
                         "-Wl,--gc-sections", "-Wl,-s",
-                // GUI subsystem so launching the .exe pops no console window.
-                // Keep the standard C `main` entry — ld would otherwise default
-                // a GUI-subsystem PE to WinMainCRTStartup (needs WinMain) and
-                // fail to link, since Kotlin/Native emits `main`.
+                        // GUI subsystem (no console window), keeping the C `main` entry.
                         "-Wl,--subsystem,windows", "-Wl,-e,mainCRTStartup",
                     )
-            // Skia (default renderer) references the system graphics stack.
-            // K/N's LLD sysroot on linuxX64 doesn't include the host's multi-arch
-            // dir, so add the -L for both x86_64 and aarch64 (harmless if either
-            // is absent — LLD skips missing dirs).
-            if (isLinux) linkerOpts(
+
+                    target.name.startsWith("linux") -> linkerOpts(
                         "-L/usr/lib/x86_64-linux-gnu", "-L/usr/lib/aarch64-linux-gnu",
                         "-lfontconfig", "-lGL", "-lX11",
                     )
                 }
             }
+        }
+    }
+
+    applyDefaultHierarchyTemplate()
 
     sourceSets {
         commonMain {
             dependencies {
-                implementation(project(":window"))
-                implementation(project(":material3"))
-                implementation(project(":material-symbols"))
+                val vComposeJvmVersion = libs.versions.compose.get()
+                val vComposeM3JvmVersion = libs.versions.composeMaterial3.get()
+
+                // Official Maven coords for everything the shared UI touches; native
+                // configurations substitute them for the port modules automatically
+                // (root bridge in-repo, the bridge plugin for consumers).
+                implementation("org.jetbrains.compose.runtime:runtime:${libs.versions.composeRuntime.get()}")
+                implementation("org.jetbrains.compose.ui:ui:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.ui:ui-graphics:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.ui:ui-text:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.ui:ui-unit:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.ui:ui-geometry:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.ui:ui-util:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.foundation:foundation:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.foundation:foundation-layout:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.animation:animation:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.animation:animation-core:$vComposeJvmVersion")
+                implementation("org.jetbrains.compose.material3:material3:$vComposeM3JvmVersion")
+
+                // Common Material Symbols Utility
+                implementation(project(":utils:material-symbols"))
+
                 implementation(libs.ktor.client.core)
                 implementation(libs.ktor.client.content.negotiation)
                 implementation(libs.ktor.serialization.kotlinx.json)
@@ -80,17 +79,23 @@ kotlin {
                 implementation(libs.kotlinx.datetime)
             }
         }
-        // Single HTTP engine on every desktop target: Ktor's Curl engine. It
-        // bundles a static libcurl per target (Schannel on Windows, OpenSSL on
-        // macOS/Linux) embedded in its cinterop klib — no runtime DLL, one copy.
-        // We use Curl everywhere (not WinHttp/Darwin) so that an upcoming
-        // client-certificate (mTLS) path — which calls the same bundled libcurl
-        // directly, since Ktor's engines expose no client-cert API — shares the
-        // exact same TLS stack as ordinary requests.
-        if (vHostSupportsMingw) getByName("mingwX64Main").dependencies { implementation(libs.ktor.client.curl) }
-        getByName("macosArm64Main").dependencies { implementation(libs.ktor.client.curl) }
-        getByName("linuxX64Main").dependencies { implementation(libs.ktor.client.curl) }
-        getByName("linuxArm64Main").dependencies { implementation(libs.ktor.client.curl) }
+        nativeMain {
+            dependencies {
+                implementation(project(":compose:desktop:native:desktop-native-window"))
+                implementation(libs.ktor.client.curl)
+            }
+        }
+        jvmMain {
+            dependencies {
+                implementation(compose.desktop.currentOs)
+                // decodeToImageBitmap / decodeToSvgPainter (window icon + in-memory
+                // image viewer). JVM-only: the native side goes through the port's
+                // own EncodedImageDecoder seam, so this stays out of commonMain.
+                implementation("org.jetbrains.compose.components:components-resources:${libs.versions.compose.get()}")
+                implementation(libs.ktor.client.cio)
+                implementation(libs.kotlinx.coroutines.swing)
+            }
+        }
     }
 
     compilerOptions {
@@ -99,181 +104,46 @@ kotlin {
     }
 }
 
-// SDL3 / SDL3_ttf / SDL3_image / FreeType are linked statically into the
-// executable (see the mingw linkerOpts above), so there are no runtime DLLs to
-// bundle — the distributable is just <app>.exe + data.kres.
-val variants = listOf("debug", "release")
+compose.desktop {
+    application {
+        mainClass = "apidemo.MainJvmKt"
+    }
+}
 
-// ==================
-// MARK: Bundle the default font (data.kres) next to each native executable
-// ==================
-// Default UI font (Noto Sans) + monospace body font (Noto Sans Mono) are
-// downloaded by :core and exposed through these generic "extra" handles (the
-// same handshake the :material-symbols:* modules use). The renderers load
-// NotoSans (variable) as the default; apidemo registers NotoSansMono (variable)
-// with IconFont under "noto-mono" for the body editor.
-val nativeTargets = listOf("macosArm64", "linuxX64", "linuxArm64", "mingwX64")
-// :core downloads the variable Noto fonts into its build/fonts. Reference them
-// by layout (lazy providers, no evaluation of :core needed) and depend on the
-// download task by path so ordering doesn't rely on :core being configured first.
-val coreBuildDir = rootProject.project(":ui").layout.buildDirectory
-val notoSansFile = coreBuildDir.file("fonts/NotoSans.ttf")
-val notoMonoFile = coreBuildDir.file("fonts/NotoSansMono.ttf")
-
-// Which Material Symbols style(s) this app uses = which style call sites appear
-// in its Kotlin sources. `MaterialSymbolsOutlined(...)` → outlined font,
-// `MaterialSymbolsRounded(...)` → rounded, `MaterialSymbolsSharp(...)` → sharp.
-// The Zip task below downloads + bundles ONLY the fonts a style actually
-// referenced — an app that only ever calls MaterialSymbolsOutlined never pays
-// for Rounded/Sharp .ttf bytes (each is ~600KB uncompressed).
-val kAllStyles = listOf(
-    "Outlined" to Regex("\\bMaterialSymbolsOutlined\\b"),
-    "Rounded"  to Regex("\\bMaterialSymbolsRounded\\b"),
-    "Sharp"    to Regex("\\bMaterialSymbolsSharp\\b"),
+compose.desktop.native {
+    entryPoint = "apidemo.main"
+    icon {
+        light.from(
+            layout.projectDirectory.file("icons/voltic-icon-32.png"),
+            layout.projectDirectory.file("icons/voltic-icon-128.png"),
         )
-fun detectUsedStyles(): List<String> {
-    val vSrcRoot = layout.projectDirectory.dir("src").asFile
-    val vUsed = mutableSetOf<String>()
-    if (!vSrcRoot.exists()) return emptyList()
-    vSrcRoot.walk().filter { it.isFile && it.extension == "kt" }.forEach { vFile ->
-        val vText = vFile.readText()
-        for ((vStyle, vRegex) in kAllStyles) {
-            if (vStyle !in vUsed && vRegex.containsMatchIn(vText)) vUsed.add(vStyle)
-        }
-    }
-    return vUsed.toList()
-}
-val vUsedStyles: List<String> = detectUsedStyles()
-
-// ==================
-// MARK: Material Symbols subsetting (-PsubsetIcons=true)
-// ==================
-// scripts/subset-material-symbols.py scans this module's Kotlin sources for
-// MaterialSymbols.<Name> references and writes build/icons/usage-codepoint.txt.
-// When -PsubsetIcons=true is passed, each icon-font module's downloaded TTF
-// is hb-subset'd against that file and the Zip below bundles the trimmed
-// font instead of the full one — typically 80-95% smaller.
-//
-// Needs: python3 + hb-subset on PATH (brew install harfbuzz /
-// apt install harfbuzz-utils).
-val subsetIcons = (findProperty("subsetIcons") as? String)?.toBoolean() ?: false
-val iconsBuildDir = layout.buildDirectory.dir("icons")
-
-val findMaterialSymbolsUsage = tasks.register<Exec>("findMaterialSymbolsUsage") {
-    description = "Scan src/ for MaterialSymbols.<Name> usages → usage-codepoint.txt."
-    val vScript = rootProject.layout.projectDirectory.file("scripts/subset-material-symbols.py").asFile
-    val vConstants = rootProject.project(":material-symbols").layout.projectDirectory
-        .file("src/commonMain/kotlin/com/compose/sdl/icons/MaterialSymbols.kt").asFile
-    val vUsageFile = iconsBuildDir.get().file("usage-codepoint.txt").asFile
-    inputs.files(fileTree("src") { include("**/*.kt") })
-    inputs.file(vConstants)
-    outputs.file(vUsageFile)
-    commandLine(
-        "python3", vScript.absolutePath,
-        "--src", layout.projectDirectory.dir("src").asFile.absolutePath,
-        "--constants", vConstants.absolutePath,
-        "--out", vUsageFile.absolutePath,
+        dark.from(
+            layout.projectDirectory.file("icons/voltic-icon-dark-32.png"),
+            layout.projectDirectory.file("icons/voltic-icon-dark-128.png"),
         )
+        exeIcon.from(
+            listOf(16, 32, 48, 64, 128, 256).map {
+                layout.projectDirectory.file("icons/voltic-icon-$it.png")
             }
-
-/* Register `subsetMaterialSymbols<Style>` for a style — hb-subsets the style's
-   downloaded TTF (owned by :material-symbols) to only the codepoints in
-   usage-codepoint.txt and writes the output under this app's build/icons/ dir. */
-fun registerSubsetTask(inStyle: String): TaskProvider<*> {
-    val vSymbolsProject = rootProject.project(":material-symbols")
-    return tasks.register("subsetMaterialSymbols$inStyle") {
-        description = "hb-subset the $inStyle Material Symbols font to icons actually used."
-        @Suppress("UNCHECKED_CAST")
-        val vInputProvider = vSymbolsProject.extra["iconFontFile$inStyle"] as org.gradle.api.provider.Provider<org.gradle.api.file.RegularFile>
-        val vDownloadTask = vSymbolsProject.extra["iconFontDownloadTask$inStyle"] as TaskProvider<*>
-        val vOut = iconsBuildDir.get().file("MaterialSymbols$inStyle.subset.ttf").asFile
-        val vUsage = iconsBuildDir.get().file("usage-codepoint.txt").asFile
-        inputs.file(vInputProvider)
-        inputs.file(vUsage)
-        outputs.file(vOut)
-        dependsOn(findMaterialSymbolsUsage)
-        dependsOn(vDownloadTask)
-        doLast {
-            val vCodepoints = vUsage.readLines()
-                .filter { it.isNotBlank() && !it.startsWith("#") && it.contains("=") }
-                .map { it.substringAfter("=").trim().removePrefix("0x").removePrefix("0X") }
-            if (vCodepoints.isEmpty()) throw GradleException(
-                "usage-codepoint.txt has no entries — refusing to subset to an empty font.")
-            val vUnicodes = vCodepoints.joinToString(",") { "U+$it" }
-            vOut.parentFile.mkdirs()
-            val vInputFile = vInputProvider.get().asFile
-            val vBefore = vInputFile.length()
-            // ProcessBuilder rather than project.exec — the latter isn't
-            // available inside doLast on Gradle 9 (only ExecOperations via
-            // an injected service is, which would mean a buildSrc plugin).
-            // hb-subset (HarfBuzz) is optional: if it isn't on PATH — common on
-            // Windows — bundle the full font instead of failing the build.
-            val vProc = try {
-                ProcessBuilder(
-                    "hb-subset",
-                    vInputFile.absolutePath,
-                    "-o", vOut.absolutePath,
-                    "--unicodes=$vUnicodes",
-                ).redirectErrorStream(true).start()
-            } catch (e: java.io.IOException) {
-                vInputFile.copyTo(vOut, overwrite = true)
-                logger.warn("[subset $inStyle] hb-subset not found on PATH — bundling the full font " +
-                    "(${vBefore / 1024}KB). Install harfbuzz to shrink it (brew install harfbuzz / " +
-                    "pacman -S mingw-w64-x86_64-harfbuzz / apt install harfbuzz-utils).")
-                return@doLast
-            }
-            val vOutput = vProc.inputStream.bufferedReader().readText()
-            val vCode = vProc.waitFor()
-            if (vCode != 0) throw GradleException("hb-subset failed (exit $vCode):\n$vOutput")
-            val vAfter = vOut.length()
-            val vPct = if (vBefore == 0L) 0 else ((100 - 100 * vAfter / vBefore)).coerceAtLeast(0)
-            logger.lifecycle("[subset $inStyle] ${vBefore / 1024}KB → ${vAfter / 1024}KB (-$vPct%) · ${vCodepoints.size} glyphs kept")
-        }
+        )
+        embedWindowsIcon = providers.gradleProperty("embedWindowsIcon").map { it.toBoolean() }
     }
 }
 
-// Pre-create subset tasks per USED style when enabled; the Zip below uses
-// them as the font source. Built outside the variant×target loop so each
-// style is subset once and reused across all bundle variants.
-val subsetTasksByStyle: Map<String, TaskProvider<*>> =
-    if (subsetIcons) vUsedStyles.associateWith { registerSubsetTask(it) } else emptyMap()
+// ==================
+// MARK: Fonts (shared pipeline - buildSrc ComposeFontBundling.kt)
+// ==================
 
-for (variant in variants) {
-    for (target in nativeTargets) {
-        val variantCap = variant.replaceFirstChar { it.uppercase() }
-        val targetCap = target.replaceFirstChar { it.uppercase() }
-        val outDir = layout.buildDirectory.dir("bin/$target/${variant}Executable")
-        val copyTask = tasks.register<Zip>("copy${variantCap}ComposeResources${targetCap}") {
-            archiveFileName.set("data.kres")
-            destinationDirectory.set(outDir)
-            entryCompression = if ((findProperty("compressResources") as? String)?.toBoolean() == true) org.gradle.api.tasks.bundling.ZipEntryCompression.DEFLATED else org.gradle.api.tasks.bundling.ZipEntryCompression.STORED
-            from(notoSansFile) { into("font") }
-            from(notoMonoFile) { into("font") }
-            dependsOn(":ui:downloadNotoFonts")
-            val vSymbolsProject = rootProject.project(":material-symbols")
-            for (vStyle in vUsedStyles) {
-                @Suppress("UNCHECKED_CAST")
-                val vFontFile = vSymbolsProject.extra["iconFontFile$vStyle"] as org.gradle.api.provider.Provider<org.gradle.api.file.RegularFile>
-                val vDownloadTask = vSymbolsProject.extra["iconFontDownloadTask$vStyle"] as TaskProvider<*>
-                val vSubsetTask = subsetTasksByStyle[vStyle]
-                if (vSubsetTask != null) {
-                    // Trimmed font: depend on the subset task and bundle its output
-                    // with the original filename so the runtime IconFont registration
-                    // doesn't need to know the bundle was subset.
-                    val vOriginalName = vFontFile.get().asFile.name
-                    from(vSubsetTask.get().outputs.files) {
-                        into("font")
-                        rename { vOriginalName }
-                    }
-                    dependsOn(vSubsetTask)
-                } else {
-                    from(vFontFile) { into("font") }
-                }
-                dependsOn(vDownloadTask)
-            }
-        }
-        listOf("link${variantCap}Executable${targetCap}", "run${variantCap}Executable${targetCap}").forEach { taskName ->
-            tasks.matching { it.name == taskName }.configureEach { dependsOn(copyTask) }
-        }
+registerComposeFontBundling {
+    bundleNotoSans = true
+    // The mono body font is loaded through the app's own seam (Fonts.kt), not via
+    // FontFamily.Monospace call sites - auto-detection can't see it, bundle explicitly.
+    bundleNotoSansMono = true
+    bundleMaterialSymbols = true
+    enableIconSubsetting = true
 }
+
+// Parity-window icon (cosmetic : the harness compares the canvas, not chrome).
+tasks.named<ProcessResources>("jvmProcessResources") {
+    from(layout.projectDirectory.file("icons/voltic-icon-256.png")) { into("icon") }
 }

apidemo/src/appleMain/kotlin/ClientCertApple.kt

@@ -2,15 +2,16 @@ package apidemo
 
 import kotlinx.cinterop.*
 import platform.CoreFoundation.*
-import platform.Foundation.*
+import platform.Foundation.CFBridgingRelease
+import platform.Foundation.NSString
 import platform.Security.*
 import kotlin.io.encoding.Base64
 import kotlin.io.encoding.ExperimentalEncodingApi
 
 // macOS: Ktor bundles an OpenSSL-backed libcurl, which reads PEM / DER / PKCS#12
-// certificate and key files directly — no certificate-store dance needed.
+// certificate and key files directly - no certificate-store dance needed.
 
-/* Point libcurl straight at the certificate / key files. */
+/** Point libcurl straight at the certificate / key files. */
 actual fun prepareClientCert(inReq: ApiRequest): PreparedCert =
     PreparedCert(
         sslCert = inReq.certPath,
@@ -21,11 +22,11 @@ actual fun prepareClientCert(inReq: ApiRequest): PreparedCert =
         cleanup = {},
     )
 
-/* No temporary certificate store off Windows. */
+/** No temporary certificate store off Windows. */
 actual fun sweepTempClientCerts() {}
 
-/* Continue the server's chain with intermediates / roots pulled from the
-   macOS Keychain — same UX as the Windows path does via the trust store.
+/** Continue the server's chain with intermediates / roots pulled from the
+macOS Keychain - same UX as the Windows path does via the trust store.
 Falls back to the name-only placeholder if Apple's APIs can't resolve
 the chain (e.g. the server's leaf doesn't parse, or its issuer isn't
 in any keychain). */
@@ -41,8 +42,8 @@ actual fun extendChain(inServerCerts: List<List<Pair<String, String>>>): List<Ch
 //  Chain walk via Security.framework
 // ============
 
-/* Build the chain by handing the leaf to SecTrust + evaluating against
-   an SSL policy — Apple then walks Keychain, pulling intermediates and
+/** Build the chain by handing the leaf to SecTrust + evaluating against
+an SSL policy - Apple then walks Keychain, pulling intermediates and
 the root in. Returns the resolved chain with fromServer=true for the
 first inServerCount entries (those came down on the wire) and false
 for anything the OS added. */
@@ -52,7 +53,7 @@ private fun osChainApple(
     inServerCount: Int,
     inServerCerts: List<List<Pair<String, String>>>,
 ): List<ChainCert> {
-	// Parse every cert the server presented, not just the leaf — Apple's
+    // Parse every cert the server presented, not just the leaf - Apple's
     // chain builder uses them as candidate intermediates when stitching to
     // a root, instead of relying solely on AIA-fetch which is off by default.
     val vServerCerts = inServerCerts.mapNotNull {
@@ -81,7 +82,7 @@ private fun osChainApple(
     }
     val vTrust = vTrustVar.value!!
 
-	// Evaluate even if it fails — we still want the partial chain back so
+    // Evaluate even if it fails - we still want the partial chain back so
     // the UI can show what it could resolve. SecTrustEvaluateWithError
     // stops at the highest cert it found.
     val vErr = nativeHeap.alloc<CFErrorRefVar>()
@@ -124,7 +125,7 @@ private fun osChainApple(
     return vResolved
 }
 
-/* SecCertificate from DER bytes. Returns null if the bytes aren't a
+/** SecCertificate from DER bytes. Returns null if the bytes aren't a
 valid X.509 cert. */
 @OptIn(ExperimentalForeignApi::class)
 private fun createSecCertificate(inDer: ByteArray): SecCertificateRef? {
@@ -136,7 +137,7 @@ private fun createSecCertificate(inDer: ByteArray): SecCertificateRef? {
     return vCert
 }
 
-/* CFArray of SecCertificateRef — the input to SecTrustCreateWithCertificates. */
+/** CFArray of SecCertificateRef - the input to SecTrustCreateWithCertificates. */
 @OptIn(ExperimentalForeignApi::class)
 private fun createCFArray(inCerts: List<SecCertificateRef>): CFArrayRef {
     val vPtrs = nativeHeap.allocArray<COpaquePointerVar>(inCerts.size)
@@ -146,7 +147,7 @@ private fun createCFArray(inCerts: List<SecCertificateRef>): CFArrayRef {
     return vArr
 }
 
-/* Apple's "subject summary" — basically the CN, but falls back to the
+/** Apple's "subject summary" - basically the CN, but falls back to the
 organisation when no CN is present (matches what Keychain Access
 displays in its cert list). */
 @OptIn(ExperimentalForeignApi::class)
@@ -156,7 +157,7 @@ private fun secSubjectSummary(inCert: SecCertificateRef): String? {
     return vNs?.toString()
 }
 
-/* PEM string for a SecCertificate — base64 of the DER bytes wrapped
+/** PEM string for a SecCertificate - base64 of the DER bytes wrapped
 with -----BEGIN CERTIFICATE-----/-----END----- headers. */
 @OptIn(ExperimentalForeignApi::class, ExperimentalEncodingApi::class)
 private fun secCertPem(inCert: SecCertificateRef): String? {
@@ -166,17 +167,17 @@ private fun secCertPem(inCert: SecCertificateRef): String? {
     val vPtr = CFDataGetBytePtr(vData)
     if (vPtr != null) for (vI in 0 until vLen) vBytes[vI] = vPtr[vI].toByte()
     CFRelease(vData)
-	val vB64 = Base64.Default.encode(vBytes)
+    val vB64 = Base64.encode(vBytes)
     val vWrapped = vB64.chunked(64).joinToString("\n")
     return "-----BEGIN CERTIFICATE-----\n$vWrapped\n-----END CERTIFICATE-----"
 }
 
-/* Decode a PEM block to DER bytes, or pass DER bytes through. */
+/** Decode a PEM block to DER bytes, or pass DER bytes through. */
 @OptIn(ExperimentalEncodingApi::class)
 private fun derFromPem(inPem: String): ByteArray? {
     if (!inPem.contains("-----BEGIN")) return inPem.encodeToByteArray()
     val vBody = inPem.lineSequence()
         .filterNot { it.startsWith("-----") }
         .joinToString("") { it.trim() }
-	return runCatching { Base64.Default.decode(vBody) }.getOrNull()
+    return runCatching { Base64.decode(vBody) }.getOrNull()
 }

apidemo/src/commonMain/kotlin/AppConstants.kt

@@ -6,17 +6,6 @@ import androidx.compose.ui.graphics.Color
 // MARK: App-wide constants + pure color / asset mappers
 // ==================
 
-// Amber used to flag undefined {{variables}} and unsaved-changes warnings.
-internal val kWarnColor = Color(0xFFFFAB00)
-
-// SDL scancodes used for app keyboard shortcuts.
-internal const val kScS = 22
-internal const val kScN = 17
-internal const val kScW = 26
-internal const val kScEnter = 40
-internal const val kScKpEnter = 88
-internal const val kScEscape = 41
-
 internal fun methodColor(inM: ReqMethod): Color = when (inM) {
     ReqMethod.GET -> Color(0xFF4C9AFF)
     ReqMethod.POST -> Color(0xFF36B37E)
@@ -35,11 +24,11 @@ internal val kPackColors: List<Long> = listOf(
     0xFFFF7043, 0xFF8D6E63, 0xFF78909C, 0xFFBDBDBD, 0xFF5C7CFA,
 )
 
-/* The palette colour for a 1-based pack-colour index, or null when unset. */
+/** The palette colour for a 1-based pack-colour index, or null when unset. */
 internal fun packColor(inIndex: Int): Color? =
     if (inIndex in 1..kPackColors.size) Color(kPackColors[inIndex - 1]) else null
 
-/* Default save name for an image response, by content type. */
+/** Default save name for an image response, by content type. */
 internal fun imageFileName(inContentType: String?): String = when {
     inContentType == null -> "image.bin"
     inContentType.contains("png", ignoreCase = true) -> "image.png"
@@ -51,9 +40,9 @@ internal fun imageFileName(inContentType: String?): String = when {
 }
 
 internal fun statusColor(inStatus: Int): Color = when (inStatus) {
-    in 200..299 -> Color(0xFF36B37E) // success — green
-    in 300..399 -> Color(0xFF4C9AFF) // redirect — blue
-    in 400..499 -> Color(0xFFFF991F) // client error — orange (warning)
-    in 500..599 -> Color(0xFFFF5630) // server error — red
-    else -> Color(0xFFFF991F)        // unknown / pending — orange
+    in 200..299 -> Color(0xFF36B37E) // success - green
+    in 300..399 -> Color(0xFF4C9AFF) // redirect - blue
+    in 400..499 -> Color(0xFFFF991F) // client error - orange (warning)
+    in 500..599 -> Color(0xFFFF5630) // server error - red
+    else -> Color(0xFFFF991F)        // unknown / pending - orange
 }

apidemo/src/commonMain/kotlin/AppState.kt

@@ -1,19 +1,21 @@
 package apidemo
 
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.mutableStateMapOf
-import androidx.compose.runtime.setValue
+import androidx.compose.runtime.*
 import kotlinx.coroutines.Job
 
 // ==================
 // MARK: Working state (session / pack / request / tabs / drag)
 // ==================
 
-internal class HistoryEntry(val method: ReqMethod, val url: String, val status: Int, val timeMs: Long, val request: ApiRequest)
+internal class HistoryEntry(
+    val method: ReqMethod,
+    val url: String,
+    val status: Int,
+    val timeMs: Long,
+    val request: ApiRequest
+)
 
-/* One request plus its live session state — response, in-flight job (for
+/** One request plus its live session state - response, in-flight job (for
 cancel) and which sub-tabs show. Stable identity lets the sidebar and the
 open-tab strip reference the same request without index juggling. */
 internal class ReqState(inInitial: ApiRequest) {
@@ -26,6 +28,7 @@ internal class ReqState(inInitial: ApiRequest) {
     var preview by mutableStateOf(false)  // panel 4 showing the resolved, not-yet-sent request
     var sentReq by mutableStateOf<ApiRequest?>(null)  // resolved request actually sent (Request tab)
     var imageKey: String? = null          // memory-resource key when the response is an image
+
     // null = auto-detect from Content-Type each frame; non-null = user-pinned override.
     var respFormatOverride by mutableStateOf<BodyFormat?>(null)
     var bodyWrap by mutableStateOf(true)  // body view: true = soft-wrap, false = no wrap + horizontal scroll
@@ -35,14 +38,21 @@ internal class ReqState(inInitial: ApiRequest) {
     var chainUrl by mutableStateOf("")               // resolved URL the chain was fetched from
 }
 
-/* One open pack: its file path (null = never saved), a dirty flag (edits since
+/** One open pack: its file path (null = never saved), a dirty flag (edits since
 last file save), and its own requests, variables and open-tab strip. Switching
 packs swaps the whole working set. */
-internal class PackState(inPack: Pack, inPath: String?, inDirty: Boolean, inOpenTabs: List<Int> = emptyList(), inActive: Int = -1) {
+internal class PackState(
+    inPack: Pack,
+    inPath: String?,
+    inDirty: Boolean,
+    inOpenTabs: List<Int> = emptyList(),
+    inActive: Int = -1
+) {
     var name by mutableStateOf(inPack.name)
     var path by mutableStateOf(inPath)
     var dirty by mutableStateOf(inDirty)
     var color by mutableStateOf(inPack.color)
+
     // A linked copy mirrors its source's requests read-only; non-linked packs own
     // their requests. `requests` resolves to whichever applies.
     var linkedSource by mutableStateOf<PackState?>(null)
@@ -52,54 +62,68 @@ internal class PackState(inPack: Pack, inPath: String?, inDirty: Boolean, inOpen
     val requests: androidx.compose.runtime.snapshots.SnapshotStateList<ReqState>
         get() = linkedSource?.requests ?: fOwnRequests
     val isLinked: Boolean get() = linkedSource != null
-    var parent: PackState? = null                                                  // enclosing pack (null = top-level / root)
+    var parent: PackState? =
+        null                                                  // enclosing pack (null = top-level / root)
     val subPacks = mutableStateListOf<PackState>().apply {
         inPack.subPacks.forEach { add(PackState(it, null, false).also { vSp -> vSp.parent = this@PackState }) }
     }
     val variables = mutableStateListOf<KeyVal>().apply { addAll(inPack.variables) }
     val headers = mutableStateListOf<KeyVal>().apply { addAll(inPack.headers) }   // pack-level, inherited by requests
-    val params = mutableStateListOf<KeyVal>().apply { addAll(inPack.params) }      // pack-level query params (inherited)
+    val params =
+        mutableStateListOf<KeyVal>().apply { addAll(inPack.params) }      // pack-level query params (inherited)
     var cert by mutableStateOf(inPack.cert)                                        // pack-level client cert (inherited)
-    val id: String = inPack.id.ifBlank { newPackId() }                            // stable id (linked copies reference it)
-    val isRoot: Boolean = inPack.isRoot                                            // the session-root "pack" (loose requests)
+    val id: String =
+        inPack.id.ifBlank { newPackId() }                            // stable id (linked copies reference it)
+    val isRoot: Boolean =
+        inPack.isRoot                                            // the session-root "pack" (loose requests)
+
     // No auto-open: tabs start empty and are restored from persisted state only.
     val openTabs = mutableStateListOf<ReqState>().apply {
         inOpenTabs.forEach { vIdx -> requests.getOrNull(vIdx)?.let { add(it) } }
     }
     var active by mutableStateOf(requests.getOrNull(inActive)?.takeIf { it in openTabs } ?: openTabs.firstOrNull())
-    var expanded by mutableStateOf(true)   // sidebar fold state (transient — not part of the pack file)
+    var expanded by mutableStateOf(true)   // sidebar fold state (transient - not part of the pack file)
     var envOpen by mutableStateOf(false)   // whether this pack's env tab is open in the strip (transient)
 
     fun toPack(): Pack = Pack(
         name = name,
         requests = if (isLinked) emptyList() else requests.map { it.req },   // linked: requests live in the source
-        variables = variables.toList(), color = color, headers = headers.toList(), params = params.toList(), cert = cert,
-        id = id, linkedTo = linkedSource?.id, isRoot = isRoot,
+        variables = variables.toList(),
+        color = color,
+        headers = headers.toList(),
+        params = params.toList(),
+        cert = cert,
+        id = id,
+        linkedTo = linkedSource?.id,
+        isRoot = isRoot,
         subPacks = subPacks.map { it.toPack() },
     )
 }
 
-/* A fresh random id for a pack (used to wire linked-copy packs to their source
+/** A fresh random id for a pack (used to wire linked-copy packs to their source
 across save / load). */
 internal fun newPackId(): String = "pk-" + kotlin.random.Random.nextLong().toULong().toString(16)
 
-/* One entry in the unified tab strip: a request tab, a pack's settings tab when
+/** One entry in the unified tab strip: a request tab, a pack's settings tab when
 req == null, or the session settings tab when isSession (pack == null). The
 underlying ReqState / PackState (or the session key) is the stable identity. */
 internal const val kSessionTabKey = "session-settings"
+
 internal class StripTab(val pack: PackState?, val req: ReqState?, val isSession: Boolean = false)
-/* Identity of a strip tab. A linked pack shares the source's ReqState objects,
-   so the key must include the pack — otherwise the source's and linked's tabs
+
+/** Identity of a strip tab. A linked pack shares the source's ReqState objects,
+so the key must include the pack - otherwise the source's and linked's tabs
 for the same request collide (double selection, duplicate key()). Data class →
 structural equality, so compare keys with == (not ===). */
 internal data class TabKey(val pack: PackState?, val req: ReqState?)
+
 internal val StripTab.tabKey: Any get() = if (isSession) kSessionTabKey else TabKey(pack, req)
 
 // ==================
 // MARK: Cross-pack drag (sidebar tree)
 // ==================
 
-/* Shared state for dragging within and across packs in the sidebar tree. One
+/** Shared state for dragging within and across packs in the sidebar tree. One
 instance is hoisted to App so any PackSection can be the drag source or the
 drop target. Two drag kinds: a request row (dragReq, owned by dragReqOwner) or
 a whole pack header (dragPack). Every rendered row / header registers its
@@ -113,7 +137,8 @@ internal class TreeDrag {
     var dragPack by mutableStateOf<PackState?>(null)
     var dy by mutableStateOf(0f)            // draw-only follow offset for the grabbed element
     var pressRel by mutableStateOf(0)       // relY at capture (cursor = grabbed-element top + relY)
-    // A press doesn't become a drag until the pointer moves past kDragSlop — so a
+
+    // A press doesn't become a drag until the pointer moves past kDragSlop - so a
     // plain click (which carries a pixel or two of jitter) still selects / opens.
     var engaged by mutableStateOf(false)
 

apidemo/src/commonMain/kotlin/CertParse.kt

@@ -0,0 +1,195 @@
+package apidemo
+
+import kotlin.io.encoding.Base64
+
+// ==================
+// MARK: Minimal X.509 / DER parser
+// ==================
+// Some TLS backends (notably Schannel on Windows) expose only Subject / Issuer /
+// the PEM through CURLINFO_CERTINFO - not the parsed fields (validity, serial,
+// SAN, algorithms). Since every backend gives us the PEM, we parse it ourselves
+// to fill in the detail. Just enough ASN.1 to walk a Certificate; anything odd
+// is swallowed and the field is simply omitted.
+
+/** Parsed certificate detail, all nullable/empty when not found or unparseable. */
+class CertDetails(
+    val version: Int?,                 // X.509 version (1/2/3)
+    val serial: String?,               // colon-separated hex
+    val sigAlg: String?,               // signature algorithm (friendly name or OID)
+    val keyAlg: String?,               // public-key algorithm (friendly name or OID)
+    val notBefore: String?,            // "YYYY-MM-DD HH:MM:SS UTC"
+    val notAfter: String?,
+    val sans: List<String>,            // dNSName SANs
+)
+
+// ============
+//  DER reader: each next() returns [tag, contentStart, contentEnd] and advances.
+private class DerReader(val b: ByteArray, var pos: Int, val end: Int) {
+    fun hasMore() = pos < end
+    fun next(): IntArray {
+        val vTag = b[pos++].toInt() and 0xFF
+        var vLen = b[pos++].toInt() and 0xFF
+        if (vLen and 0x80 != 0) {
+            val vN = vLen and 0x7F
+            vLen = 0
+            repeat(vN) { vLen = (vLen shl 8) or (b[pos++].toInt() and 0xFF) }
+        }
+        val vStart = pos
+        pos += vLen
+        return intArrayOf(vTag, vStart, vStart + vLen)
+    }
+}
+
+/** Parse the PEM into the fields the chain dialog shows. Returns null on any
+structural surprise (the UI just falls back to whatever the backend gave). */
+fun parseCertDetails(inPem: String): CertDetails? {
+    val vDer = pemToDer(inPem) ?: return null
+    return try {
+        val vCert = DerReader(vDer, 0, vDer.size).next()                 // Certificate SEQUENCE
+        val vCertInner = DerReader(vDer, vCert[1], vCert[2])
+        val vTbs = vCertInner.next()                                     // tbsCertificate
+        val vSigAlg = firstOidName(vDer, vCertInner.next())              // signatureAlgorithm
+
+        val vT = DerReader(vDer, vTbs[1], vTbs[2])
+        var vE = vT.next()
+        var vVersion: Int? = null
+        if (vE[0] == 0xA0)                                               // [0] EXPLICIT version
+        {
+            val vVi = DerReader(vDer, vE[1], vE[2]).next()
+            if (vVi[0] == 0x02 && vVi[2] > vVi[1]) vVersion = (vDer[vVi[1]].toInt() and 0xFF) + 1
+            vE = vT.next()
+        }
+        val vSerial = if (vE[0] == 0x02) bytesToHex(vDer, vE[1], vE[2]) else null
+        vT.next()                                                        // signature
+        vT.next()                                                        // issuer
+        val vValidity = vT.next()                                        // validity SEQUENCE
+        val vVr = DerReader(vDer, vValidity[1], vValidity[2])
+        val vNotBefore = parseAsn1Time(vDer, vVr.next())
+        val vNotAfter = parseAsn1Time(vDer, vVr.next())
+        vT.next()                                                        // subject
+        val vSpki = vT.next()                                            // subjectPublicKeyInfo SEQUENCE
+        // SPKI = SEQUENCE { algorithm AlgorithmIdentifier SEQUENCE { OID … }, key BIT STRING }
+        val vKeyAlg = firstOidName(vDer, DerReader(vDer, vSpki[1], vSpki[2]).next())
+        val vSans = ArrayList<String>()
+        while (vT.hasMore()) {
+            val vX = vT.next()
+            if (vX[0] == 0xA3) parseSans(vDer, vX, vSans)                // extensions [3]
+        }
+        CertDetails(vVersion, vSerial, vSigAlg, vKeyAlg, vNotBefore, vNotAfter, vSans)
+    } catch (_: Throwable) {
+        null
+    }
+}
+
+// ============
+//  Helpers
+
+private fun pemToDer(inPem: String): ByteArray? {
+    val vBody = inPem.lineSequence().filterNot { it.contains("-----") }.joinToString("") { it.trim() }
+    if (vBody.isBlank()) return null
+    return try {
+        Base64.decode(vBody)
+    } catch (_: Throwable) {
+        null
+    }
+}
+
+/** The friendly name (or dotted OID) of the first child OID of a SEQUENCE - used
+for signatureAlgorithm and subjectPublicKeyInfo's AlgorithmIdentifier. */
+private fun firstOidName(inB: ByteArray, inSeq: IntArray): String? {
+    val vR = DerReader(inB, inSeq[1], inSeq[2])
+    val vOid = vR.next()
+    if (vOid[0] != 0x06) return null
+    return oidName(oidToString(inB, vOid[1], vOid[2]))
+}
+
+/** Pull dNSName entries out of the SubjectAltName extension under [3]. */
+private fun parseSans(inB: ByteArray, inExt3: IntArray, inOut: MutableList<String>) {
+    val vSeq = DerReader(inB, inExt3[1], inExt3[2]).next()               // SEQUENCE OF Extension
+    val vEs = DerReader(inB, vSeq[1], vSeq[2])
+    while (vEs.hasMore()) {
+        val vExtn = vEs.next()
+        val vEr = DerReader(inB, vExtn[1], vExtn[2])
+        val vOid = vEr.next()                                           // extnID
+        // SAN OID 2.5.29.17 == bytes 55 1D 11
+        val vIsSan = vOid[2] - vOid[1] == 3 &&
+                (inB[vOid[1]].toInt() and 0xFF) == 0x55 &&
+                (inB[vOid[1] + 1].toInt() and 0xFF) == 0x1D &&
+                (inB[vOid[1] + 2].toInt() and 0xFF) == 0x11
+        var vVal = vEr.next()
+        if (vVal[0] == 0x01) vVal = vEr.next()                          // skip critical BOOLEAN
+        if (vIsSan && vVal[0] == 0x04)                                  // OCTET STRING wrapping GeneralNames
+        {
+            val vGnSeq = DerReader(inB, vVal[1], vVal[2]).next()
+            val vGn = DerReader(inB, vGnSeq[1], vGnSeq[2])
+            while (vGn.hasMore()) {
+                val vName = vGn.next()
+                if (vName[0] == 0x82) inOut.add(inB.copyOfRange(vName[1], vName[2]).decodeToString())  // [2] dNSName
+            }
+        }
+    }
+}
+
+/** ASN.1 UTCTime (YYMMDD…) / GeneralizedTime (YYYYMMDD…) → readable UTC string. */
+private fun parseAsn1Time(inB: ByteArray, inTlv: IntArray): String? {
+    val vS = inB.copyOfRange(inTlv[1], inTlv[2]).decodeToString()
+    return try {
+        val vYear: String
+        val vRest: String
+        if (inTlv[0] == 0x18)                                           // GeneralizedTime
+        {
+            vYear = vS.substring(0, 4); vRest = vS.substring(4)
+        } else                                                            // UTCTime - RFC 5280 pivot at 50
+        {
+            val vYy = vS.substring(0, 2).toInt()
+            vYear = (if (vYy >= 50) "19" else "20") + vS.substring(0, 2)
+            vRest = vS.substring(2)
+        }
+        val vMo = vRest.substring(0, 2)
+        val vDa = vRest.substring(2, 4)
+        val vHh = vRest.substring(4, 6)
+        val vMi = vRest.substring(6, 8)
+        val vSs = if (vRest.length >= 10 && vRest[8].isDigit()) vRest.substring(8, 10) else "00"
+        "$vYear-$vMo-$vDa $vHh:$vMi:$vSs UTC"
+    } catch (_: Throwable) {
+        vS
+    }
+}
+
+/** Colon-separated hex of a byte range (serial number rendering). */
+private fun bytesToHex(inB: ByteArray, inFrom: Int, inTo: Int): String =
+    (inFrom until inTo).joinToString(":") { (inB[it].toInt() and 0xFF).toString(16).padStart(2, '0') }
+
+/** Decode an OID's content bytes to dotted-decimal. */
+private fun oidToString(inB: ByteArray, inFrom: Int, inTo: Int): String {
+    if (inTo <= inFrom) return ""
+    val vSb = StringBuilder()
+    val vFirst = inB[inFrom].toInt() and 0xFF
+    vSb.append(vFirst / 40).append('.').append(vFirst % 40)
+    var vAcc = 0L
+    for (vI in (inFrom + 1) until inTo) {
+        val vByte = inB[vI].toInt() and 0xFF
+        vAcc = (vAcc shl 7) or (vByte and 0x7F).toLong()
+        if (vByte and 0x80 == 0) {
+            vSb.append('.').append(vAcc); vAcc = 0
+        }
+    }
+    return vSb.toString()
+}
+
+/** Friendly name for the common signature / public-key OIDs, else the OID. */
+private fun oidName(inOid: String): String = when (inOid) {
+    "1.2.840.113549.1.1.1" -> "RSA"
+    "1.2.840.113549.1.1.5" -> "SHA1withRSA"
+    "1.2.840.113549.1.1.11" -> "SHA256withRSA"
+    "1.2.840.113549.1.1.12" -> "SHA384withRSA"
+    "1.2.840.113549.1.1.13" -> "SHA512withRSA"
+    "1.2.840.113549.1.1.10" -> "RSASSA-PSS"
+    "1.2.840.10045.2.1" -> "EC"
+    "1.2.840.10045.4.3.2" -> "ECDSAwithSHA256"
+    "1.2.840.10045.4.3.3" -> "ECDSAwithSHA384"
+    "1.2.840.10045.4.3.4" -> "ECDSAwithSHA512"
+    "1.3.101.112" -> "Ed25519"
+    "1.3.101.113" -> "Ed448"
+    else -> inOid
+}

apidemo/src/commonMain/kotlin/Fonts.kt

@@ -0,0 +1,68 @@
+package apidemo
+
+import androidx.compose.material3.Typography
+import androidx.compose.ui.text.font.FontFamily
+
+// ==================
+// MARK: Monospace body font (seam)
+// ==================
+// Family name the body editor passes for monospace text. Resolves to the
+// bundled Noto Sans Mono once registered; null means the font isn't shipped
+// (data.kres on native, classpath font/ on jvm), in which case the body falls
+// back to the default proportional font.
+const val kMonoFamily = "noto-mono"
+
+/** Family name the bundled proportional font registers under. */
+const val kDefaultFamily = "noto-sans"
+
+/** The raw family name string - used by wrappedRowCount, which measures via the
+platform text pipeline (accepts a name string). Null when not bundled. */
+expect val monoFontFamilyName: String?
+
+/** The material3 Text / BasicTextField-shaped FontFamily for the mono family.
+Null when not bundled. */
+expect val monoFontFamily: FontFamily?
+
+// ==================
+// MARK: Default proportional font (seam)
+// ==================
+// PARITY: the native side resolves FontFamily.Default to the BUNDLED NotoSans
+// (SkiaFonts.defaultTypeface is the fallback for every unresolved family), while
+// stock Compose Desktop on the JVM resolves it to a SYSTEM font (Segoe UI on
+// Windows, Helvetica on macOS). Different typefaces mean different ascent /
+// descent / line-gap, so identical layout code puts glyphs at a different height
+// inside an identically-sized text box - which is what made the SourceTag pill
+// look vertically centred on JVM and off-centre on native.
+//
+// The two stacks must rasterise the SAME face for the comparison to mean
+// anything, so the app pins its default family explicitly rather than inheriting
+// whatever the platform picks. Null = the bundled font isn't available, in which
+// case we fall back to the platform default and the skew returns.
+
+/** The bundled proportional font, applied app-wide as the default text family.
+Null when NotoSans isn't shipped (data.kres on native, classpath font/ on jvm). */
+expect val defaultFontFamily: FontFamily?
+
+/** Re-stamps every style in a Material 3 [Typography] with [inFamily]. M3 seeds
+LocalTextStyle from the typography, so this reaches every `Text` that doesn't name
+a family of its own. A null family leaves the typography untouched. */
+fun Typography.withDefaultFontFamily(inFamily: FontFamily?): Typography {
+    if (inFamily == null) return this
+    return copy(
+        displayLarge = displayLarge.copy(fontFamily = inFamily),
+        displayMedium = displayMedium.copy(fontFamily = inFamily),
+        displaySmall = displaySmall.copy(fontFamily = inFamily),
+        headlineLarge = headlineLarge.copy(fontFamily = inFamily),
+        headlineMedium = headlineMedium.copy(fontFamily = inFamily),
+        headlineSmall = headlineSmall.copy(fontFamily = inFamily),
+        titleLarge = titleLarge.copy(fontFamily = inFamily),
+        titleMedium = titleMedium.copy(fontFamily = inFamily),
+        titleSmall = titleSmall.copy(fontFamily = inFamily),
+        bodyLarge = bodyLarge.copy(fontFamily = inFamily),
+        bodyMedium = bodyMedium.copy(fontFamily = inFamily),
+        bodySmall = bodySmall.copy(fontFamily = inFamily),
+        labelLarge = labelLarge.copy(fontFamily = inFamily),
+        labelMedium = labelMedium.copy(fontFamily = inFamily),
+        labelSmall = labelSmall.copy(fontFamily = inFamily),
+    )
+}

apidemo/src/commonMain/kotlin/Format.kt

@@ -25,13 +25,14 @@ fun formatBody(inText: String, inFormat: BodyFormat): String =
         BodyFormat.JSON -> runCatching {
             fPrettyJson.encodeToString(JsonElement.serializer(), fPrettyJson.parseToJsonElement(inText))
         }.getOrDefault(inText)
+
         BodyFormat.XML -> runCatching { formatXml(inText) }.getOrDefault(inText)
         else -> inText
     }
 
 // Minimal XML re-indenter: a newline between adjacent tags, one tab per
 // nesting level (rendered at the editor's tab size). Declarations (<?…?>), comments / doctype (<!…>), self-closing tags and
-// single-line <a>text</a> elements don't change depth. Best-effort — content
+// single-line <a>text</a> elements don't change depth. Best-effort - content
 // with a literal '>' inside attributes or CDATA may not round-trip, hence the
 // runCatching guard at the call site.
 private fun formatXml(inText: String): String {

apidemo/src/commonMain/kotlin/Http.kt

@@ -1,29 +1,28 @@
 package apidemo
 
-import io.ktor.client.*
-import io.ktor.client.engine.curl.Curl
+import apidemo.compat.createApiHttpClient
+import apidemo.compat.systemFileSystem
 import io.ktor.client.request.*
 import io.ktor.client.statement.*
 import io.ktor.http.*
 import kotlinx.coroutines.CancellationException
 import okio.Buffer
-import okio.FileSystem
 import okio.GzipSource
 import okio.Path.Companion.toPath
 import okio.buffer
 import kotlin.time.TimeSource
 
 // ==================
-// MARK: HttpRunner — executes an ApiRequest through Ktor
+// MARK: HttpRunner - executes an ApiRequest through Ktor
 // ==================
 
-/* Holds one Ktor HttpClient for the app's lifetime. One engine on every desktop
-   target: Ktor's Curl engine (bundled libcurl — Schannel on Windows, OpenSSL on
+/** Holds one Ktor HttpClient for the app's lifetime. One engine on every desktop
+target: Ktor's Curl engine (bundled libcurl - Schannel on Windows, OpenSSL on
 macOS/Linux). Same TLS stack as the client-cert path in CurlMtls.kt.
-   run() is a suspend fun — call it off the UI dispatcher. */
+run() is a suspend fun - call it off the UI dispatcher. */
 class HttpRunner {
 
-    private val fClient = HttpClient(Curl)
+    private val fClient = createApiHttpClient()
 
     init {
         // Clear any temporary client certs a prior crash left in the Windows
@@ -33,7 +32,7 @@ class HttpRunner {
 
     suspend fun run(inReq: ApiRequest): ApiResponse {
         // Client-certificate requests bypass Ktor (no engine exposes a cert API)
-        // and go straight through libcurl — same bundled TLS stack.
+        // and go straight through libcurl - same bundled TLS stack.
         if (inReq.hasClientCert) return curlSendWithClientCert(inReq)
         val vMark = TimeSource.Monotonic.markNow()
         return try {
@@ -45,7 +44,7 @@ class HttpRunner {
                 inReq.headers
                     .filter { it.enabled && it.key.isNotBlank() }
                     .forEach { header(it.key, it.value) }
-                if (inReq.method.allowsBody && inReq.bodyType != BodyType.NONE) {
+                if (inReq.bodyType != BodyType.NONE) {
                     // Content-Type comes from the body type / text format, unless the
                     // request already carries an explicit Content-Type header.
                     val vCt = inReq.bodyContentType()
@@ -73,7 +72,6 @@ class HttpRunner {
             // so show a short note instead and let the user Save the raw bytes.
             val vBinary = !vIsImage && isBinaryBody(vContentType, vBody)
             ApiResponse(
-                ok = true,
                 status = vResp.status.value,
                 statusText = vResp.status.description,
                 timeMs = vMark.elapsedNow().inWholeMilliseconds,
@@ -83,7 +81,7 @@ class HttpRunner {
                     .sortedBy { it.first.lowercase() },
                 body = when {
                     vIsImage -> ""
-                    vBinary -> "(${vContentType ?: "binary"} · ${vBody.size} bytes — not shown; use Save as…)"
+                    vBinary -> "(${vContentType ?: "binary"} · ${vBody.size} bytes - not shown; use Save as…)"
                     else -> vBody.decodeToString()
                 },
                 bytes = vBody,
@@ -99,14 +97,13 @@ class HttpRunner {
                 httpVersion = vResp.version.toString(),
             )
         } catch (e: CancellationException) {
-            // The caller cancelled (Cancel button) — let it propagate so the
+            // The caller cancelled (Cancel button) - let it propagate so the
             // request is dropped rather than reported as a failed response.
             throw e
         } catch (e: Throwable) {
             ApiResponse(
-                ok = false,
                 status = 0,
-                statusText = "—",
+                statusText = "-",
                 timeMs = vMark.elapsedNow().inWholeMilliseconds,
                 sizeBytes = 0,
                 headers = emptyList(),
@@ -119,7 +116,7 @@ class HttpRunner {
     fun close() = fClient.close()
 }
 
-/* Heuristic for a non-text body: textual content types (text, json, xml, html,
+/** Heuristic for a non-text body: textual content types (text, json, xml, html,
 javascript, csv, form) are shown as text; everything else, or bytes with
 embedded NULs, is treated as binary. */
 internal fun isBinaryBody(inContentType: String?, inBytes: ByteArray): Boolean {
@@ -132,17 +129,17 @@ internal fun isBinaryBody(inContentType: String?, inBytes: ByteArray): Boolean {
     return inBytes.take(1024).any { it.toInt() == 0 }       // no type: sniff for NUL bytes
 }
 
-/* True when the bytes are gzip — either the response says so or they carry the
+/** True when the bytes are gzip - either the response says so or they carry the
 gzip magic number (1f 8b). */
 private fun isGzip(inEncoding: String?, inBytes: ByteArray): Boolean =
     inEncoding?.contains("gzip", ignoreCase = true) == true ||
             (inBytes.size >= 2 && inBytes[0] == 0x1f.toByte() && inBytes[1] == 0x8b.toByte())
 
-/* Read a file's raw bytes (used for a FILE request body). */
+/** Read a file's raw bytes (used for a FILE request body). */
 internal fun readFileBytes(inPath: String): ByteArray =
-    FileSystem.SYSTEM.read(inPath.trim().toPath()) { readByteArray() }
+    systemFileSystem.read(inPath.trim().toPath()) { readByteArray() }
 
-/* Inflate a gzip stream to its original bytes via okio's GzipSource. */
+/** Inflate a gzip stream to its original bytes via okio's GzipSource. */
 private fun gunzip(inBytes: ByteArray): ByteArray {
     val vGz = GzipSource(Buffer().write(inBytes)).buffer()
     val vResult = vGz.readByteArray()

apidemo/src/commonMain/kotlin/InheritanceUi.kt

@@ -1,5 +1,3 @@
-@file:OptIn(androidx.compose.material3.ExperimentalMaterial3Api::class)
-
 package apidemo
 
 import androidx.compose.foundation.background
@@ -21,10 +19,10 @@ import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
 // MARK: Headers tab (inherited read-only + own editable)
 // ==================
 
-/* A request tab pairing an inherited (read-only, source-tagged) list with the
+/** A request tab pairing an inherited (read-only, source-tagged) list with the
 request's own editable list: Override copies an inherited entry down, and own
 rows that shadow an inherited one get an OverrideMark. Used by Query / Var /
-   Headers — the only differences are the key case-sensitivity and the labels. */
+Headers - the only differences are the key case-sensitivity and the labels. */
 @Composable
 internal fun InheritedEditableTab(
     inInherited: List<InheritedKv>,
@@ -40,8 +38,10 @@ internal fun InheritedEditableTab(
     fun norm(inKey: String) = if (inCaseInsensitive) inKey.lowercase() else inKey
     val vOwnKeys = inOwn.filter { it.key.isNotBlank() }.map { norm(it.key) }.toSet()
     Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-        InheritedKvSection(inInheritedTitle, inInherited, vOwnKeys, inCaseInsensitive,
-            inOnOverride = if (inReadOnly) null else inOnOverride)
+        InheritedKvSection(
+            inInheritedTitle, inInherited, vOwnKeys, inCaseInsensitive,
+            inOnOverride = if (inReadOnly) null else inOnOverride
+        )
         if (inInherited.any { it.kv.key.isNotBlank() }) {
             HorizontalDivider(color = c.border)
             Text(inOwnTitle, color = c.dim, fontSize = 11.sp)
@@ -52,26 +52,52 @@ internal fun InheritedEditableTab(
     }
 }
 
-/* Request Headers tab: inherited headers (case-insensitive) + the request's own. */
+/** Request Headers tab: inherited headers (case-insensitive) + the request's own. */
 @Composable
-internal fun HeadersTab(inReq: ApiRequest, inInherited: List<InheritedKv>, inReadOnly: Boolean, inEdit: (((ApiRequest) -> ApiRequest)) -> Unit) =
-    InheritedEditableTab(inInherited, inReq.headers, inCaseInsensitive = true, inReadOnly = inReadOnly, inOwnTitle = "Request headers",
+internal fun HeadersTab(
+    inReq: ApiRequest,
+    inInherited: List<InheritedKv>,
+    inReadOnly: Boolean,
+    inEdit: (((ApiRequest) -> ApiRequest)) -> Unit
+) =
+    InheritedEditableTab(
+        inInherited, inReq.headers, inCaseInsensitive = true, inReadOnly = inReadOnly, inOwnTitle = "Request headers",
         inOnOverride = { vKv -> inEdit { it.copy(headers = it.headers + vKv) } },
         inOnChange = { v -> inEdit { it.copy(headers = v) } })
 
-/* Request Query tab: inherited query params (case-sensitive) + the request's own. */
+/** Request Query tab: inherited query params (case-sensitive) + the request's own. */
 @Composable
-internal fun QueryTab(inReq: ApiRequest, inInherited: List<InheritedKv>, inReadOnly: Boolean, inEdit: (((ApiRequest) -> ApiRequest)) -> Unit) =
-    InheritedEditableTab(inInherited, inReq.params, inCaseInsensitive = false, inReadOnly = inReadOnly, inOwnTitle = "Request query params",
+internal fun QueryTab(
+    inReq: ApiRequest,
+    inInherited: List<InheritedKv>,
+    inReadOnly: Boolean,
+    inEdit: (((ApiRequest) -> ApiRequest)) -> Unit
+) =
+    InheritedEditableTab(
+        inInherited,
+        inReq.params,
+        inCaseInsensitive = false,
+        inReadOnly = inReadOnly,
+        inOwnTitle = "Request query params",
         inOnOverride = { vKv -> inEdit { it.copy(params = it.params + vKv) } },
         inOnChange = { v -> inEdit { it.copy(params = v) } })
 
-/* Request Var tab: inherited variables (case-sensitive {{name}}) + the request's
+/** Request Var tab: inherited variables (case-sensitive {{name}}) + the request's
 own. A request's own variable overrides the same name inherited from a pack /
 the session when the request is sent. */
 @Composable
-internal fun VarTab(inReq: ApiRequest, inInherited: List<InheritedKv>, inReadOnly: Boolean, inEdit: (((ApiRequest) -> ApiRequest)) -> Unit) =
-    InheritedEditableTab(inInherited, inReq.variables, inCaseInsensitive = false, inReadOnly = inReadOnly, inOwnTitle = "Request variables",
+internal fun VarTab(
+    inReq: ApiRequest,
+    inInherited: List<InheritedKv>,
+    inReadOnly: Boolean,
+    inEdit: (((ApiRequest) -> ApiRequest)) -> Unit
+) =
+    InheritedEditableTab(
+        inInherited,
+        inReq.variables,
+        inCaseInsensitive = false,
+        inReadOnly = inReadOnly,
+        inOwnTitle = "Request variables",
         inOnOverride = { vKv -> inEdit { it.copy(variables = it.variables + vKv) } },
         inOnChange = { v -> inEdit { it.copy(variables = v) } })
 
@@ -79,14 +105,18 @@ internal fun VarTab(inReq: ApiRequest, inInherited: List<InheritedKv>, inReadOnl
 // MARK: Inheritance UI (source tags / override markers / inherited lists)
 // ==================
 
-/* A small pill naming the kind of scope an inherited value comes from ("Session"
+/** A small pill naming the kind of scope an inherited value comes from ("Session"
 / "Pack"); hover shows the full path (e.g. "Methods / Nested"). The path tooltip
 is skipped when it would just repeat the label (the session). */
 @Composable
 internal fun SourceTag(inLabel: String, inPath: String) {
     val c = LocalAppColors.current
     val vPill = @Composable {
-        Box(modifier = Modifier.clip(RoundedCornerShape(4.dp)).background(c.accent.copy(alpha = 0.16f), RoundedCornerShape(4.dp)).padding(horizontal = 5.dp, vertical = 1.dp)) {
+        Box(
+            modifier = Modifier.clip(RoundedCornerShape(4.dp))
+                .background(c.accent.copy(alpha = 0.16f), RoundedCornerShape(4.dp))
+                .padding(horizontal = 5.dp, vertical = 1.dp)
+        ) {
             Text(inLabel, color = c.accent, fontSize = 9.sp)
         }
     }
@@ -101,7 +131,7 @@ internal fun SourceTag(inLabel: String, inPath: String) {
     }
 }
 
-/* The tiny marker shown on an own value that shadows an inherited one — hover for
+/** The tiny marker shown on an own value that shadows an inherited one - hover for
 "Overrides <key> from <path>". */
 @Composable
 internal fun OverrideMark(inKey: String, inPath: String) {
@@ -120,7 +150,7 @@ internal fun OverrideMark(inKey: String, inPath: String) {
     }
 }
 
-/* Read-only list of inherited key/values, each tagged with its source. When not
+/** Read-only list of inherited key/values, each tagged with its source. When not
 already overridden in this scope (own key absent) and inOnOverride != null, a
 row offers a one-click Override that copies it into this scope's own list. */
 @Composable
@@ -139,15 +169,26 @@ internal fun InheritedKvSection(
         vShown.forEach { vIt ->
             val vKey = if (inCaseInsensitive) vIt.kv.key.lowercase() else vIt.kv.key
             val vOverridden = vKey in inOwnKeys
-            Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
                 SourceTag(vIt.source, vIt.path)
                 Text(vIt.kv.key, color = c.dim, fontSize = 12.sp, modifier = Modifier.weight(0.42f))
-                Text(vIt.kv.value, color = c.dim.copy(alpha = if (vOverridden) 0.4f else 1f), fontSize = 12.sp, modifier = Modifier.weight(0.58f))
+                Text(
+                    vIt.kv.value,
+                    color = c.dim.copy(alpha = if (vOverridden) 0.4f else 1f),
+                    fontSize = 12.sp,
+                    modifier = Modifier.weight(0.58f)
+                )
                 when {
                     vOverridden -> Text("overridden", color = c.dim.copy(alpha = 0.6f), fontSize = 10.sp)
                     inOnOverride != null -> Box(
-                        modifier = Modifier.clip(RoundedCornerShape(6.dp)).border(1.dp, c.border, RoundedCornerShape(6.dp))
-                            .clickable { inOnOverride(KeyVal(vIt.kv.key, vIt.kv.value)) }.padding(horizontal = 8.dp, vertical = 3.dp),
+                        modifier = Modifier.clip(RoundedCornerShape(6.dp))
+                            .border(1.dp, c.border, RoundedCornerShape(6.dp))
+                            .clickable { inOnOverride(KeyVal(vIt.kv.key, vIt.kv.value)) }
+                            .padding(horizontal = 8.dp, vertical = 3.dp),
                     ) { Text("Override", color = c.accent, fontSize = 11.sp) }
                 }
             }
@@ -159,11 +200,15 @@ internal fun InheritedKvSection(
 // MARK: Key/value editor
 // ==================
 
-/* inOverrideInfo maps an own row to the source label it shadows (or null) so the
+/** inOverrideInfo maps an own row to the source label it shadows (or null) so the
 editor can flag overriding rows with an OverrideMark. It sits before inOnChange
 so existing trailing-lambda calls (KeyValEditor(rows) { … }) still bind to onChange. */
 @Composable
-internal fun KeyValEditor(inRows: List<KeyVal>, inOverrideInfo: (KeyVal) -> String? = { null }, inOnChange: (List<KeyVal>) -> Unit) {
+internal fun KeyValEditor(
+    inRows: List<KeyVal>,
+    inOverrideInfo: (KeyVal) -> String? = { null },
+    inOnChange: (List<KeyVal>) -> Unit
+) {
     val c = LocalAppColors.current
     val vAnyOverride = inRows.any { inOverrideInfo(it) != null }
     Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
@@ -188,15 +233,33 @@ internal fun KeyValEditor(inRows: List<KeyVal>, inOverrideInfo: (KeyVal) -> Stri
                     Checkbox(
                         checked = vKv.enabled,
                         onCheckedChange = null,
-                        colors = CheckboxDefaults.colors(checkedColor = c.accent, uncheckedColor = c.dim, checkmarkColor = c.onAccent),
+                        colors = CheckboxDefaults.colors(
+                            checkedColor = c.accent,
+                            uncheckedColor = c.dim,
+                            checkmarkColor = c.onAccent
+                        ),
                     )
                 }
                 if (vAnyOverride) Box(modifier = Modifier.width(18.dp), contentAlignment = Alignment.Center) {
                     inOverrideInfo(vKv)?.let { vSrc -> OverrideMark(vKv.key, vSrc) }
                 }
-                ThinField(vKv.key, { v -> inOnChange(inRows.mapIndexed { vJ, vR -> if (vJ == vI) vR.copy(key = v) else vR }) }, inModifier = Modifier.weight(1f), inPlaceholder = "key")
-                ThinField(vKv.value, { v -> inOnChange(inRows.mapIndexed { vJ, vR -> if (vJ == vI) vR.copy(value = v) else vR }) }, inModifier = Modifier.weight(1.4f), inPlaceholder = "value")
-                IconBtn(MaterialSymbols.Close, "Remove", inSize = 16.dp) { inOnChange(inRows.filterIndexed { vJ, _ -> vJ != vI }) }
+                ThinField(
+                    vKv.key,
+                    { v -> inOnChange(inRows.mapIndexed { vJ, vR -> if (vJ == vI) vR.copy(key = v) else vR }) },
+                    inModifier = Modifier.weight(1f),
+                    inPlaceholder = "key"
+                )
+                ThinField(
+                    vKv.value,
+                    { v -> inOnChange(inRows.mapIndexed { vJ, vR -> if (vJ == vI) vR.copy(value = v) else vR }) },
+                    inModifier = Modifier.weight(1.4f),
+                    inPlaceholder = "value"
+                )
+                IconBtn(
+                    MaterialSymbols.Close,
+                    "Remove",
+                    inSize = 16.dp
+                ) { inOnChange(inRows.filterIndexed { vJ, _ -> vJ != vI }) }
             }
         }
         OutlinedAction(MaterialSymbols.Add, "Add row") { inOnChange(inRows + KeyVal()) }

apidemo/src/commonMain/kotlin/MenuRow.kt

@@ -10,7 +10,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
 
-/* Icon + label row used inside nearly every DropdownMenuItem. */
+/** Icon + label row used inside nearly every DropdownMenuItem. */
 @Composable
 internal fun MenuRow(inIcon: Int, inLabel: String, inColor: Color? = null) {
     val c = LocalAppColors.current

apidemo/src/commonMain/kotlin/Model.kt

@@ -0,0 +1,325 @@
+package apidemo
+
+import kotlinx.serialization.Serializable
+
+// ==================
+// MARK: Pack model (serialized to / from .json)
+// ==================
+
+/** A "pack" is a savable collection of requests plus its environment variables
+- the export/import unit. Variables are referenced as {{name}} in any URL,
+query value, header or body and substituted just before the request is sent
+(see resolveVars in Tools.kt). Packs may be empty; the rich starter set lives
+in defaultSession(). */
+@Serializable
+data class Pack(
+    val name: String = "My Pack",
+    val requests: List<ApiRequest> = emptyList(),
+    val variables: List<KeyVal> = emptyList(),
+    val color: Int = 0,   // 1-based index into the pack-colour palette; 0 = none
+    val headers: List<KeyVal> = emptyList(),   // pack-level headers, inherited by requests
+    val params: List<KeyVal> = emptyList(),    // pack-level query params, inherited by requests
+    val cert: CertConfig? = null,              // pack-level client cert, inherited by requests
+    val id: String = "",                       // stable id (used by linked-copy packs)
+    val linkedTo: String? = null,              // id of the source pack when this is a linked copy
+    val isRoot: Boolean = false,               // the hidden session-root "pack" holding loose requests
+    val subPacks: List<Pack> = emptyList(),    // nested packs (a pack tree)
+)
+
+/** A client-certificate (mutual TLS) configuration. Lives on a request today and
+- with the pack tree - on the session / packs too (inherited downward). Maps
+to libcurl's CURLOPT_SSLCERT / SSLCERTTYPE / SSLKEY / SSLKEYTYPE / KEYPASSWD. */
+@Serializable
+data class CertConfig(
+    val certPath: String = "",
+    val certFormat: CertFormat = CertFormat.PEM,
+    val keyPath: String = "",
+    val keyFormat: CertFormat = CertFormat.PEM,
+    val certPassword: String = "",
+)
+
+/** The starter SESSION loaded on first launch (and on demand from the session
+menu) - a guided tour of every feature against httpbin.org: the inheritance
+ladder (session → pack → sub-pack → request, for variables / query params /
+headers / client cert, innermost wins), loose root requests, a nested sub-pack,
+per-request overrides, a client-cert pack, and a linked-copy pack. Each /get or
+/anything endpoint echoes the args + headers it received, so the merged,
+inherited result is visible in the response. Loaded as an unsaved session. */
+fun defaultSession(): Session = Session(
+    activePack = 0,
+    // ── Session level - the base of every inheritance ladder ──
+    globalEnv = listOf(
+        KeyVal("baseUrl", "https://httpbin.org"),
+        KeyVal("token", "session-token-abc"),
+        KeyVal("user", "session-user"),
+        KeyVal("password", "passwd"),
+        KeyVal("apiVer", "v1"),                                       // overridden by Methods (v2) then Nested (v3)
+    ),
+    globalHeaders = listOf(KeyVal("X-Client", "compose-apidemo")),    // every request sends it (echoed by /headers)
+    globalParams = listOf(
+        KeyVal(
+            "trace",
+            "session"
+        )
+    ),                // every request gets ?trace=session (echoed in /get args)
+    // No session-level cert: it would route every request through mTLS and fail
+    // without a real cert file. Client certs are shown on the "Secure (mTLS)" pack.
+    // ── Loose requests at the session root (in no pack - inherit session only) ──
+    root = Pack(
+        isRoot = true, name = "", requests = listOf(
+            ApiRequest(name = "Ping (loose)", method = ReqMethod.GET, url = "{{baseUrl}}/get"),
+            ApiRequest(name = "Headers echo (loose)", method = ReqMethod.GET, url = "{{baseUrl}}/headers"),
+        )
+    ),
+    packs = listOf(
+        // ── Methods - pack header/param/var inherited by its requests, plus a
+        //    nested sub-pack and per-request overrides of each kind. ──
+        SavedPack(
+            pack = Pack(
+                name = "Methods", id = "pk-methods", color = 1,
+                headers = listOf(KeyVal("Accept", "application/json")),   // pack header, inherited by its requests
+                params = listOf(
+                    KeyVal(
+                        "source",
+                        "methods"
+                    )
+                ),             // pack query param, inherited (echoed in /get args)
+                variables = listOf(
+                    KeyVal(
+                        "apiVer",
+                        "v2"
+                    )
+                ),               // overrides the session's apiVer for this pack
+                requests = listOf(
+                    ApiRequest(
+                        name = "GET - echoes inherited", method = ReqMethod.GET, url = "{{baseUrl}}/get",
+                        params = listOf(KeyVal("q", "compose"))
+                    ),         // own q + inherited trace=session + source=methods
+                    ApiRequest(
+                        name = "GET - overrides query param", method = ReqMethod.GET, url = "{{baseUrl}}/get",
+                        params = listOf(KeyVal("trace", "request"))
+                    ),     // request's trace wins over the session's
+                    ApiRequest(
+                        name = "POST - overrides header",
+                        method = ReqMethod.POST,
+                        url = "{{baseUrl}}/post",
+                        headers = listOf(KeyVal("Accept", "text/plain")), // request's Accept wins over the pack's
+                        bodyType = BodyType.TEXT,
+                        bodyFormat = BodyFormat.JSON,
+                        body = "{\n  \"user\": \"{{user}}\",\n  \"api\": \"{{apiVer}}\"\n}"
+                    ),
+                    ApiRequest(
+                        name = "POST - overrides {{user}} var", method = ReqMethod.POST, url = "{{baseUrl}}/anything",
+                        variables = listOf(
+                            KeyVal(
+                                "user",
+                                "request-user"
+                            )
+                        ),   // request var beats session/pack - see body echo
+                        bodyType = BodyType.TEXT, bodyFormat = BodyFormat.JSON, body = "{ \"who\": \"{{user}}\" }"
+                    ),
+                    ApiRequest(
+                        name = "PUT - replace",
+                        method = ReqMethod.PUT,
+                        url = "{{baseUrl}}/put",
+                        bodyType = BodyType.TEXT,
+                        bodyFormat = BodyFormat.JSON,
+                        body = "{ \"id\": 1, \"name\": \"updated\" }"
+                    ),
+                    ApiRequest(name = "DELETE", method = ReqMethod.DELETE, url = "{{baseUrl}}/delete"),
+                    ApiRequest(
+                        name = "Anything echo", method = ReqMethod.POST, url = "{{baseUrl}}/anything",
+                        bodyType = BodyType.TEXT, bodyFormat = BodyFormat.JSON, body = "{ \"hello\": \"world\" }"
+                    ),
+                ),
+                // Nested sub-pack - inherits Session → Methods → here (apiVer becomes v3,
+                // plus its own X-Nested header; trace / source / Accept still flow down).
+                subPacks = listOf(
+                    Pack(
+                        name = "Nested", color = 4,
+                        variables = listOf(KeyVal("apiVer", "v3")),
+                        headers = listOf(KeyVal("X-Nested", "true")),
+                        requests = listOf(
+                            ApiRequest(
+                                name = "GET - deep inheritance",
+                                method = ReqMethod.GET,
+                                url = "{{baseUrl}}/anything/{{apiVer}}"
+                            ),
+                        )
+                    ),
+                )
+            )
+        ),
+        // ── Auth & status - uses the inherited {{token}} / {{user}} / {{password}} ──
+        SavedPack(
+            pack = Pack(
+                name = "Auth & status", color = 2, requests = listOf(
+                    ApiRequest(
+                        name = "Bearer auth", method = ReqMethod.GET, url = "{{baseUrl}}/bearer",
+                        headers = listOf(KeyVal("Authorization", "Bearer {{token}}"))
+                    ),
+                    ApiRequest(
+                        name = "Basic auth",
+                        method = ReqMethod.GET,
+                        url = "{{baseUrl}}/basic-auth/{{user}}/{{password}}"
+                    ),
+                    ApiRequest(name = "Status 200", method = ReqMethod.GET, url = "{{baseUrl}}/status/200"),
+                    ApiRequest(name = "Status 500", method = ReqMethod.GET, url = "{{baseUrl}}/status/500"),
+                    ApiRequest(name = "Redirect x3", method = ReqMethod.GET, url = "{{baseUrl}}/redirect/3"),
+                    ApiRequest(name = "Delay 3s (try Cancel)", method = ReqMethod.GET, url = "{{baseUrl}}/delay/3"),
+                )
+            )
+        ),
+        // ── Formats - response viewer (JSON / XML / HTML / image) ──
+        SavedPack(
+            pack = Pack(
+                name = "Formats", color = 3, requests = listOf(
+                    ApiRequest(name = "JSON", method = ReqMethod.GET, url = "{{baseUrl}}/json"),
+                    ApiRequest(name = "XML", method = ReqMethod.GET, url = "{{baseUrl}}/xml"),
+                    ApiRequest(name = "HTML", method = ReqMethod.GET, url = "{{baseUrl}}/html"),
+                    ApiRequest(name = "UTF-8 text", method = ReqMethod.GET, url = "{{baseUrl}}/encoding/utf8"),
+                    ApiRequest(name = "PNG image", method = ReqMethod.GET, url = "{{baseUrl}}/image/png"),
+                    ApiRequest(name = "SVG image", method = ReqMethod.GET, url = "{{baseUrl}}/image/svg"),
+                )
+            )
+        ),
+        // ── Secure (mTLS) - a PACK-LEVEL client cert, inherited by its requests.
+        //    Open a request's Cert tab to see the inherited cert (source pill +
+        //    Override). Set real cert paths to actually send; the example paths
+        //    won't load. The second request overrides with its own cert. ──
+        SavedPack(
+            pack = Pack(
+                name = "Secure (mTLS)", color = 5,
+                cert = CertConfig(
+                    certPath = "/path/to/client.p12",
+                    certFormat = CertFormat.PKCS12,
+                    certPassword = "changeit"
+                ),
+                requests = listOf(
+                    ApiRequest(name = "Inherits the pack cert", method = ReqMethod.GET, url = "{{baseUrl}}/get"),
+                    ApiRequest(
+                        name = "Overrides with own cert",
+                        method = ReqMethod.GET,
+                        url = "{{baseUrl}}/get",
+                        certPath = "/path/to/other-client.pem",
+                        certFormat = CertFormat.PEM,
+                        keyPath = "/path/to/other-key.pem"
+                    ),
+                )
+            )
+        ),
+        // ── Linked copy of "Methods": a read-only mirror of its requests, but with
+        //    its own baseUrl var → the same calls run against the httpbingo sibling.
+        //    Showcases linked packs + per-pack variable override. ──
+        SavedPack(
+            pack = Pack(
+                name = "Methods · httpbingo", color = 6, requests = emptyList(),
+                variables = listOf(KeyVal("baseUrl", "https://httpbingo.org")), linkedTo = "pk-methods"
+            )
+        ),
+    ),
+)
+
+@Serializable
+data class ApiRequest(
+    val name: String = "New request",
+    val method: ReqMethod = ReqMethod.GET,
+    val url: String = "https://",
+    val params: List<KeyVal> = emptyList(),
+    val variables: List<KeyVal> = emptyList(),   // request-level vars ({{name}}); override inherited ones
+    val headers: List<KeyVal> = emptyList(),
+    val bodyType: BodyType = BodyType.NONE,
+    val body: String = "",                       // TEXT content, or the file path when bodyType == FILE
+    val bodyFormat: BodyFormat = BodyFormat.RAW, // for a TEXT body: syntax-highlight type + sent Content-Type
+    val form: List<KeyVal> = emptyList(),        // key/value fields when bodyType == FORM
+    // Client certificate (mutual TLS). When certPath is set, the request is sent
+    // through the libcurl path (CurlMtls.kt) with these mapped to CURLOPT_SSLCERT
+    // / SSLCERTTYPE / SSLKEY / SSLKEYTYPE / KEYPASSWD. A PKCS#12 file bundles its
+    // own key, so keyPath is left blank for it.
+    val certPath: String = "",
+    val certFormat: CertFormat = CertFormat.PEM,
+    val keyPath: String = "",
+    val keyFormat: CertFormat = CertFormat.PEM,
+    val certPassword: String = "",
+)
+
+/** Whether this request carries a client certificate (and so is sent via the
+libcurl mTLS path rather than the default engine). */
+val ApiRequest.hasClientCert: Boolean
+    get() = certPath.isNotBlank()
+
+/** This request's cert fields as a CertConfig (certPath may be blank = none). */
+fun ApiRequest.certConfig(): CertConfig = CertConfig(certPath, certFormat, keyPath, keyFormat, certPassword)
+
+/** This request with its cert fields replaced by inCert's. */
+fun ApiRequest.withCert(inCert: CertConfig): ApiRequest =
+    copy(
+        certPath = inCert.certPath, certFormat = inCert.certFormat,
+        keyPath = inCert.keyPath, keyFormat = inCert.keyFormat, certPassword = inCert.certPassword
+    )
+
+/** True when this config actually selects a certificate. */
+val CertConfig.isSet: Boolean
+    get() = certPath.isNotBlank()
+
+/** Certificate / private-key encodings, mapped to libcurl's CURLOPT_SSLCERTTYPE
+/ CURLOPT_SSLKEYTYPE string values and to `curl --cert-type` / `--key-type`.
+Runtime support depends on the TLS backend: OpenSSL (macOS/Linux) handles all
+three; Schannel (Windows) effectively supports P12. */
+@Serializable
+enum class CertFormat(val curlName: String, val label: String) {
+    PEM("PEM", "PEM"),
+    DER("DER", "DER"),
+    PKCS12("P12", "PKCS#12"),
+}
+
+/** A toggleable key/value row, used for both query params and headers. */
+@Serializable
+data class KeyVal(val key: String = "", val value: String = "", val enabled: Boolean = true)
+
+@Serializable
+enum class ReqMethod { GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS }
+
+@Serializable
+enum class BodyType { NONE, TEXT, FORM, FILE }
+
+/** Title-case label for the body-type picker. */
+val BodyType.label: String
+    get() = when (this) {
+        BodyType.NONE -> "None"
+        BodyType.TEXT -> "Text"
+        BodyType.FORM -> "Form"
+        BodyType.FILE -> "File"
+    }
+
+/** The Content-Type the request body implies (null when there's no body). For a
+TEXT body it comes from the chosen format (Text→text/plain, JSON→application/
+json, …); FORM / FILE are fixed. Sent unless the request already sets one. */
+fun ApiRequest.bodyContentType(): String? = when (bodyType) {
+    BodyType.NONE -> null
+    BodyType.TEXT -> bodyFormat.contentType
+    BodyType.FORM -> "application/x-www-form-urlencoded"
+    BodyType.FILE -> "application/octet-stream"
+}
+
+// ==================
+// MARK: Response (runtime only - not part of a pack)
+// ==================
+
+class ApiResponse(
+    val status: Int,
+    val statusText: String,
+    val timeMs: Long,
+    val sizeBytes: Long,
+    val headers: List<Pair<String, String>>,
+    val body: String,
+    val bytes: ByteArray = ByteArray(0),
+    val contentType: String? = null,
+    val requestHeaders: List<Pair<String, String>> = emptyList(),  // headers actually sent
+    val httpVersion: String = "HTTP/1.1",  // from Ktor's response.version, e.g. "HTTP/1.1" or "HTTP/2"
+    val error: String? = null,
+)
+
+/** True when the response carries an image payload (rendered, not shown as text). */
+val ApiResponse.isImage: Boolean
+    get() = contentType?.startsWith("image/", ignoreCase = true) == true

apidemo/src/commonMain/kotlin/Packs.kt

@@ -1,8 +1,8 @@
 package apidemo
 
+import apidemo.compat.systemFileSystem
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement
-import okio.FileSystem
 import okio.Path.Companion.toPath
 
 // ==================
@@ -16,10 +16,10 @@ private val fJson = Json {
     encodeDefaults = true
 }
 
-/* Write the pack as pretty JSON to inPath. Returns null on success, else the
+/** Write the pack as pretty JSON to inPath. Returns null on success, else the
 error message. */
 fun exportPack(inPack: Pack, inPath: String): String? = try {
-    FileSystem.SYSTEM.write(inPath.trim().toPath()) {
+    systemFileSystem.write(inPath.trim().toPath()) {
         writeUtf8(fJson.encodeToString(inPack))
     }
     null
@@ -27,17 +27,17 @@ fun exportPack(inPack: Pack, inPath: String): String? = try {
     e.message ?: e.toString()
 }
 
-/* Read a pack back from inPath. */
+/** Read a pack back from inPath. */
 fun importPack(inPath: String): Result<Pack> = try {
-    val vText = FileSystem.SYSTEM.read(inPath.trim().toPath()) { readUtf8() }
+    val vText = systemFileSystem.read(inPath.trim().toPath()) { readUtf8() }
     Result.success(fJson.decodeFromString<Pack>(vText))
 } catch (e: Throwable) {
     Result.failure(e)
 }
 
-/* Write a whole self-contained session to inPath. Returns null on success. */
+/** Write a whole self-contained session to inPath. Returns null on success. */
 fun exportSession(inSession: Session, inPath: String): String? = try {
-    FileSystem.SYSTEM.write(inPath.trim().toPath()) {
+    systemFileSystem.write(inPath.trim().toPath()) {
         writeUtf8(fJson.encodeToString(inSession))
     }
     null
@@ -45,47 +45,47 @@ fun exportSession(inSession: Session, inPath: String): String? = try {
     e.message ?: e.toString()
 }
 
-/* Read a session back from inPath. */
+/** Read a session back from inPath. */
 fun importSession(inPath: String): Result<Session> = try {
-    val vText = FileSystem.SYSTEM.read(inPath.trim().toPath()) { readUtf8() }
+    val vText = systemFileSystem.read(inPath.trim().toPath()) { readUtf8() }
     Result.success(fJson.decodeFromString<Session>(vText))
 } catch (e: Throwable) {
     Result.failure(e)
 }
 
-/* Rename inPath to inNewName within the same directory (adding a .json
+/** Rename inPath to inNewName within the same directory (adding a .json
 extension when the new name has none), returning the new path on success. */
 fun renameFile(inPath: String, inNewName: String): Result<String> = try {
     val vSrc = inPath.trim().toPath()
     val vLeaf = inNewName.trim().let { if (it.contains('.')) it else "$it.json" }
     val vDst = vSrc.parent?.div(vLeaf) ?: vLeaf.toPath()
-    FileSystem.SYSTEM.atomicMove(vSrc, vDst)
+    systemFileSystem.atomicMove(vSrc, vDst)
     Result.success(vDst.toString())
 } catch (e: Throwable) {
     Result.failure(e)
 }
 
-/* Write arbitrary text (a response body / headers dump) to inPath. Returns null
+/** Write arbitrary text (a response body / headers dump) to inPath. Returns null
 on success, else the error message. */
 fun writeTextFile(inPath: String, inText: String): String? = try {
-    FileSystem.SYSTEM.write(inPath.trim().toPath()) { writeUtf8(inText) }
+    systemFileSystem.write(inPath.trim().toPath()) { writeUtf8(inText) }
     null
 } catch (e: Throwable) {
     e.message ?: e.toString()
 }
 
-/* Write raw bytes (a binary response body, e.g. an image) to inPath. */
+/** Write raw bytes (a binary response body, e.g. an image) to inPath. */
 fun writeBytesFile(inPath: String, inBytes: ByteArray): String? = try {
-    FileSystem.SYSTEM.write(inPath.trim().toPath()) { write(inBytes) }
+    systemFileSystem.write(inPath.trim().toPath()) { write(inBytes) }
     null
 } catch (e: Throwable) {
     e.message ?: e.toString()
 }
 
-/* Re-indent a JSON response for display; returns the input unchanged if it
+/** Re-indent a JSON response for display; returns the input unchanged if it
 isn't valid JSON (so plain-text / HTML responses still show). */
 fun prettyJsonOrRaw(inText: String): String = try {
     fJson.encodeToString(JsonElement.serializer(), fJson.parseToJsonElement(inText))
-} catch (e: Throwable) {
+} catch (_: Throwable) {
     inText
 }

apidemo/src/commonMain/kotlin/Persist.kt

@@ -1,17 +1,17 @@
 package apidemo
 
-import com.compose.sdl.appDataDir
-import com.compose.sdl.revealInFileManager
+import apidemo.compat.appDataDir
+import apidemo.compat.revealInFileManager
+import apidemo.compat.systemFileSystem
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
-import okio.FileSystem
 import okio.Path.Companion.toPath
 
 // ==================
 // MARK: Persisted app state
 // ==================
 
-/* Everything the app restores on relaunch: the theme, the global override env,
+/** Everything the app restores on relaunch: the theme, the global override env,
 every open pack (with its file path + dirty flag so unsaved work survives a
 quit) and which pack was active. `launched` flips to true after the very
 first run so the httpbin starter pack is only auto-loaded once. */
@@ -19,6 +19,7 @@ import okio.Path.Companion.toPath
 data class AppState(
     val launched: Boolean = false,
     val dark: Boolean = true,
+    val theme: String = "purple",                     // selected voltic palette id (VolticPalette.id)
     val globalEnv: List<KeyVal> = emptyList(),        // session-level variables (base of the inheritance ladder)
     val globalHeaders: List<KeyVal> = emptyList(),    // session-level headers (inherited by every request)
     val globalParams: List<KeyVal> = emptyList(),     // session-level query params (inherited by every request)
@@ -36,7 +37,7 @@ data class AppState(
     val activeReq: Int = -1,
 )
 
-/* A pack as stored in the app state: the pack content plus where it was last
+/** A pack as stored in the app state: the pack content plus where it was last
 saved (null = never saved to a file) and whether it has unsaved edits. */
 @Serializable
 data class SavedPack(
@@ -45,8 +46,8 @@ data class SavedPack(
     val pack: Pack = Pack(),
 )
 
-/* A whole session, the export/import unit for the working set: every open pack
-   (self-contained — full content embedded) plus the shared global env and which
+/** A whole session, the export/import unit for the working set: every open pack
+(self-contained - full content embedded) plus the shared global env and which
 pack was active. Only one session is open at a time. */
 @Serializable
 data class Session(
@@ -74,39 +75,39 @@ private const val kOrg = "ComposeDesktopNative"
 private const val kApp = "ApiManager"
 private const val kStateFile = "state.json"
 
-/* Absolute path to the state file in the per-user app-data dir (created on
+/** Absolute path to the state file in the per-user app-data dir (created on
 demand by SDL_GetPrefPath). Null if no writable dir is available. */
 private fun stateFilePath(): String? {
     val vDir = appDataDir(kOrg, kApp) ?: return null  // ends with a separator
     return vDir + kStateFile
 }
 
-/* Read the persisted app state, or a fresh (first-launch) AppState if there's
+/** Read the persisted app state, or a fresh (first-launch) AppState if there's
 nothing saved yet or it can't be read. */
 fun loadAppState(): AppState {
     val vPath = stateFilePath() ?: return AppState()
     return try {
-        val vText = FileSystem.SYSTEM.read(vPath.toPath()) { readUtf8() }
+        val vText = systemFileSystem.read(vPath.toPath()) { readUtf8() }
         fStateJson.decodeFromString<AppState>(vText)
-    } catch (e: Throwable) {
+    } catch (_: Throwable) {
         AppState()
     }
 }
 
-/* Write the app state. Best-effort — failures are swallowed (it's a cache of
+/** Write the app state. Best-effort - failures are swallowed (it's a cache of
 the session, not the user's exported .json packs). */
 fun saveAppState(inState: AppState) {
     val vPath = stateFilePath() ?: return
     try {
-        FileSystem.SYSTEM.write(vPath.toPath()) { writeUtf8(fStateJson.encodeToString(inState)) }
-    } catch (e: Throwable) {
-        // ignore — nothing the user can act on, and packs can still be exported
+        systemFileSystem.write(vPath.toPath()) { writeUtf8(fStateJson.encodeToString(inState)) }
+    } catch (_: Throwable) {
+        // ignore - nothing the user can act on, and packs can still be exported
     }
 }
 
-/* Open the per-user app-data folder where the state file lives in the OS file
+/** Open the per-user app-data folder where the state file lives in the OS file
 manager. Revealing the state file opens its containing folder, which SDL has
-   already created even when nothing's been saved yet. Fire-and-forget — the
+already created even when nothing's been saved yet. Fire-and-forget - the
 reveal launches off the main thread (see revealInFileManager). */
 fun openSettingsFolder() {
     val vPath = stateFilePath() ?: return

apidemo/src/commonMain/kotlin/RequestBar.kt

@@ -1,5 +1,3 @@
-@file:OptIn(androidx.compose.material3.ExperimentalMaterial3Api::class)
-
 package apidemo
 
 import androidx.compose.foundation.background
@@ -32,12 +30,18 @@ import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
 internal fun OptionsMenu(
     inDark: Boolean,
     inOnToggleTheme: () -> Unit,
+    inPalette: VolticPalette,
+    inOnPalette: (VolticPalette) -> Unit,
 ) {
     val c = LocalAppColors.current
     var vOpen by remember { mutableStateOf(false) }
     Box {
         IconBtn(MaterialSymbols.Settings, "Options") { vOpen = true }
-        DropdownMenu(expanded = vOpen, onDismissRequest = { vOpen = false }, modifier = Modifier.widthIn(min = 200.dp)) {
+        DropdownMenu(
+            expanded = vOpen,
+            onDismissRequest = { vOpen = false },
+            modifier = Modifier.widthIn(min = 200.dp)
+        ) {
             DropdownMenuItem(text = {
                 Text("Dark mode", color = if (inDark) c.accent else c.text, fontSize = 13.sp)
             }, onClick = { if (!inDark) inOnToggleTheme(); vOpen = false })
@@ -45,6 +49,32 @@ internal fun OptionsMenu(
                 Text("Light mode", color = if (!inDark) c.accent else c.text, fontSize = 13.sp)
             }, onClick = { if (inDark) inOnToggleTheme(); vOpen = false })
             HorizontalDivider(color = c.border)
+            // Palette picker - a swatch of each theme's primary + a check on the active one.
+            Box(modifier = Modifier.fillMaxWidth().padding(start = 16.dp, top = 6.dp, bottom = 2.dp)) {
+                Text("Theme", color = c.dim, fontSize = 11.sp)
+            }
+            VolticPalette.entries.forEach { vPal ->
+                val vSel = vPal == inPalette
+                DropdownMenuItem(text = {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    ) {
+                        Box(
+                            modifier = Modifier.size(12.dp).clip(RoundedCornerShape(3.dp))
+                                .background(vPal.scheme.light.primary)
+                        )
+                        Text(
+                            vPal.label,
+                            color = if (vSel) c.accent else c.text,
+                            fontSize = 13.sp,
+                            modifier = Modifier.weight(1f)
+                        )
+                        if (vSel) MaterialSymbolsOutlined(MaterialSymbols.Check, tint = c.accent, size = 16.dp)
+                    }
+                }, onClick = { inOnPalette(vPal); vOpen = false })
+            }
+            HorizontalDivider(color = c.border)
             DropdownMenuItem(text = {
                 MenuRow(MaterialSymbols.Folder, "Open settings folder")
             }, onClick = { vOpen = false; openSettingsFolder() })
@@ -56,7 +86,7 @@ internal fun OptionsMenu(
 // MARK: Method picker (dropdown)
 // ==================
 
-/* Panel 2 — one unified bar: a method dropdown (coloured label + unfold arrows),
+/** Panel 2 - one unified bar: a method dropdown (coloured label + unfold arrows),
 a borderless URL field that melts into the bar, and Send (or Cancel). */
 @Composable
 internal fun UrlBar(
@@ -96,10 +126,12 @@ internal fun UrlBar(
             }
         }
 
-        // Borderless URL field — no box, so it reads as part of the bar.
+        // Borderless URL field - no box, so it reads as part of the bar.
         Box(
             modifier = Modifier.weight(1f).alpha(if (inReadOnly) 0.55f else 1f).onKeyEvent { ev ->
-                if (ev.type == KeyEventType.KeyDown && (ev.key == Key.Enter || ev.key == Key.NumPadEnter)) { inOnSend(); true } else false
+                if (ev.type == KeyEventType.KeyDown && (ev.key == Key.Enter || ev.key == Key.NumPadEnter)) {
+                    inOnSend(); true
+                } else false
             },
         ) {
             if (inReq.url.isEmpty()) Text("https://example.com/path", color = c.dim, fontSize = 14.sp)
@@ -122,8 +154,8 @@ internal fun UrlBar(
         }
 
         // Inspect the server's TLS certificate chain (handshake-only probe).
-        // During the probe the lock glyph swaps to a spinner IN PLACE — same
-        // box, padding and size — so the bar doesn't shift.
+        // During the probe the lock glyph swaps to a spinner IN PLACE - same
+        // box, padding and size - so the bar doesn't shift.
         val vLockHoverSrc = remember { MutableInteractionSource() }
         val vLockHover by vLockHoverSrc.collectIsHoveredAsState()
         TooltipBox(
@@ -133,7 +165,10 @@ internal fun UrlBar(
         ) {
             Box(
                 modifier = Modifier.clip(RoundedCornerShape(6.dp))
-                    .background(if (vLockHover) c.accent.copy(alpha = 0.18f) else Color.Transparent, RoundedCornerShape(6.dp))
+                    .background(
+                        if (vLockHover) c.accent.copy(alpha = 0.18f) else Color.Transparent,
+                        RoundedCornerShape(6.dp)
+                    )
                     .hoverable(vLockHoverSrc)
                     .clickable(onClick = inOnInspectChain)
                     .padding(6.dp),
@@ -141,23 +176,28 @@ internal fun UrlBar(
                 if (inChainLoading) {
                     CircularProgressIndicator(modifier = Modifier.size(18.dp), color = c.accent, strokeWidth = 2.dp)
                 } else {
-                    MaterialSymbolsOutlined(MaterialSymbols.Lock, contentDescription = "Inspect TLS chain",
-                        tint = if (vLockHover) c.accent else c.dim, size = 18.dp)
+                    MaterialSymbolsOutlined(
+                        MaterialSymbols.Lock, contentDescription = "Inspect TLS chain",
+                        tint = if (vLockHover) c.accent else c.dim, size = 18.dp
+                    )
                 }
             }
         }
 
         // Send and Cancel are the same Material Button (same MinHeight + padding)
-        // so the bar never changes height when toggling — Cancel is just red.
+        // so the bar never changes height when toggling - Cancel is just red.
         if (inLoading) Button(
             onClick = inOnCancel,
-            colors = ButtonDefaults.buttonColors(containerColor = methodColor(ReqMethod.DELETE), contentColor = Color.White),
+            colors = ButtonDefaults.buttonColors(
+                containerColor = methodColor(ReqMethod.DELETE),
+                contentColor = Color.White
+            ),
         ) { BtnContent(MaterialSymbols.Stop, "Cancel", Color.White) }
         else Button(onClick = inOnSend) { BtnContent(MaterialSymbols.Send, "Send", c.onAccent) }
     }
 }
 
-/* Bottom-of-panel-3 dropdown choosing the body type (None/Text/Form/File). */
+/** Bottom-of-panel-3 dropdown choosing the body type (None/Text/Form/File). */
 @Composable
 internal fun BodyTypeMenu(inType: BodyType, inEnabled: Boolean, inOnPick: (BodyType) -> Unit) {
     val c = LocalAppColors.current

apidemo/src/commonMain/kotlin/RequestBuilderPanel.kt

@@ -1,5 +1,3 @@
-@file:OptIn(androidx.compose.material3.ExperimentalMaterial3Api::class)
-
 package apidemo
 
 import androidx.compose.foundation.*
@@ -17,16 +15,16 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
-import com.compose.sdl.TextLayoutConfig
+import apidemo.compat.editorTabWidth
+import apidemo.compat.showOpenFileDialog
 import com.compose.sdl.icons.MaterialSymbols
 import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
-import com.compose.sdl.showOpenFileDialog
 
 // ==================
-// MARK: Panel 3 — request builder (Query / Headers / Body)
+// MARK: Panel 3 - request builder (Query / Headers / Body)
 // ==================
 
-/* Tabs to edit query params, headers and the body, a Preview toggle top-right,
+/** Tabs to edit query params, headers and the body, a Preview toggle top-right,
 and a body-type dropdown pinned at the bottom. */
 @Composable
 internal fun RequestBuilder(
@@ -42,7 +40,7 @@ internal fun RequestBuilder(
     inEdit: ((ApiRequest) -> ApiRequest) -> Unit,
 ) {
     val c = LocalAppColors.current
-    val vBodySet = inReq.method.allowsBody && when (inReq.bodyType) {
+    val vBodySet = true && when (inReq.bodyType) {
         BodyType.NONE -> false
         BodyType.FORM -> inReq.form.any { it.enabled && it.key.isNotBlank() }
         else -> inReq.body.isNotBlank()
@@ -55,17 +53,17 @@ internal fun RequestBuilder(
                 horizontalArrangement = Arrangement.spacedBy(6.dp),
                 verticalAlignment = Alignment.CenterVertically,
             ) {
-                MaterialSymbolsOutlined(MaterialSymbols.Warning, tint = kWarnColor, size = 15.dp)
+                MaterialSymbolsOutlined(MaterialSymbols.Warning, tint = VolticTheme.extended.warning, size = 15.dp)
                 Text(
                     "Undefined: ${inUnresolved.joinToString(", ") { "{{$it}}" }}",
-                    color = kWarnColor,
+                    color = VolticTheme.extended.warning,
                     fontSize = 11.sp
                 )
             }
         }
 
         // Tabs, with the status message and a Preview toggle (icon only) on the
-        // same line — the toggle no longer needs its own row.
+        // same line - the toggle no longer needs its own row.
         Row(
             modifier = Modifier.fillMaxWidth().padding(start = 12.dp, end = 10.dp, top = 6.dp),
             verticalAlignment = Alignment.CenterVertically,
@@ -100,7 +98,7 @@ internal fun RequestBuilder(
         }
         HorizontalDivider(color = c.border)
 
-        // Tab content — scrolls, except a Text body which fills the whole panel
+        // Tab content - scrolls, except a Text body which fills the whole panel
         // (so it stays one editable surface you can click anywhere in). Greyed when
         // read-only (a linked-copy request).
         val vScroll = rememberScrollState()
@@ -119,7 +117,7 @@ internal fun RequestBuilder(
             }
         }
 
-        // Body-type selector — only on the Body tab, pinned at the bottom. For a
+        // Body-type selector - only on the Body tab, pinned at the bottom. For a
         // Text body the format/type picker sits beside it; that type drives both the
         // syntax colours and the sent Content-Type.
         if (inRs.reqTab == 3) {
@@ -147,7 +145,7 @@ internal fun RequestBuilder(
     }
 }
 
-/* The body editing area for the current body type (driven by the bottom menu). A
+/** The body editing area for the current body type (driven by the bottom menu). A
 Text body is highlighted per its chosen format (bodyFormat). */
 @Composable
 internal fun BodyContent(inReq: ApiRequest, inEdit: ((ApiRequest) -> ApiRequest) -> Unit) {
@@ -159,19 +157,20 @@ internal fun BodyContent(inReq: ApiRequest, inEdit: ((ApiRequest) -> ApiRequest)
             inOnChange = { v -> inEdit { it.copy(body = v) } },
             inFormat = inReq.bodyFormat,
         )
+
         BodyType.FORM -> KeyValEditor(inReq.form) { v -> inEdit { it.copy(form = v) } }
         BodyType.FILE -> FileBody(inReq) { v -> inEdit(v) }
     }
 }
 
-/* Magic-wand button that pretty-prints the current body in place (JSON /
+/** Magic-wand button that pretty-prints the current body in place (JSON /
 XML). Lives at the right end of the body type/format bar. */
 @Composable
 internal fun FormatButton(inOnClick: () -> Unit) {
     HoverIconBtn(MaterialSymbols.AutoFixHigh, "Format (pretty-print)", inOnClick)
 }
 
-/* Icon button with the toolbar's standard hover treatment — accent-tinted
+/** Icon button with the toolbar's standard hover treatment - accent-tinted
 background + accent icon on hover (matching the TLS chain button). inActive
 keeps it lit, for toggles such as the preview eye. */
 @Composable
@@ -204,14 +203,16 @@ internal fun HoverIconBtn(
                 .clickable(onClick = inOnClick)
                 .padding(6.dp),
         ) {
-            MaterialSymbolsOutlined(inIcon, contentDescription = inTooltip,
-                tint = if (inActive || vHover) c.accent else c.dim, size = inSize)
+            MaterialSymbolsOutlined(
+                inIcon, contentDescription = inTooltip,
+                tint = if (inActive || vHover) c.accent else c.dim, size = inSize
+            )
         }
     }
 }
 
-/* Tab-size picker (2 / 4 / 8), shown left of the format button. Sets the global
-   editor tab width via TextLayoutConfig — how wide a typed '\t' renders AND how
+/** Tab-size picker (2 / 4 / 8), shown left of the format button. Sets the global
+editor tab width via TextLayoutConfig - how wide a typed '\t' renders AND how
 deep the formatter indents. Snapshot-backed, so the change is live. */
 @Composable
 internal fun TabSizeSelector() {
@@ -219,7 +220,7 @@ internal fun TabSizeSelector() {
     var vOpen by remember { mutableStateOf(false) }
     val vHoverSrc = remember { MutableInteractionSource() }
     val vHover by vHoverSrc.collectIsHoveredAsState()
-    val vSize = TextLayoutConfig.tabWidth
+    val vSize = editorTabWidth
     TooltipBox(
         positionProvider = TooltipDefaults.rememberTooltipPositionProvider(TooltipAnchorPosition.Above),
         tooltip = { PlainTooltip { Text("Editor tab size") } },
@@ -229,7 +230,10 @@ internal fun TabSizeSelector() {
             Row(
                 modifier = Modifier
                     .clip(RoundedCornerShape(6.dp))
-                    .background(if (vHover) c.accent.copy(alpha = 0.18f) else Color.Transparent, RoundedCornerShape(6.dp))
+                    .background(
+                        if (vHover) c.accent.copy(alpha = 0.18f) else Color.Transparent,
+                        RoundedCornerShape(6.dp)
+                    )
                     .hoverable(vHoverSrc)
                     .clickable { vOpen = true }
                     .padding(horizontal = 8.dp, vertical = 5.dp),
@@ -237,20 +241,24 @@ internal fun TabSizeSelector() {
                 horizontalArrangement = Arrangement.spacedBy(3.dp),
             ) {
                 Text("Tab $vSize", color = if (vHover) c.accent else c.dim, fontSize = 12.sp)
-                MaterialSymbolsOutlined(MaterialSymbols.UnfoldMore, tint = if (vHover) c.accent else c.dim, size = 14.dp)
+                MaterialSymbolsOutlined(
+                    MaterialSymbols.UnfoldMore,
+                    tint = if (vHover) c.accent else c.dim,
+                    size = 14.dp
+                )
             }
             DropdownMenu(expanded = vOpen, onDismissRequest = { vOpen = false }) {
                 for (vN in listOf(2, 4, 8)) {
                     DropdownMenuItem(text = {
                         Text("$vN spaces", color = if (vN == vSize) c.accent else c.text)
-                    }, onClick = { TextLayoutConfig.tabWidth = vN; vOpen = false })
+                    }, onClick = { editorTabWidth = vN; vOpen = false })
                 }
             }
         }
     }
 }
 
-/* FILE body — pick a file; its path is stored in body and sent as raw bytes. */
+/** FILE body - pick a file; its path is stored in body and sent as raw bytes. */
 @Composable
 internal fun FileBody(inReq: ApiRequest, inEdit: ((ApiRequest) -> ApiRequest) -> Unit) {
     val c = LocalAppColors.current
@@ -263,12 +271,17 @@ internal fun FileBody(inReq: ApiRequest, inEdit: ((ApiRequest) -> ApiRequest) ->
     }
 }
 
-/* Client-certificate (mTLS) editor — certificate + optional separate key +
+/** Client-certificate (mTLS) editor - certificate + optional separate key +
 passphrase. PEM/DER are used directly by OpenSSL on macOS/Linux; on Windows
 they're imported into the certificate store for the request then removed
 (see CurlMtls). PKCS#12 bundles its own private key. */
 @Composable
-internal fun CertConfigEditor(inCert: CertConfig, inHeading: String = "Client certificate (mTLS)", inOverrideSource: String? = null, inOnChange: (CertConfig) -> Unit) {
+internal fun CertConfigEditor(
+    inCert: CertConfig,
+    inHeading: String = "Client certificate (mTLS)",
+    inOverrideSource: String? = null,
+    inOnChange: (CertConfig) -> Unit
+) {
     val c = LocalAppColors.current
     val vHasCert = inCert.certPath.isNotBlank()
     Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
@@ -293,7 +306,11 @@ internal fun CertConfigEditor(inCert: CertConfig, inHeading: String = "Client ce
                 inOnChange(CertConfig())
             }
         }
-        Text(if (vHasCert) inCert.certPath else "No certificate selected.", color = if (vHasCert) c.text else c.dim, fontSize = 12.sp)
+        Text(
+            if (vHasCert) inCert.certPath else "No certificate selected.",
+            color = if (vHasCert) c.text else c.dim,
+            fontSize = 12.sp
+        )
 
         // ============
         //  Private key (PKCS#12 carries its own key)
@@ -304,10 +321,17 @@ internal fun CertConfigEditor(inCert: CertConfig, inHeading: String = "Client ce
                     showOpenFileDialog { vPath -> if (vPath != null) inOnChange(inCert.copy(keyPath = vPath)) }
                 }
                 CertFormatMenu(inCert.keyFormat) { vF -> inOnChange(inCert.copy(keyFormat = vF)) }
-                if (inCert.keyPath.isNotBlank()) IconBtn(MaterialSymbols.Close, "Clear key") { inOnChange(inCert.copy(keyPath = "", keyFormat = CertFormat.PEM)) }
+                if (inCert.keyPath.isNotBlank()) IconBtn(MaterialSymbols.Close, "Clear key") {
+                    inOnChange(
+                        inCert.copy(
+                            keyPath = "",
+                            keyFormat = CertFormat.PEM
+                        )
+                    )
+                }
             }
             Text(
-                if (inCert.keyPath.isNotBlank()) inCert.keyPath else "Optional — only if the key is in a separate file.",
+                inCert.keyPath.ifBlank { "Optional - only if the key is in a separate file." },
                 color = if (inCert.keyPath.isNotBlank()) c.text else c.dim, fontSize = 12.sp,
             )
         }
@@ -315,17 +339,27 @@ internal fun CertConfigEditor(inCert: CertConfig, inHeading: String = "Client ce
         // ============
         //  Passphrase
         Text("Passphrase", color = c.dim, fontSize = 12.sp)
-        ThinField(inCert.certPassword, { v -> inOnChange(inCert.copy(certPassword = v)) }, inPlaceholder = "Key / PKCS#12 password (optional)")
+        ThinField(
+            inCert.certPassword,
+            { v -> inOnChange(inCert.copy(certPassword = v)) },
+            inPlaceholder = "Key / PKCS#12 password (optional)"
+        )
     }
 }
 
-/* A read-only card for an inherited client cert: its source pill + path, plus an
+/** A read-only card for an inherited client cert: its source pill + path, plus an
 Override action (copy it into this scope) when this scope hasn't set its own. */
 @Composable
-internal fun InheritedCertCard(inInherited: InheritedCert, inOwnSet: Boolean, inReadOnly: Boolean, inOnOverride: () -> Unit) {
+internal fun InheritedCertCard(
+    inInherited: InheritedCert,
+    inOwnSet: Boolean,
+    inReadOnly: Boolean,
+    inOnOverride: () -> Unit
+) {
     val c = LocalAppColors.current
     Column(
-        modifier = Modifier.fillMaxWidth().clip(RoundedCornerShape(8.dp)).border(1.dp, c.border, RoundedCornerShape(8.dp)).padding(10.dp),
+        modifier = Modifier.fillMaxWidth().clip(RoundedCornerShape(8.dp))
+            .border(1.dp, c.border, RoundedCornerShape(8.dp)).padding(10.dp),
         verticalArrangement = Arrangement.spacedBy(4.dp),
     ) {
         Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
@@ -343,20 +377,32 @@ internal fun InheritedCertCard(inInherited: InheritedCert, inOwnSet: Boolean, in
     }
 }
 
-/* The request's Cert tab: the inherited cert (from pack / session) shown read-only
+/** The request's Cert tab: the inherited cert (from pack / session) shown read-only
 with its source + an Override action when the request has none, then the
 request's own cert editor (its own cert overrides the inherited one). */
 @Composable
-internal fun RequestCertTab(inReq: ApiRequest, inInheritedCert: InheritedCert?, inReadOnly: Boolean, inEdit: (((ApiRequest) -> ApiRequest)) -> Unit) {
+internal fun RequestCertTab(
+    inReq: ApiRequest,
+    inInheritedCert: InheritedCert?,
+    inReadOnly: Boolean,
+    inEdit: (((ApiRequest) -> ApiRequest)) -> Unit
+) {
     Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
-        if (inInheritedCert != null) InheritedCertCard(inInheritedCert, inOwnSet = inReq.hasClientCert, inReadOnly = inReadOnly) {
+        if (inInheritedCert != null) InheritedCertCard(
+            inInheritedCert,
+            inOwnSet = inReq.hasClientCert,
+            inReadOnly = inReadOnly
+        ) {
             inEdit { it.withCert(inInheritedCert.cert) }
         }
-        CertConfigEditor(inReq.certConfig(), inOverrideSource = if (inReq.hasClientCert) inInheritedCert?.path else null) { vCc -> inEdit { it.withCert(vCc) } }
+        CertConfigEditor(
+            inReq.certConfig(),
+            inOverrideSource = if (inReq.hasClientCert) inInheritedCert?.path else null
+        ) { vCc -> inEdit { it.withCert(vCc) } }
     }
 }
 
-/* Scope settings editor (Variables / Query / Headers / Cert sub-tabs) — shared by
+/** Scope settings editor (Variables / Query / Headers / Cert sub-tabs) - shared by
 the session settings tab and each pack's settings tab. Each sub-tab shows what
 the scope inherits from above (source-tagged, with Override) over its own
 editable list, mirroring the request panels. */
@@ -369,7 +415,7 @@ internal fun ScopeSettings(
     inParams: List<KeyVal>, inOnParams: (List<KeyVal>) -> Unit, inParamHelp: String,
     inHeaders: List<KeyVal>, inOnHeaders: (List<KeyVal>) -> Unit, inHeaderHelp: String,
     inCert: CertConfig?, inOnCert: (CertConfig?) -> Unit, inCertHelp: String, inCertHeading: String,
-    // What this scope inherits from above (empty for the session — it's the top).
+    // What this scope inherits from above (empty for the session - it's the top).
     inInheritedVars: List<InheritedKv> = emptyList(),
     inInheritedParams: List<InheritedKv> = emptyList(),
     inInheritedHeaders: List<InheritedKv> = emptyList(),
@@ -390,33 +436,50 @@ internal fun ScopeSettings(
         when (inTab) {
             0 -> {
                 Text(inVarHelp, color = c.dim, fontSize = 12.sp)
-                InheritedEditableTab(inInheritedVars, inVars, inCaseInsensitive = false, inReadOnly = false,
+                InheritedEditableTab(
+                    inInheritedVars, inVars, inCaseInsensitive = false, inReadOnly = false,
                     inOwnTitle = "This scope's variables", inInheritedTitle = "Inherited variables",
-                    inOnOverride = { vKv -> inOnVars(inVars + vKv) }, inOnChange = inOnVars)
+                    inOnOverride = { vKv -> inOnVars(inVars + vKv) }, inOnChange = inOnVars
+                )
             }
+
             1 -> {
                 Text(inParamHelp, color = c.dim, fontSize = 12.sp)
-                InheritedEditableTab(inInheritedParams, inParams, inCaseInsensitive = false, inReadOnly = false,
+                InheritedEditableTab(
+                    inInheritedParams, inParams, inCaseInsensitive = false, inReadOnly = false,
                     inOwnTitle = "This scope's query params", inInheritedTitle = "Inherited query params",
-                    inOnOverride = { vKv -> inOnParams(inParams + vKv) }, inOnChange = inOnParams)
+                    inOnOverride = { vKv -> inOnParams(inParams + vKv) }, inOnChange = inOnParams
+                )
             }
+
             2 -> {
                 Text(inHeaderHelp, color = c.dim, fontSize = 12.sp)
-                InheritedEditableTab(inInheritedHeaders, inHeaders, inCaseInsensitive = true, inReadOnly = false,
+                InheritedEditableTab(
+                    inInheritedHeaders, inHeaders, inCaseInsensitive = true, inReadOnly = false,
                     inOwnTitle = "This scope's headers", inInheritedTitle = "Inherited headers",
-                    inOnOverride = { vKv -> inOnHeaders(inHeaders + vKv) }, inOnChange = inOnHeaders)
+                    inOnOverride = { vKv -> inOnHeaders(inHeaders + vKv) }, inOnChange = inOnHeaders
+                )
             }
+
             else -> {
                 Text(inCertHelp, color = c.dim, fontSize = 12.sp)
                 val vOwnSet = inCert?.isSet == true
-                if (inInheritedCert != null) InheritedCertCard(inInheritedCert, inOwnSet = vOwnSet, inReadOnly = false) { inOnCert(inInheritedCert.cert) }
-                CertConfigEditor(inCert ?: CertConfig(), inCertHeading, inOverrideSource = if (vOwnSet) inInheritedCert?.path else null) { vCc -> inOnCert(vCc.takeIf { it.isSet }) }
+                if (inInheritedCert != null) InheritedCertCard(
+                    inInheritedCert,
+                    inOwnSet = vOwnSet,
+                    inReadOnly = false
+                ) { inOnCert(inInheritedCert.cert) }
+                CertConfigEditor(
+                    inCert ?: CertConfig(),
+                    inCertHeading,
+                    inOverrideSource = if (vOwnSet) inInheritedCert?.path else null
+                ) { vCc -> inOnCert(vCc.takeIf { it.isSet }) }
             }
         }
     }
 }
 
-/* Certificate / key encoding dropdown (PEM / DER / PKCS#12). */
+/** Certificate / key encoding dropdown (PEM / DER / PKCS#12). */
 @Composable
 internal fun CertFormatMenu(inFormat: CertFormat, inOnPick: (CertFormat) -> Unit) {
     val c = LocalAppColors.current

apidemo/src/commonMain/kotlin/RequestTabStrip.kt

@@ -0,0 +1,295 @@
+@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class)
+
+package apidemo
+
+import androidx.compose.foundation.*
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.Text
+import androidx.compose.runtime.*
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.input.pointer.PointerButton
+import androidx.compose.ui.input.pointer.PointerEventType
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.zIndex
+import apidemo.compat.x
+import com.compose.sdl.icons.MaterialSymbols
+import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
+
+// ==================
+// MARK: Request tab strip (open requests; drag a tab to reorder)
+// ==================
+
+/** Strip of open requests above the editor. Each tab is clickable to select
+and drag-reorderable. While dragging, the grabbed tab lifts (zIndex),
+fades, and follows the cursor via a graphicsLayer translation - its
+neighbours don't shuffle; the reorder commits on drop, to the slot whose
+neighbours' centres the cursor passed. key(tab) keeps each tab's
+LayoutNode stable so the drag session survives the reorder. */
+@Composable
+internal fun RequestTabStrip(
+    inTabs: List<StripTab>,
+    inActiveKey: Any?,
+    inOnSelect: (StripTab) -> Unit,
+    inOnClose: (StripTab) -> Unit,
+    inOnCloseOthers: (StripTab) -> Unit,
+    inOnCloseAll: () -> Unit,
+    inOnReorder: (Int, Int) -> Unit,
+) {
+    val c = LocalAppColors.current
+    val vScroll = rememberScrollState()                     // strip's horizontal scroll
+    val vLeft = remember { mutableStateMapOf<Any, Int>() }   // window-x of each tab's left edge, by tab key
+    val vWidth = remember { mutableStateMapOf<Any, Int>() }  // measured tab width, by tab key
+    var vDragKey by remember { mutableStateOf<Any?>(null) }
+    var vPressRelX by remember { mutableStateOf(0) }
+    var vDragDx by remember { mutableStateOf(0f) }
+    var vDragTarget by remember { mutableStateOf(-1) }
+
+    // One shared context menu, anchored to the tab that opened it (m3 DropdownMenu
+    // is parent-anchored, not cursor-anchored - the old x/y capture is gone).
+    var vMenu by remember { mutableStateOf(false) }
+    var vMenuTab by remember { mutableStateOf<StripTab?>(null) }
+
+    var vListOpen by remember { mutableStateOf(false) }   // overflow list
+
+    val vShowBar = vDragKey != null && vDragDx != 0f
+    val vOthers = if (vShowBar) inTabs.filter { it.tabKey != vDragKey } else emptyList()
+    val vBarBeforeKey = if (vShowBar) vOthers.getOrNull(vDragTarget)?.tabKey else null
+    val vBarAtEnd = vShowBar && vDragTarget >= vOthers.size
+
+    Row(
+        modifier = Modifier.fillMaxWidth().background(c.panel),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Row(
+            modifier = Modifier.weight(1f)
+                .horizontalScroll(vScroll).padding(horizontal = 6.dp, vertical = 5.dp),
+            horizontalArrangement = Arrangement.spacedBy(4.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            inTabs.forEach { vTab ->
+                val vKey = vTab.tabKey
+                if (vKey == vBarBeforeKey) DropBar()
+                key(vKey) {
+                    val vSel = vKey == inActiveKey
+                    val vDragged = vKey == vDragKey
+
+                    var vMod = Modifier
+                        .onGloballyPositioned { vLeft[vKey] = it.x }
+                        .onSizeChanged { vWidth[vKey] = it.width }
+                    // NOTE: `alpha` and `translationX` MUST be on the same graphicsLayer.
+                    // `Modifier.alpha` expands to `graphicsLayer(alpha, clip = true)` - clip is
+                    // applied in the ALPHA layer's local coord space (before any child layer's
+                    // translation), so `.alpha().graphicsLayer(translationX = X)` clips the drag
+                    // ghost inside its original bounds and the ghost disappears as it slides. One
+                    // layer with both properties = clip stays false, alpha modulates via layerPaint.
+                    if (vDragged) vMod =
+                        vMod.zIndex(1f).graphicsLayer(alpha = 0.65f, translationX = vDragDx, translationY = 0f)
+                    vMod = vMod
+                        .clip(RoundedCornerShape(7.dp))
+                        .background(if (vSel) c.accent.copy(alpha = 0.20f) else c.field, RoundedCornerShape(7.dp))
+                        .border(1.dp, if (vSel || vDragged) c.accent else c.border, RoundedCornerShape(7.dp))
+                        .pointerInput(vKey) {
+                            // Accumulate the per-frame delta rather than reading change.position.
+                            // The tab wears a graphicsLayer(translationX = vDragDx) while dragging,
+                            // which transforms the modifier's local pointer frame - so position.x
+                            // would compensate for the translation each frame and the tab would
+                            // trail the mouse by roughly half its offset. dragAmount is the
+                            // root-frame delta and doesn't feed back through the layer transform.
+                            detectDragGestures(
+                                onDragStart = { offset ->
+                                    vDragKey = vKey
+                                    vPressRelX = offset.x.toInt()
+                                    vDragDx = 0f
+                                    vDragTarget = inTabs.indexOfFirst { it.tabKey == vKey }
+                                },
+                                onDrag = { _, dragAmount ->
+                                    val vd = vDragKey ?: return@detectDragGestures
+                                    vDragDx += dragAmount.x
+                                    val vRelX = vPressRelX + vDragDx.toInt()
+                                    val vCursorX = (vLeft[vd] ?: 0) + vRelX
+                                    var vCount = 0
+                                    inTabs.forEach { vT ->
+                                        if (vT.tabKey != vd) {
+                                            val vCenter = (vLeft[vT.tabKey] ?: 0) + (vWidth[vT.tabKey] ?: 0) / 2
+                                            if (vCursorX > vCenter) vCount++
+                                        }
+                                    }
+                                    vDragTarget = vCount
+                                },
+                                onDragEnd = {
+                                    val vd = vDragKey
+                                    if (vd != null) {
+                                        val vFrom = inTabs.indexOfFirst { it.tabKey == vd }
+                                        if (vFrom >= 0 && vDragTarget >= 0 && vDragTarget != vFrom) inOnReorder(
+                                            vFrom,
+                                            vDragTarget
+                                        )
+                                    }
+                                    vDragKey = null; vDragDx = 0f; vDragTarget = -1
+                                },
+                                onDragCancel = { vDragKey = null; vDragDx = 0f; vDragTarget = -1 },
+                            )
+                        }
+                        // Middle-click closes the tab; right-click opens the tab menu. Compose
+                        // has no first-class match for either - inline pointerInput checks the
+                        // pressed PointerButton at each Press.
+                        .pointerInput(vTab) {
+                            awaitPointerEventScope {
+                                while (true) {
+                                    val vEv = awaitPointerEvent()
+                                    if (vEv.type != PointerEventType.Press) continue
+                                    when (vEv.button) {
+                                        PointerButton.Tertiary -> {
+                                            vEv.changes.firstOrNull()?.consume()
+                                            inOnClose(vTab)
+                                        }
+
+                                        PointerButton.Secondary -> {
+                                            vEv.changes.firstOrNull()?.consume()
+                                            vMenuTab = vTab; vMenu = true
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        .clickable { inOnSelect(vTab) }
+                        .padding(start = 9.dp, top = 6.dp, bottom = 6.dp, end = 3.dp)
+
+                    Row(
+                        modifier = vMod,
+                        horizontalArrangement = Arrangement.spacedBy(6.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        val vRs = vTab.req
+                        if (vRs == null) {
+                            // Session / pack settings tab.
+                            MaterialSymbolsOutlined(
+                                MaterialSymbols.Tune,
+                                tint = if (vSel) c.accent else c.dim,
+                                size = 13.dp
+                            )
+                            Text(
+                                if (vTab.isSession) "Session" else (vTab.pack?.name ?: ""),
+                                color = if (vSel) c.text else c.dim,
+                                fontSize = 13.sp
+                            )
+                        } else {
+                            Box(
+                                modifier = Modifier.size(7.dp)
+                                    .background(methodColor(vRs.req.method), RoundedCornerShape(4.dp))
+                            )
+                            Text(vRs.req.name, color = if (vSel) c.text else c.dim, fontSize = 13.sp)
+                            if (vRs.loading) CircularProgressIndicator(
+                                modifier = Modifier.size(12.dp),
+                                color = c.accent,
+                                strokeWidth = 1.5.dp
+                            )
+                        }
+                        IconBtn(MaterialSymbols.Close, "Close", inSize = 13.dp) { inOnClose(vTab) }
+                    }
+                }
+            }
+            if (vBarAtEnd) DropBar()
+
+            // Shared right-click menu, opened at the cursor over the clicked tab.
+            val vMTab = vMenuTab
+            if (vMenu && vMTab != null) {
+                DropdownMenu(
+                    expanded = true,
+                    onDismissRequest = { vMenu = false },
+                    modifier = Modifier.widthIn(min = 188.dp),
+                ) {
+                    DropdownMenuItem(
+                        text = { MenuRow(MaterialSymbols.Close, "Close tab") },
+                        onClick = { vMenu = false; inOnClose(vMTab) })
+                    DropdownMenuItem(
+                        text = { MenuRow(MaterialSymbols.Clear, "Close other tabs") },
+                        onClick = { vMenu = false; inOnCloseOthers(vMTab) })
+                    DropdownMenuItem(
+                        text = { MenuRow(MaterialSymbols.Clear, "Close all tabs") },
+                        onClick = { vMenu = false; inOnCloseAll() })
+                }
+            }
+        }
+
+        // Overflow → chevron opens a scrollable list of every open tab.
+        if (vScroll.maxValue > 0) {
+            Box(modifier = Modifier.padding(end = 4.dp)) {
+                IconBtn(MaterialSymbols.ExpandMore, "All tabs") { vListOpen = true }
+                DropdownMenu(
+                    expanded = vListOpen,
+                    onDismissRequest = { vListOpen = false },
+                    modifier = Modifier.widthIn(min = 240.dp)
+                ) {
+                    Column(modifier = Modifier.heightIn(max = 320.dp).verticalScroll(rememberScrollState())) {
+                        inTabs.forEach { vTab ->
+                            DropdownMenuItem(text = {
+                                Row(
+                                    modifier = Modifier.fillMaxWidth(),
+                                    verticalAlignment = Alignment.CenterVertically,
+                                    horizontalArrangement = Arrangement.spacedBy(8.dp)
+                                ) {
+                                    val vSel = vTab.tabKey == inActiveKey
+                                    val vRs = vTab.req
+                                    if (vRs == null) {
+                                        MaterialSymbolsOutlined(
+                                            MaterialSymbols.Tune,
+                                            tint = if (vSel) c.accent else c.dim,
+                                            size = 13.dp
+                                        )
+                                        Text(
+                                            if (vTab.isSession) "Session" else "${vTab.pack?.name} · var",
+                                            color = if (vSel) c.accent else c.text,
+                                            fontSize = 13.sp,
+                                            modifier = Modifier.weight(1f)
+                                        )
+                                    } else {
+                                        Box(
+                                            modifier = Modifier.size(7.dp)
+                                                .background(methodColor(vRs.req.method), RoundedCornerShape(4.dp))
+                                        )
+                                        Text(
+                                            vRs.req.name,
+                                            color = if (vSel) c.accent else c.text,
+                                            fontSize = 13.sp,
+                                            modifier = Modifier.weight(1f)
+                                        )
+                                        if (vRs.loading) CircularProgressIndicator(
+                                            modifier = Modifier.size(12.dp),
+                                            color = c.accent,
+                                            strokeWidth = 1.5.dp
+                                        )
+                                    }
+                                }
+                            }, onClick = { vListOpen = false; inOnSelect(vTab) })
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/** Thin accent bar marking where a dragged tab will be inserted. Rendered in-flow
+between tabs so the Row centres it vertically and reserves a little space. */
+@Composable
+internal fun DropBar() {
+    val c = LocalAppColors.current
+    Box(
+        modifier = Modifier.width(3.dp).height(24.dp).clip(RoundedCornerShape(2.dp))
+            .background(c.accent, RoundedCornerShape(2.dp))
+    )
+}
+

apidemo/src/commonMain/kotlin/Sidebar.kt

@@ -1,5 +1,4 @@
 @file:OptIn(
-    androidx.compose.material3.ExperimentalMaterial3Api::class,
     androidx.compose.ui.ExperimentalComposeUiApi::class,
 )
 
@@ -31,17 +30,17 @@ import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.compose.ui.zIndex
-import com.compose.sdl.fileManagerName
+import apidemo.compat.fileManagerName
+import apidemo.compat.revealInFileManager
+import apidemo.compat.y
 import com.compose.sdl.icons.MaterialSymbols
 import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
-import com.compose.sdl.layout.y
-import com.compose.sdl.revealInFileManager
 
 // ==================
 // MARK: Pack colour (palette dot + picker)
 // ==================
 
-/* A small rounded square in the pack's palette colour (neutral when unset).
+/** A small rounded square in the pack's palette colour (neutral when unset).
 The pack's visual identity in the sidebar's foldable pack header. */
 @Composable
 internal fun ColorDot(inColor: Int, inSize: Dp = 11.dp) {
@@ -50,7 +49,7 @@ internal fun ColorDot(inColor: Int, inSize: Dp = 11.dp) {
     Box(Modifier.size(inSize).background(vCol, RoundedCornerShape(3.dp)))
 }
 
-/* A 5×4 grid of swatches; tapping one sets the pack's colour (1-based index).
+/** A 5×4 grid of swatches; tapping one sets the pack's colour (1-based index).
 The current colour gets a ring. Sized to fit inside the (fixed-width) ⋮ menu. */
 @Composable
 internal fun PackColorPicker(inSelected: Int, inOnPick: (Int) -> Unit) {
@@ -80,7 +79,7 @@ internal fun PackColorPicker(inSelected: Int, inOnPick: (Int) -> Unit) {
 // MARK: Add-pack menu (header '+')
 // ==================
 
-/* The header '+' — a small menu to add a pack to the open session, either blank
+/** The header '+' - a small menu to add a pack to the open session, either blank
 or imported from a .json file. Importing a pack always lands it in the session. */
 @Composable
 internal fun AddPackMenu(inOnNewRequest: () -> Unit, inOnNew: () -> Unit, inOnImport: () -> Unit) {
@@ -88,7 +87,11 @@ internal fun AddPackMenu(inOnNewRequest: () -> Unit, inOnNew: () -> Unit, inOnIm
     var vOpen by remember { mutableStateOf(false) }
     Box {
         IconBtn(MaterialSymbols.Add, "Add", inSize = 18.dp) { vOpen = true }
-        DropdownMenu(expanded = vOpen, onDismissRequest = { vOpen = false }, modifier = Modifier.widthIn(min = 200.dp)) {
+        DropdownMenu(
+            expanded = vOpen,
+            onDismissRequest = { vOpen = false },
+            modifier = Modifier.widthIn(min = 200.dp)
+        ) {
             DropdownMenuItem(text = {
                 MenuRow(
                     MaterialSymbols.Send,
@@ -96,7 +99,9 @@ internal fun AddPackMenu(inOnNewRequest: () -> Unit, inOnNew: () -> Unit, inOnIm
                 )
             }, onClick = { vOpen = false; inOnNewRequest() })
             HorizontalDivider(color = c.border)
-            DropdownMenuItem(text = { MenuRow(MaterialSymbols.Add, "New pack") }, onClick = { vOpen = false; inOnNew() })
+            DropdownMenuItem(
+                text = { MenuRow(MaterialSymbols.Add, "New pack") },
+                onClick = { vOpen = false; inOnNew() })
             DropdownMenuItem(text = {
                 MenuRow(
                     MaterialSymbols.Download,
@@ -111,11 +116,11 @@ internal fun AddPackMenu(inOnNewRequest: () -> Unit, inOnNew: () -> Unit, inOnIm
 // MARK: Session menu (save / open / new / recent)
 // ==================
 
-/* The last path segment of inPath (the file name), tolerant of either slash. */
+/** The last path segment of inPath (the file name), tolerant of either slash. */
 internal fun fileLeaf(inPath: String): String =
     inPath.trimEnd('/', '\\').substringAfterLast('/').substringAfterLast('\\')
 
-/* Shortens a long path to inMax chars keeping the start and end (so the root
+/** Shortens a long path to inMax chars keeping the start and end (so the root
 and file stay visible), joined by an ellipsis. The menu has no text-overflow
 primitive, so we trim the string ourselves. */
 internal fun ellipsizeMiddle(inText: String, inMax: Int = 46): String {
@@ -125,8 +130,8 @@ internal fun ellipsizeMiddle(inText: String, inMax: Int = 46): String {
     return inText.take(vHead) + "…" + inText.takeLast(vKeep - vHead)
 }
 
-/* Header dropdown for the one open session. Shows its file name with the full
-   path underneath when it has a file (so you can see it's saved — file-backed
+/** Header dropdown for the one open session. Shows its file name with the full
+path underneath when it has a file (so you can see it's saved - file-backed
 sessions auto-save), or "Untitled session" with a dot when it has no file yet.
 Menu: Save / Save as… / Rename / Reveal / Open… / New + a recent list. */
 @Composable
@@ -155,7 +160,10 @@ internal fun SessionMenu(
         // Highlight on hover and stay highlighted while the menu is open.
         Row(
             modifier = Modifier.fillMaxWidth().clip(RoundedCornerShape(6.dp))
-                .background(if (vHover || vOpen) c.accent.copy(alpha = 0.16f) else Color.Transparent, RoundedCornerShape(6.dp))
+                .background(
+                    if (vHover || vOpen) c.accent.copy(alpha = 0.16f) else Color.Transparent,
+                    RoundedCornerShape(6.dp)
+                )
                 .hoverable(vHoverSrc)
                 .clickable { vOpen = true }.padding(horizontal = 6.dp, vertical = 4.dp),
             verticalAlignment = Alignment.CenterVertically,
@@ -169,7 +177,11 @@ internal fun SessionMenu(
             // No file yet → a dot; once it has a file it auto-saves, so no dot.
             if (!vSaved) Box(Modifier.size(6.dp).background(c.accent, RoundedCornerShape(3.dp)))
         }
-        DropdownMenu(expanded = vOpen, onDismissRequest = { vOpen = false }, modifier = Modifier.widthIn(min = 248.dp)) {
+        DropdownMenu(
+            expanded = vOpen,
+            onDismissRequest = { vOpen = false },
+            modifier = Modifier.widthIn(min = 248.dp)
+        ) {
             DropdownMenuItem(text = {
                 MenuRow(
                     MaterialSymbols.Tune,
@@ -177,7 +189,9 @@ internal fun SessionMenu(
                 )
             }, onClick = { vOpen = false; inOnSettings() })
             HorizontalDivider(color = c.border)
-            DropdownMenuItem(text = { MenuRow(MaterialSymbols.Save, "Save session") }, onClick = { vOpen = false; inOnSave() })
+            DropdownMenuItem(
+                text = { MenuRow(MaterialSymbols.Save, "Save session") },
+                onClick = { vOpen = false; inOnSave() })
             DropdownMenuItem(text = {
                 MenuRow(
                     MaterialSymbols.Download,
@@ -193,7 +207,8 @@ internal fun SessionMenu(
                     )
                 },
                 onClick = { vOpen = false; inOnRename() },
-                enabled = vSaved)
+                enabled = vSaved
+            )
             DropdownMenuItem(
                 text = {
                     MenuRow(
@@ -203,7 +218,8 @@ internal fun SessionMenu(
                     )
                 },
                 onClick = { vOpen = false; inOnReveal() },
-                enabled = vSaved)
+                enabled = vSaved
+            )
             HorizontalDivider(color = c.border)
             DropdownMenuItem(text = {
                 MenuRow(
@@ -211,7 +227,9 @@ internal fun SessionMenu(
                     "Default session"
                 )
             }, onClick = { vOpen = false; inOnDefault() })
-            DropdownMenuItem(text = { MenuRow(MaterialSymbols.Add, "New session") }, onClick = { vOpen = false; inOnNew() })
+            DropdownMenuItem(
+                text = { MenuRow(MaterialSymbols.Add, "New session") },
+                onClick = { vOpen = false; inOnNew() })
             DropdownMenuItem(text = {
                 MenuRow(
                     MaterialSymbols.Folder,
@@ -222,7 +240,7 @@ internal fun SessionMenu(
                 HorizontalDivider(color = c.border)
                 // Aligned to the icon column (the DropdownMenuItem's 16dp pad), so
                 // it lines up with the recent items' file icon. Padding goes on a
-                // wrapping Box — a leaf Text's own start padding isn't applied to its
+                // wrapping Box - a leaf Text's own start padding isn't applied to its
                 // draw position by this layout engine.
                 Box(modifier = Modifier.fillMaxWidth().padding(start = 16.dp, top = 6.dp, bottom = 2.dp)) {
                     Text("Recent", color = c.dim, fontSize = 11.sp)
@@ -245,10 +263,12 @@ internal fun SessionMenu(
                                     Text(fileLeaf(vPath), color = c.text, fontSize = 12.sp)
                                     Text(ellipsizeMiddle(vPath, 32), color = c.dim, fontSize = 10.sp, softWrap = false)
                                 }
-                                // Reveal this session's folder — its own hover + tooltip so it
+                                // Reveal this session's folder - its own hover + tooltip so it
                                 // reads as a separate action from "open the session".
                                 TooltipBox(
-                                    positionProvider = TooltipDefaults.rememberTooltipPositionProvider(TooltipAnchorPosition.Above),
+                                    positionProvider = TooltipDefaults.rememberTooltipPositionProvider(
+                                        TooltipAnchorPosition.Above
+                                    ),
                                     tooltip = { PlainTooltip { Text("Reveal in ${fileManagerName()}") } },
                                     state = rememberTooltipState(),
                                 ) {
@@ -283,7 +303,7 @@ internal fun SessionMenu(
 // MARK: Pack tree (recursive sidebar rendering)
 // ==================
 
-/* The per-pack operations a PackSection needs, bundled so PackTree can bind them
+/** The per-pack operations a PackSection needs, bundled so PackTree can bind them
 recursively for sub-packs while PackSection itself stays callback-driven. */
 internal class PackOps(
     val onEnv: (PackState) -> Unit,
@@ -310,11 +330,18 @@ internal class PackOps(
     val packDropEnd: () -> Unit,
 )
 
-/* Renders a pack then its sub-packs recursively, each indented by its depth.
+/** Renders a pack then its sub-packs recursively, each indented by its depth.
 inSiblings is the list this pack belongs to (top-level vPacks, or a parent's
-   subPacks) — used to position the pack-reorder drop bars by index. */
+subPacks) - used to position the pack-reorder drop bars by index. */
 @Composable
-internal fun PackTree(inPack: PackState, inSiblings: List<PackState>, inDepth: Int, inOps: PackOps, inActive: PackState?, inEnvActive: Boolean) {
+internal fun PackTree(
+    inPack: PackState,
+    inSiblings: List<PackState>,
+    inDepth: Int,
+    inOps: PackOps,
+    inActive: PackState?,
+    inEnvActive: Boolean
+) {
     val vDrag = inOps.drag
     val vMyIndex = inSiblings.indexOf(inPack)
     val vMoving = vDrag.draggingPack && vDrag.engaged && vDrag.dropInto == null
@@ -354,7 +381,16 @@ internal fun PackTree(inPack: PackState, inSiblings: List<PackState>, inDepth: I
             )
         }
     }
-    if (inPack.expanded) inPack.subPacks.forEach { PackTree(it, inPack.subPacks, inDepth + 1, inOps, inActive, inEnvActive) }
+    if (inPack.expanded) inPack.subPacks.forEach {
+        PackTree(
+            it,
+            inPack.subPacks,
+            inDepth + 1,
+            inOps,
+            inActive,
+            inEnvActive
+        )
+    }
     if (vBarAfter) Box(modifier = vPad) { RowDropBar() }
 }
 
@@ -362,7 +398,7 @@ internal fun PackTree(inPack: PackState, inSiblings: List<PackState>, inDepth: I
 // MARK: Pack section (foldable pack in the sidebar)
 // ==================
 
-/* One open pack rendered as a foldable section: a header (fold chevron, colour
+/** One open pack rendered as a foldable section: a header (fold chevron, colour
 box, name, dirty dot, request count, ⋮ menu) over the pack's request list
 when expanded. Clicking the header body selects the pack (so the Env tab and
 main panel follow it); the chevron only folds. The request list drags to
@@ -413,7 +449,8 @@ internal fun PackSection(
             .onSizeChanged { inDrag.headH[inPack] = it.height }
         // See RequestTabStrip note: alpha + translation on the SAME graphicsLayer so
         // clip=false and the drag ghost isn't clipped to its original bounds.
-        if (vHeaderDragged) vHeadMod = vHeadMod.zIndex(1f).graphicsLayer(alpha = 0.65f, translationX = 0f, translationY = inDrag.dy)
+        if (vHeaderDragged) vHeadMod =
+            vHeadMod.zIndex(1f).graphicsLayer(alpha = 0.65f, translationX = 0f, translationY = inDrag.dy)
         vHeadMod = vHeadMod.clip(RoundedCornerShape(6.dp))
             .background(
                 when {
@@ -465,9 +502,15 @@ internal fun PackSection(
             verticalAlignment = Alignment.CenterVertically,
             horizontalArrangement = Arrangement.spacedBy(2.dp),
         ) {
-            IconBtn(if (inPack.expanded) MaterialSymbols.ExpandMore else MaterialSymbols.ChevronRight, "Fold", inSize = 18.dp, inPadding = 3.dp) { inOnToggle() }
+            IconBtn(
+                if (inPack.expanded) MaterialSymbols.ExpandMore else MaterialSymbols.ChevronRight,
+                "Fold",
+                inSize = 18.dp,
+                inPadding = 3.dp
+            ) { inOnToggle() }
             Row(
-                modifier = Modifier.weight(1f).clip(RoundedCornerShape(5.dp)).clickable { inOnSelect() }.padding(vertical = 4.dp),
+                modifier = Modifier.weight(1f).clip(RoundedCornerShape(5.dp)).clickable { inOnSelect() }
+                    .padding(vertical = 4.dp),
                 verticalAlignment = Alignment.CenterVertically,
                 horizontalArrangement = Arrangement.spacedBy(7.dp),
             ) {
@@ -476,11 +519,19 @@ internal fun PackSection(
                 Text(inPack.name, color = c.text, fontSize = 14.sp, modifier = Modifier.weight(1f))
                 Text("${inPack.requests.size}", color = c.dim, fontSize = 11.sp)
             }
-            // + (new request) and ⋮ (pack menu) — both reveal on hover only, so the
+            // + (new request) and ⋮ (pack menu) - both reveal on hover only, so the
             // header width never shifts (alpha, not conditional layout). A linked
             // copy mirrors its source's requests, so it has no "new request".
-            Row(modifier = Modifier.alpha(if (vHover || vMenu) 1f else 0f), verticalAlignment = Alignment.CenterVertically) {
-                if (!inPack.isLinked) IconBtn(MaterialSymbols.Add, "New request", inSize = 16.dp, inPadding = 4.dp) { inOnNewRequest() }
+            Row(
+                modifier = Modifier.alpha(if (vHover || vMenu) 1f else 0f),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                if (!inPack.isLinked) IconBtn(
+                    MaterialSymbols.Add,
+                    "New request",
+                    inSize = 16.dp,
+                    inPadding = 4.dp
+                ) { inOnNewRequest() }
                 Box {
                     IconBtn(MaterialSymbols.MoreHoriz, "Pack menu", inSize = 16.dp, inPadding = 4.dp) { vMenu = true }
                     DropdownMenu(
@@ -488,23 +539,41 @@ internal fun PackSection(
                         onDismissRequest = { vMenu = false },
                         modifier = Modifier.widthIn(min = 220.dp),
                     ) {
-                        DropdownMenuItem(text = { MenuRow(MaterialSymbols.Edit, "Rename pack") }, onClick = { vMenu = false; inOnRenamePack() })
-                        DropdownMenuItem(text = { MenuRow(MaterialSymbols.FileCopy, "Duplicate pack") }, onClick = { vMenu = false; inOnDuplicatePack() })
-                        DropdownMenuItem(text = { MenuRow(MaterialSymbols.Add, "New sub-pack") }, onClick = { vMenu = false; inOnNewSubPack() })
-                        DropdownMenuItem(text = { MenuRow(MaterialSymbols.Share, "Linked copy") }, onClick = { vMenu = false; inOnLinkedCopy() })
-                        DropdownMenuItem(text = { MenuRow(MaterialSymbols.Save, "Export pack") }, onClick = { vMenu = false; inOnSavePack() })
-                        DropdownMenuItem(text = { MenuRow(MaterialSymbols.Folder, "Export pack as…") }, onClick = { vMenu = false; inOnSaveAsPack() })
+                        DropdownMenuItem(
+                            text = { MenuRow(MaterialSymbols.Edit, "Rename pack") },
+                            onClick = { vMenu = false; inOnRenamePack() })
+                        DropdownMenuItem(
+                            text = { MenuRow(MaterialSymbols.FileCopy, "Duplicate pack") },
+                            onClick = { vMenu = false; inOnDuplicatePack() })
+                        DropdownMenuItem(
+                            text = { MenuRow(MaterialSymbols.Add, "New sub-pack") },
+                            onClick = { vMenu = false; inOnNewSubPack() })
+                        DropdownMenuItem(
+                            text = { MenuRow(MaterialSymbols.Share, "Linked copy") },
+                            onClick = { vMenu = false; inOnLinkedCopy() })
+                        DropdownMenuItem(
+                            text = { MenuRow(MaterialSymbols.Save, "Export pack") },
+                            onClick = { vMenu = false; inOnSavePack() })
+                        DropdownMenuItem(
+                            text = { MenuRow(MaterialSymbols.Folder, "Export pack as…") },
+                            onClick = { vMenu = false; inOnSaveAsPack() })
                         HorizontalDivider(color = c.border)
                         PackColorPicker(inPack.color) { inOnSetColor(it) }
                         HorizontalDivider(color = c.border)
-                        DropdownMenuItem(text = { MenuRow(MaterialSymbols.Delete, "Remove pack", methodColor(ReqMethod.DELETE)) }, onClick = { vMenu = false; inOnRemovePack() })
+                        DropdownMenuItem(text = {
+                            MenuRow(
+                                MaterialSymbols.Delete,
+                                "Remove pack",
+                                methodColor(ReqMethod.DELETE)
+                            )
+                        }, onClick = { vMenu = false; inOnRemovePack() })
                     }
                 }
             }
         }
 
         // ============
-        //  Pack body — request list (expanded, or always for the loose root).
+        //  Pack body - request list (expanded, or always for the loose root).
         //  Rows drag within and across packs via the shared controller; the drop
         //  bar shows here whenever this pack is the resolved target.
         if (inPack.expanded || inHeaderless) {
@@ -515,7 +584,7 @@ internal fun PackSection(
             val vBarBefore = if (vIsTarget) vOthers.getOrNull(inDrag.dropIndex) else null
             val vBarAtEnd = vIsTarget && inDrag.dropIndex >= vOthers.size
             // The loose root has no header, so register the body box as its drop
-            // anchor — that gives an empty root a region to target while dragging.
+            // anchor - that gives an empty root a region to target while dragging.
             var vBodyMod = Modifier.fillMaxWidth().padding(start = 10.dp, top = 2.dp, bottom = 4.dp)
             if (inHeaderless) vBodyMod = vBodyMod
                 .onGloballyPositioned { inDrag.headTop[inPack] = it.y }
@@ -525,13 +594,18 @@ internal fun PackSection(
                 verticalArrangement = Arrangement.spacedBy(2.dp),
             ) {
                 if (inHeaderless && vReqs.isEmpty())
-                    Text("Drop a request here to make it loose", color = c.dim, fontSize = 11.sp, modifier = Modifier.padding(vertical = 4.dp))
+                    Text(
+                        "Drop a request here to make it loose",
+                        color = c.dim,
+                        fontSize = 11.sp,
+                        modifier = Modifier.padding(vertical = 4.dp)
+                    )
                 vReqs.forEach { vRs ->
                     if (vRs === vBarBefore) RowDropBar()
                     key(vRs) {
                         val vDragged = vRs === inDrag.dragReq && vMoving
                         var vMod: Modifier = Modifier
-                        // Linked copies mirror the source's requests — read-only, so
+                        // Linked copies mirror the source's requests - read-only, so
                         // their rows neither register geometry (would clobber the
                         // source's) nor drag.
                         if (!inPack.isLinked) vMod = vMod
@@ -539,9 +613,10 @@ internal fun PackSection(
                             .onSizeChanged { inDrag.rowH[vRs] = it.height }
                         // translate is draw-only (doesn't shift absoluteY), so the
                         // cursor offset below stays correct while dragging.
-                        if (vDragged) vMod = vMod.zIndex(1f).graphicsLayer(alpha = 0.65f, translationX = 0f, translationY = inDrag.dy)
+                        if (vDragged) vMod =
+                            vMod.zIndex(1f).graphicsLayer(alpha = 0.65f, translationX = 0f, translationY = inDrag.dy)
                         if (!inPack.isLinked) vMod = vMod.pointerInput(vRs) {
-                                // Same graphicsLayer feedback concern as the pack drag —
+                            // Same graphicsLayer feedback concern as the pack drag -
                             // accumulate dragAmount instead of reading change.position.
                             detectDragGestures(
                                 onDragStart = { offset ->
@@ -554,7 +629,8 @@ internal fun PackSection(
                                     val vd = inDrag.dragReq ?: return@detectDragGestures
                                     inDrag.dy += dragAmount.y
                                     val vRelY = inDrag.pressRel + inDrag.dy.toInt()
-                                        if (!inDrag.engaged && kotlin.math.abs(inDrag.dy) >= kDragSlop) inDrag.engaged = true
+                                    if (!inDrag.engaged && kotlin.math.abs(inDrag.dy) >= kDragSlop) inDrag.engaged =
+                                        true
                                     if (inDrag.engaged) inResolveReqDrop((inDrag.rowTop[vd] ?: 0) + vRelY)
                                 },
                                 onDragEnd = { inOnReqDropEnd() },
@@ -630,7 +706,7 @@ internal fun RequestRow(
     ) {
         MethodTag(vReq.method)
         Text(vReq.name, color = c.text, fontSize = 13.sp, modifier = Modifier.weight(1f))
-        // Overflow (vertical-dots) menu — always laid out so the row width
+        // Overflow (vertical-dots) menu - always laid out so the row width
         // never changes; only its opacity toggles on hover / while open. Delete
         // lives inside this menu (no separate button on the row).
         Box(modifier = Modifier.alpha(if (vHover || vMenu) 1f else 0f)) {
@@ -640,10 +716,22 @@ internal fun RequestRow(
                 onDismissRequest = { vMenu = false },
                 modifier = Modifier.widthIn(min = 168.dp),
             ) {
-                if (!inReadOnly) DropdownMenuItem(text = { MenuRow(MaterialSymbols.Edit, "Rename") }, onClick = { vMenu = false; inOnRename() })
-                if (!inReadOnly) DropdownMenuItem(text = { MenuRow(MaterialSymbols.FileCopy, "Duplicate") }, onClick = { vMenu = false; inOnDuplicate() })
-                DropdownMenuItem(text = { MenuRow(MaterialSymbols.Terminal, "Copy as cURL") }, onClick = { vMenu = false; inOnCopyCurl() })
-                if (!inReadOnly) DropdownMenuItem(text = { MenuRow(MaterialSymbols.Delete, "Delete", methodColor(ReqMethod.DELETE)) }, onClick = { vMenu = false; inOnDelete() })
+                if (!inReadOnly) DropdownMenuItem(
+                    text = { MenuRow(MaterialSymbols.Edit, "Rename") },
+                    onClick = { vMenu = false; inOnRename() })
+                if (!inReadOnly) DropdownMenuItem(
+                    text = { MenuRow(MaterialSymbols.FileCopy, "Duplicate") },
+                    onClick = { vMenu = false; inOnDuplicate() })
+                DropdownMenuItem(
+                    text = { MenuRow(MaterialSymbols.Terminal, "Copy as cURL") },
+                    onClick = { vMenu = false; inOnCopyCurl() })
+                if (!inReadOnly) DropdownMenuItem(text = {
+                    MenuRow(
+                        MaterialSymbols.Delete,
+                        "Delete",
+                        methodColor(ReqMethod.DELETE)
+                    )
+                }, onClick = { vMenu = false; inOnDelete() })
             }
         }
     }

apidemo/src/commonMain/kotlin/SyntaxHighlight.kt

@@ -0,0 +1,397 @@
+package apidemo
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import kotlinx.serialization.Serializable
+
+// ==================
+// MARK: BodyFormat - viewer/highlighter selection
+// ==================
+
+/** Format of a body payload as shown in the viewer, and (for a TEXT request body)
+the type the user picks on the right of the Body tab - it drives both syntax
+highlighting and the sent Content-Type. RAW disables highlighting and falls back
+to the selectable BasicTextField; other values pick a tokeniser. */
+@Serializable
+enum class BodyFormat { RAW, JSON, XML, YAML, HTML }
+
+/** Short label for the format / "type" picker (RAW = plain text, no highlighting). */
+val BodyFormat.label: String
+    get() = when (this) {
+        BodyFormat.RAW -> "RAW"
+        BodyFormat.JSON -> "JSON"
+        BodyFormat.XML -> "XML"
+        BodyFormat.YAML -> "YAML"
+        BodyFormat.HTML -> "HTML"
+    }
+
+/** The Content-Type a TEXT body of this format is sent with. */
+val BodyFormat.contentType: String
+    get() = when (this) {
+        BodyFormat.RAW -> "text/plain"
+        BodyFormat.JSON -> "application/json"
+        BodyFormat.XML -> "application/xml"
+        BodyFormat.YAML -> "application/yaml"
+        BodyFormat.HTML -> "text/html"
+    }
+
+/** Pick a format from a Content-Type header. JSON / XML / YAML / HTML
+match their canonical types and common variants; anything else
+(image types, text/plain, …) falls back to RAW. */
+fun autoFormatFor(inContentType: String?): BodyFormat {
+    val vCt = inContentType?.substringBefore(';')?.trim()?.lowercase() ?: return BodyFormat.RAW
+    return when {
+        vCt.endsWith("+json") || vCt == "application/json" -> BodyFormat.JSON
+        vCt.endsWith("+xml") || vCt == "application/xml" || vCt == "text/xml" -> BodyFormat.XML
+        vCt == "application/yaml" || vCt == "text/yaml" || vCt == "application/x-yaml" -> BodyFormat.YAML
+        vCt == "text/html" -> BodyFormat.HTML
+        else -> BodyFormat.RAW
+    }
+}
+
+// ==================
+// MARK: Highlight palette
+// ==================
+
+/** Per-token colours. Two preset themes: a dark-on-dark and a dark-on-
+light variant matching VS Code's defaults. Caller picks based on
+surrounding theme; auto-pick available via SyntaxPalette.forDark(). */
+data class SyntaxPalette(
+    val key: Color,
+    val string: Color,
+    val number: Color,
+    val keyword: Color,
+    val tag: Color,
+    val comment: Color,
+    val punct: Color,
+) {
+    companion object {
+        /** Light-on-dark - VS Code Dark+. */
+        val Dark = SyntaxPalette(
+            key = Color(0xFF9CDCFE),
+            string = Color(0xFFCE9178),
+            number = Color(0xFFB5CEA8),
+            keyword = Color(0xFFC586C0),
+            tag = Color(0xFF569CD6),
+            comment = Color(0xFF6A9955),
+            punct = Color(0xFFCCCCCC),
+        )
+
+        /** Dark-on-light - VS Code Light+. Higher contrast on white. */
+        val Light = SyntaxPalette(
+            key = Color(0xFF0451A5),
+            string = Color(0xFFA31515),
+            number = Color(0xFF098658),
+            keyword = Color(0xFF0000FF),
+            tag = Color(0xFF800000),
+            comment = Color(0xFF008000),
+            punct = Color(0xFF333333),
+        )
+
+        /** Pick a palette by the host theme's background brightness. */
+        fun forDark(inIsDark: Boolean): SyntaxPalette = if (inIsDark) Dark else Light
+    }
+}
+
+// ==================
+// MARK: Entry point
+// ==================
+
+/** Render the given text with per-token colour spans for the requested
+format. RAW returns an unstyled AnnotatedString. */
+fun highlight(
+    inText: String,
+    inFormat: BodyFormat,
+    inPalette: SyntaxPalette = SyntaxPalette.Dark,
+): AnnotatedString = when (inFormat) {
+    BodyFormat.RAW -> AnnotatedString(inText)
+    BodyFormat.JSON -> highlightJson(inText, inPalette)
+    BodyFormat.XML, BodyFormat.HTML -> highlightXml(inText, inPalette)
+    BodyFormat.YAML -> highlightYaml(inText, inPalette)
+}
+
+// ==================
+// MARK: JSON tokeniser - single-pass, error-tolerant
+// ==================
+
+/** Tokeniser for JSON. Walks the string once and emits style spans for
+strings, numbers, booleans, null, punctuation. Distinguishes "keys"
+(strings followed by ':') from string values by peeking after each
+string. Error-tolerant - malformed JSON still highlights as best
+effort rather than throwing. */
+private fun highlightJson(inText: String, inP: SyntaxPalette): AnnotatedString = buildAnnotatedString {
+    val vN = inText.length
+    var vI = 0
+    while (vI < vN) {
+        val vC = inText[vI]
+        when {
+            vC == '"' -> {
+                // Find closing quote, honouring backslash-escaped chars so an
+                // escaped \" doesn't terminate the string early.
+                val vStart = vI
+                var vJ = vI + 1
+                while (vJ < vN) {
+                    if (inText[vJ] == '\\' && vJ + 1 < vN) {
+                        vJ += 2; continue
+                    }
+                    if (inText[vJ] == '"') {
+                        vJ++; break
+                    }
+                    vJ++
+                }
+                // Peek for ':' (skipping whitespace) → it's a key, not a value.
+                var vK = vJ
+                while (vK < vN && inText[vK].isWhitespace()) vK++
+                val vIsKey = vK < vN && inText[vK] == ':'
+                val vColor = if (vIsKey) inP.key else inP.string
+                pushStyle(SpanStyle(color = vColor))
+                append(inText.substring(vStart, vJ))
+                pop()
+                vI = vJ
+            }
+
+            vC.isDigit() || (vC == '-' && vI + 1 < vN && inText[vI + 1].isDigit()) -> {
+                val vStart = vI
+                if (vC == '-') vI++
+                while (vI < vN && (inText[vI].isDigit() || inText[vI] in ".eE+-")) vI++
+                pushStyle(SpanStyle(color = inP.number))
+                append(inText.substring(vStart, vI))
+                pop()
+            }
+
+            vC.isLetter() -> {
+                val vStart = vI
+                while (vI < vN && inText[vI].isLetter()) vI++
+                val vWord = inText.substring(vStart, vI)
+                if (vWord == "true" || vWord == "false" || vWord == "null") {
+                    pushStyle(SpanStyle(color = inP.keyword))
+                    append(vWord)
+                    pop()
+                } else {
+                    append(vWord)
+                }
+            }
+
+            vC in "{}[],:" -> {
+                pushStyle(SpanStyle(color = inP.punct))
+                append(vC)
+                pop()
+                vI++
+            }
+
+            else -> {
+                append(vC); vI++
+            }
+        }
+    }
+}
+
+// ==================
+// MARK: XML / HTML tokeniser
+// ==================
+
+/** Tokeniser for XML / HTML. Distinguishes tag names, attribute names,
+attribute values (string), and comments. Inside tags, attr=value pairs
+are recognised; outside tags text is left in the default colour. */
+private fun highlightXml(inText: String, inP: SyntaxPalette): AnnotatedString = buildAnnotatedString {
+    val vN = inText.length
+    var vI = 0
+    while (vI < vN) {
+        when (val vC = inText[vI]) {
+            '<' if inText.startsWith("<!--", vI) -> {
+                val vEnd = inText.indexOf("-->", vI + 4).let { if (it < 0) vN else it + 3 }
+                pushStyle(SpanStyle(color = inP.comment))
+                append(inText.substring(vI, vEnd))
+                pop()
+                vI = vEnd
+            }
+
+            '<' -> {
+                // Tag open: <[/]name attr=val attr2="val2">
+                val vGt = inText.indexOf('>', vI).let { if (it < 0) vN else it + 1 }
+                pushStyle(SpanStyle(color = inP.punct)); append('<'); pop()
+                var vJ = vI + 1
+                if (vJ < vN && inText[vJ] == '/') {
+                    pushStyle(SpanStyle(color = inP.punct)); append('/'); pop(); vJ++
+                }
+                // Tag name.
+                val vTagStart = vJ
+                while (vJ < vN && !inText[vJ].isWhitespace() && inText[vJ] != '>' && inText[vJ] != '/') vJ++
+                if (vJ > vTagStart) {
+                    pushStyle(SpanStyle(color = inP.tag))
+                    append(inText.substring(vTagStart, vJ))
+                    pop()
+                }
+                // Attributes - name="value" pairs.
+                while (vJ < vGt - 1) {
+                    val vC2 = inText[vJ]
+                    when {
+                        vC2.isWhitespace() -> {
+                            append(vC2); vJ++
+                        }
+
+                        vC2 == '/' -> {
+                            pushStyle(SpanStyle(color = inP.punct)); append('/'); pop(); vJ++
+                        }
+
+                        vC2 == '=' -> {
+                            pushStyle(SpanStyle(color = inP.punct)); append('='); pop(); vJ++
+                        }
+
+                        vC2 == '"' || vC2 == '\'' -> {
+                            val vEnd = inText.indexOf(vC2, vJ + 1).let { if (it < 0) vGt - 1 else it + 1 }
+                            pushStyle(SpanStyle(color = inP.string))
+                            append(inText.substring(vJ, vEnd))
+                            pop()
+                            vJ = vEnd
+                        }
+
+                        else -> {
+                            val vAttrStart = vJ
+                            while (vJ < vGt - 1 && !inText[vJ].isWhitespace() && inText[vJ] != '=' && inText[vJ] != '>' && inText[vJ] != '/') vJ++
+                            pushStyle(SpanStyle(color = inP.key))
+                            append(inText.substring(vAttrStart, vJ))
+                            pop()
+                        }
+                    }
+                }
+                if (vGt > vI && inText.getOrNull(vGt - 1) == '>') {
+                    pushStyle(SpanStyle(color = inP.punct)); append('>'); pop()
+                }
+                vI = vGt
+            }
+
+            else -> {
+                append(vC); vI++
+            }
+        }
+    }
+}
+
+// ==================
+// MARK: YAML tokeniser - line-based
+// ==================
+
+/** Tokeniser for YAML. Walks line by line because YAML's grammar is
+indent-sensitive and most of the interesting colour decisions
+(key vs value, list item vs scalar) depend on position within a
+line. Comments (#), keys (text before ':'), quoted strings, numbers
+and booleans are coloured; everything else stays default. */
+private fun highlightYaml(inText: String, inP: SyntaxPalette): AnnotatedString = buildAnnotatedString {
+    val vLines = inText.split('\n')
+    for ((vIdx, vLineRaw) in vLines.withIndex()) {
+        val vLine = vLineRaw
+        // Comment: rest of the line after a # (not inside a quoted string).
+        val vCommentAt = findUnquotedHash(vLine)
+        val vCodePart = if (vCommentAt >= 0) vLine.substring(0, vCommentAt) else vLine
+        val vCommentPart = if (vCommentAt >= 0) vLine.substring(vCommentAt) else ""
+
+        // Find a key: indent + (optional "- ") + key + ':' + (space|eol).
+        val vColon = indexOfKeyColon(vCodePart)
+        if (vColon > 0) {
+            val vPrefix = vCodePart.substring(0, vColon)
+            val vRest = vCodePart.substring(vColon + 1)
+            // Lead whitespace + optional list marker, then key.
+            var vK = 0
+            while (vK < vPrefix.length && vPrefix[vK].isWhitespace()) {
+                append(vPrefix[vK]); vK++
+            }
+            if (vK + 1 < vPrefix.length && vPrefix[vK] == '-' && vPrefix[vK + 1].isWhitespace()) {
+                pushStyle(SpanStyle(color = inP.punct)); append('-'); pop()
+                append(vPrefix[vK + 1])
+                vK += 2
+            }
+            pushStyle(SpanStyle(color = inP.key))
+            append(vPrefix.substring(vK))
+            pop()
+            pushStyle(SpanStyle(color = inP.punct)); append(':'); pop()
+            appendYamlValue(vRest, inP)
+        } else {
+            appendYamlValue(vCodePart, inP)
+        }
+        if (vCommentPart.isNotEmpty()) {
+            pushStyle(SpanStyle(color = inP.comment))
+            append(vCommentPart)
+            pop()
+        }
+        if (vIdx < vLines.size - 1) append('\n')
+    }
+}
+
+/** Render the value portion of a YAML line - applies string / number /
+keyword / list-marker colours where applicable. */
+private fun AnnotatedString.Builder.appendYamlValue(inSeg: String, inP: SyntaxPalette) {
+    val vTrimmed = inSeg.trimStart()
+    val vPad = inSeg.substring(0, inSeg.length - vTrimmed.length)
+    append(vPad)
+    when {
+        vTrimmed.isEmpty() -> { /* nothing */
+        }
+
+        vTrimmed.startsWith('-') && (vTrimmed.length == 1 || vTrimmed[1].isWhitespace()) -> {
+            pushStyle(SpanStyle(color = inP.punct)); append('-'); pop()
+            appendYamlValue(vTrimmed.substring(1), inP)
+        }
+
+        vTrimmed.startsWith('"') || vTrimmed.startsWith('\'') -> {
+            val vQ = vTrimmed[0]
+            val vEnd = vTrimmed.indexOf(vQ, 1).let { if (it < 0) vTrimmed.length else it + 1 }
+            pushStyle(SpanStyle(color = inP.string))
+            append(vTrimmed.substring(0, vEnd))
+            pop()
+            append(vTrimmed.substring(vEnd))
+        }
+
+        vTrimmed == "true" || vTrimmed == "false" || vTrimmed == "null" || vTrimmed == "~" -> {
+            pushStyle(SpanStyle(color = inP.keyword)); append(vTrimmed); pop()
+        }
+
+        vTrimmed.first().let { it.isDigit() || it == '-' && vTrimmed.length > 1 && vTrimmed[1].isDigit() } -> {
+            var vJ = 0
+            if (vTrimmed[0] == '-') vJ++
+            while (vJ < vTrimmed.length && (vTrimmed[vJ].isDigit() || vTrimmed[vJ] in ".eE+-")) vJ++
+            pushStyle(SpanStyle(color = inP.number))
+            append(vTrimmed.substring(0, vJ))
+            pop()
+            append(vTrimmed.substring(vJ))
+        }
+
+        else -> append(vTrimmed)
+    }
+}
+
+/** Find the index of the first '#' that isn't inside a quoted string,
+or -1 if there is none. Used to split a YAML line into code + comment. */
+private fun findUnquotedHash(inLine: String): Int {
+    var vInSingle = false
+    var vInDouble = false
+    for (vI in inLine.indices) {
+        when (inLine[vI]) {
+            '"' if !vInSingle -> vInDouble = !vInDouble
+            '\'' if !vInDouble -> vInSingle = !vInSingle
+            '#' if !vInSingle && !vInDouble -> return vI
+        }
+    }
+    return -1
+}
+
+/** Locate the colon that separates a YAML key from its value at the
+current indent level - the FIRST unquoted ':' that's followed by
+either whitespace or end-of-line. Returns -1 if the line has no key. */
+private fun indexOfKeyColon(inLine: String): Int {
+    var vInSingle = false
+    var vInDouble = false
+    for (vI in inLine.indices) {
+        when (inLine[vI]) {
+            '"' if !vInSingle -> vInDouble = !vInDouble
+            '\'' if !vInDouble -> vInSingle = !vInSingle
+            ':' if !vInSingle && !vInDouble -> {
+                val vNext = if (vI + 1 < inLine.length) inLine[vI + 1] else ' '
+                if (vNext.isWhitespace() || vI + 1 == inLine.length) return vI
+            }
+        }
+    }
+    return -1
+}

apidemo/src/commonMain/kotlin/Theme.kt

@@ -0,0 +1,19 @@
+package apidemo
+
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.graphics.Color
+
+// ==================
+// MARK: Theme - the app's legacy colour slots, derived from the active palette
+// ==================
+// AppColors is the app's own colour vocabulary (used by the custom widgets). It
+// is now DERIVED from the selected Voltic M3 ColorScheme via appColorsFromScheme
+// (VolticThemes.kt) and provided through LocalAppColors by App(). The default
+// below (purple dark) only applies before that provider is installed.
+
+class AppColors(
+    val bg: Color, val panel: Color, val field: Color, val border: Color,
+    val accent: Color, val text: Color, val dim: Color, val onAccent: Color,
+)
+
+internal val LocalAppColors = staticCompositionLocalOf { appColorsFromScheme(VolticPalette.Purple.scheme.dark) }

apidemo/src/commonMain/kotlin/TlsChainDialog.kt

@@ -15,24 +15,25 @@ import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.layout.onGloballyPositioned
 import androidx.compose.ui.layout.onSizeChanged
-import androidx.compose.ui.platform.ClipEntry
 import androidx.compose.ui.platform.LocalClipboard
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.Popup
+import apidemo.compat.clipEntryOfText
+import apidemo.compat.x
+import apidemo.compat.y
 import com.compose.sdl.icons.MaterialSymbols
 import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
-import com.compose.sdl.layout.x
-import com.compose.sdl.layout.y
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlin.time.Duration.Companion.milliseconds
 
 // ==================
 // MARK: TLS certificate-chain dialog + cert cards
 // ==================
 
-/* Dialog showing the server's TLS certificate chain (one card per cert, plus a
+/** Dialog showing the server's TLS certificate chain (one card per cert, plus a
 Copy PEM action). Fetched on demand by the lock button in the URL bar. */
 @Composable
 internal fun TlsChainDialog(inChain: TlsChain?, inUrl: String, inOnDismiss: () -> Unit) {
@@ -40,16 +41,28 @@ internal fun TlsChainDialog(inChain: TlsChain?, inUrl: String, inOnDismiss: () -
     Dialog(onDismissRequest = inOnDismiss) {
         Surface(color = c.panel, shape = RoundedCornerShape(10.dp), modifier = Modifier.width(540.dp)) {
             Column(modifier = Modifier.padding(18.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
-                Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) {
+                Row(
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    verticalAlignment = Alignment.CenterVertically
+                ) {
                     MaterialSymbolsOutlined(MaterialSymbols.Lock, tint = c.accent, size = 20.dp)
                     Text("TLS certificate chain", color = c.text, fontSize = 16.sp)
                 }
                 val vCerts = inChain?.certs.orEmpty()
                 when {
                     inChain == null -> Text("Probing…", color = c.dim, fontSize = 13.sp)
-                    vCerts.isEmpty() -> Text(inChain.error ?: "No chain reported.", color = kWarnColor, fontSize = 13.sp)
+                    vCerts.isEmpty() -> Text(
+                        inChain.error ?: "No chain reported.",
+                        color = VolticTheme.extended.warning,
+                        fontSize = 13.sp
+                    )
+
                     else -> {
-                        Text("${vCerts.size} certificate(s) presented by ${hostOf(inUrl)}", color = c.dim, fontSize = 12.sp)
+                        Text(
+                            "${vCerts.size} certificate(s) presented by ${hostOf(inUrl)}",
+                            color = c.dim,
+                            fontSize = 12.sp
+                        )
                         Column(
                             modifier = Modifier.heightIn(max = 420.dp).verticalScroll(rememberScrollState()),
                             verticalArrangement = Arrangement.spacedBy(10.dp),
@@ -57,7 +70,10 @@ internal fun TlsChainDialog(inChain: TlsChain?, inUrl: String, inOnDismiss: () -
                     }
                 }
                 Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.End) {
-                    Row(horizontalArrangement = Arrangement.spacedBy(10.dp), verticalAlignment = Alignment.CenterVertically) {
+                    Row(
+                        horizontalArrangement = Arrangement.spacedBy(10.dp),
+                        verticalAlignment = Alignment.CenterVertically
+                    ) {
                         val vChainPem = vCerts.mapNotNull { certField(it.fields, "Cert") }.joinToString("\n")
                         if (vChainPem.isNotEmpty()) CopyButton(vChainPem, "Copy chain")
                         OutlinedButton(onClick = inOnDismiss) { Text("Close", color = c.text) }
@@ -68,7 +84,7 @@ internal fun TlsChainDialog(inChain: TlsChain?, inUrl: String, inOnDismiss: () -
     }
 }
 
-/* One certificate's summary card (subject / issuer / validity). Server-presented
+/** One certificate's summary card (subject / issuer / validity). Server-presented
 certs get a solid border; derived ones (issuer pulled from the OS store, or a
 name-only placeholder) get an accent-coloured border + a label. A self-signed
 cert shows "Self-signed" in green instead of repeating its issuer. */
@@ -88,20 +104,28 @@ internal fun CertCard(inIndex: Int, inCert: ChainCert) {
     Column(
         modifier = Modifier.fillMaxWidth().clip(RoundedCornerShape(8.dp))
             .background(c.field.copy(alpha = if (inCert.fromServer) 1f else 0.4f), RoundedCornerShape(8.dp))
-            .border(if (inCert.fromServer) 1.dp else 1.5.dp, if (inCert.fromServer) c.border else c.accent, RoundedCornerShape(8.dp))
+            .border(
+                if (inCert.fromServer) 1.dp else 1.5.dp,
+                if (inCert.fromServer) c.border else c.accent,
+                RoundedCornerShape(8.dp)
+            )
             .padding(10.dp),
         verticalArrangement = Arrangement.spacedBy(3.dp),
     ) {
         val vTitle = vSubject?.let { cnOf(it) } ?: if (inIndex == 0) "Leaf certificate" else "Issuer #$inIndex"
         Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
             Text(vTitle, color = c.accent, fontSize = 12.sp, modifier = Modifier.weight(1f))
-            if (!inCert.fromServer) Text(if (vPem != null) "from OS store" else "not presented", color = c.dim, fontSize = 10.sp)
+            if (!inCert.fromServer) Text(
+                if (vPem != null) "from OS store" else "not presented",
+                color = c.dim,
+                fontSize = 10.sp
+            )
             if (vPem != null) CopyButton(vPem)
         }
         vSubject?.let { CertLine("Subject", it) }
         if (vSelfSigned) CertLine("Issuer", "Self-signed", kSelfSignedColor)
         else vIssuer?.let { CertLine("Issuer", it) }
-        // Hosts this cert is valid for — the field that actually has to match the URL.
+        // Hosts this cert is valid for - the field that actually has to match the URL.
         (certField(vFields, "X509v3 Subject Alternative Name")
             ?: certField(vFields, "Subject Alternative Name")
             ?: vParsed?.sans?.takeIf { it.isNotEmpty() }?.joinToString(", "))
@@ -117,7 +141,7 @@ internal fun CertCard(inIndex: Int, inCert: ChainCert) {
 
 internal val kSelfSignedColor = Color(0xFF3FB950L)
 
-/* Copy button — rounded, hover overlay, real click that copies inText and shows
+/** Copy button - rounded, hover overlay, real click that copies inText and shows
 a green check. Icon-only (per cert) flashes a small floating "Copied" bubble
 for 2s; the labelled variant (Copy chain) flips its label to "Copied" instead.
 Uses a non-catching Popup so it never dismisses the dialog or eats clicks. */
@@ -132,7 +156,11 @@ internal fun CopyButton(inText: String, inLabel: String? = null) {
     var vHeight by remember { mutableStateOf(0) }
     val vClipboard = LocalClipboard.current
     val vScope = rememberCoroutineScope()
-    LaunchedEffect(vCopied) { if (vCopied) { delay(2000); vCopied = false } }
+    LaunchedEffect(vCopied) {
+        if (vCopied) {
+            delay(2000.milliseconds); vCopied = false
+        }
+    }
     Row(
         modifier = Modifier
             .onGloballyPositioned { vX = it.x; vY = it.y }
@@ -141,7 +169,7 @@ internal fun CopyButton(inText: String, inLabel: String? = null) {
             .background(if (vHover) c.accent.copy(alpha = 0.18f) else Color.Transparent, RoundedCornerShape(7.dp))
             .hoverable(vHoverSrc)
             .clickable {
-                vScope.launch { vClipboard.setClipEntry(ClipEntry.withPlainText(inText)) }
+                vScope.launch { vClipboard.setClipEntry(clipEntryOfText(inText)) }
                 vCopied = true
             }
             .padding(horizontal = if (inLabel != null) 10.dp else 5.dp, vertical = 5.dp),
@@ -154,7 +182,11 @@ internal fun CopyButton(inText: String, inLabel: String? = null) {
             tint = if (vCopied) kSelfSignedColor else c.dim,
             size = 15.dp,
         )
-        if (inLabel != null) Text(if (vCopied) "Copied" else inLabel, color = if (vCopied) kSelfSignedColor else c.text, fontSize = 12.sp)
+        if (inLabel != null) Text(
+            if (vCopied) "Copied" else inLabel,
+            color = if (vCopied) kSelfSignedColor else c.text,
+            fontSize = 12.sp
+        )
     }
     // Icon-only: float a tiny "Copied" bubble (non-catching popup → no dismiss).
     if (vCopied && inLabel == null) {
@@ -177,16 +209,16 @@ internal fun CertLine(inLabel: String, inValue: String, inValueColor: Color? = n
     }
 }
 
-/* Look up a CURLINFO_CERTINFO field by name (case-insensitive). */
+/** Look up a CURLINFO_CERTINFO field by name (case-insensitive). */
 internal fun certField(inFields: List<Pair<String, String>>, inName: String): String? =
     inFields.firstOrNull { it.first.equals(inName, ignoreCase = true) }?.second
 
-/* The CN= value out of a distinguished-name string. Handles every
+/** The CN= value out of a distinguished-name string. Handles every
 format the platform backends emit:
 "CN=R3, O=Let's Encrypt, C=US"        (Windows CertGetNameStringA)
 "/C=US/O=Let's Encrypt/CN=R3"          (OpenSSL X509_NAME_oneline)
 "CN = R3, O = Let's Encrypt, C = US"   (OpenSSL X509_NAME_print_ex
-                                             default, with spaces — what
+default, with spaces - what
 libcurl on macOS emits)
 Null when there's no CN. */
 internal fun cnOf(inDn: String): String? {
@@ -194,6 +226,6 @@ internal fun cnOf(inDn: String): String? {
     return vMatch.groupValues[1].trim().ifBlank { null }
 }
 
-/* The host portion of a URL (for the chain dialog header). */
+/** The host portion of a URL (for the chain dialog header). */
 internal fun hostOf(inUrl: String): String =
     inUrl.substringAfter("://", inUrl).substringBefore("/").substringBefore("?").ifBlank { inUrl }

apidemo/src/commonMain/kotlin/TlsCommon.kt

@@ -0,0 +1,29 @@
+package apidemo
+
+// ==================
+// MARK: TLS chain / client-certificate seam
+// ==================
+// The real implementations drive the bundled libcurl directly (CurlMtls.kt,
+// nativeMain) - Ktor's engines expose no client-cert / CERTINFO API. The jvm
+// parity app has no bundled libcurl, so its actuals report the feature as
+// native-only instead.
+
+/** One certificate in the chain: its CURLINFO_CERTINFO-style fields (Subject /
+Issuer / the PEM under "Cert" / dates …) and whether the server actually
+presented it. Derived certs - an issuer resolved from the OS store, or a
+name-only placeholder - have fromServer = false and are drawn dotted. */
+class ChainCert(val fields: List<Pair<String, String>>, val fromServer: Boolean)
+
+/** The server's TLS certificate chain. error is set instead when it couldn't be
+fetched; fields vary by TLS backend. */
+class TlsChain(val certs: List<ChainCert>, val error: String?)
+
+/** Fetch the TLS certificate chain the request's server presents. */
+expect fun inspectTlsChain(inReq: ApiRequest): TlsChain
+
+/** Send the request with its client certificate attached (mTLS). */
+expect fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse
+
+/** Remove temp client certs a previous crashed run left behind. Call once at
+startup; no-op where the OS store isn't used. */
+expect fun sweepTempClientCerts()

apidemo/src/commonMain/kotlin/Tools.kt

@@ -4,11 +4,11 @@ package apidemo
 // MARK: Variable substitution ({{name}})
 // ==================
 
-/* Matches a {{ name }} token. Names may contain letters, digits, _, . and -.
+/** Matches a {{ name }} token. Names may contain letters, digits, _, . and -.
 Surrounding whitespace inside the braces is tolerated. */
 private val kVarRegex = Regex("""\{\{\s*([A-Za-z0-9_.\-]+)\s*\}\}""")
 
-/* Replace every {{name}} token in inText with the matching enabled variable's
+/** Replace every {{name}} token in inText with the matching enabled variable's
 value. Unknown / disabled names are left untouched so the user can spot the
 ones that won't resolve. */
 fun substituteVars(inText: String, inVars: List<KeyVal>): String {
@@ -20,26 +20,41 @@ fun substituteVars(inText: String, inVars: List<KeyVal>): String {
     return kVarRegex.replace(inText) { vMatch -> vMap[vMatch.groupValues[1]] ?: vMatch.value }
 }
 
-/* Apply variable substitution across every field that actually gets sent — URL,
-   query params, headers and body — returning a fully-resolved request. The
+/** Apply variable substitution across every field that actually gets sent - URL,
+query params, headers and body - returning a fully-resolved request. The
 original (template) request is left untouched. */
 fun resolveVars(inReq: ApiRequest, inVars: List<KeyVal>): ApiRequest {
     val vActive = inVars.any { it.enabled && it.key.isNotBlank() }
     if (!vActive) return inReq
     return inReq.copy(
         url = substituteVars(inReq.url, inVars),
-        params = inReq.params.map { it.copy(key = substituteVars(it.key, inVars), value = substituteVars(it.value, inVars)) },
-        headers = inReq.headers.map { it.copy(key = substituteVars(it.key, inVars), value = substituteVars(it.value, inVars)) },
+        params = inReq.params.map {
+            it.copy(
+                key = substituteVars(it.key, inVars),
+                value = substituteVars(it.value, inVars)
+            )
+        },
+        headers = inReq.headers.map {
+            it.copy(
+                key = substituteVars(it.key, inVars),
+                value = substituteVars(it.value, inVars)
+            )
+        },
         body = substituteVars(inReq.body, inVars),
-        form = inReq.form.map { it.copy(key = substituteVars(it.key, inVars), value = substituteVars(it.value, inVars)) },
+        form = inReq.form.map {
+            it.copy(
+                key = substituteVars(it.key, inVars),
+                value = substituteVars(it.value, inVars)
+            )
+        },
         certPath = substituteVars(inReq.certPath, inVars),
         keyPath = substituteVars(inReq.keyPath, inVars),
         certPassword = substituteVars(inReq.certPassword, inVars),
     )
 }
 
-/* The distinct {{names}} referenced anywhere in the request that have no enabled
-   variable to fill them — surfaced as a warning in the editor. */
+/** The distinct {{names}} referenced anywhere in the request that have no enabled
+variable to fill them - surfaced as a warning in the editor. */
 fun unresolvedVars(inReq: ApiRequest, inVars: List<KeyVal>): List<String> {
     val vDefined = inVars
         .filter { it.enabled && it.key.isNotBlank() }
@@ -49,7 +64,7 @@ fun unresolvedVars(inReq: ApiRequest, inVars: List<KeyVal>): List<String> {
         append(inReq.url).append('\n')
         inReq.params.forEach { append(it.key).append('\n').append(it.value).append('\n') }
         inReq.headers.forEach { append(it.key).append('\n').append(it.value).append('\n') }
-        if (inReq.method.allowsBody) {
+        if (true) {
             when (inReq.bodyType) {
                 BodyType.FORM -> inReq.form.forEach { append(it.key).append('\n').append(it.value).append('\n') }
                 else -> append(inReq.body)
@@ -67,7 +82,7 @@ fun unresolvedVars(inReq: ApiRequest, inVars: List<KeyVal>): List<String> {
 // MARK: Copy as cURL
 // ==================
 
-/* Render inReq as a runnable, multi-line curl command (pass an already-resolved
+/** Render inReq as a runnable, multi-line curl command (pass an already-resolved
 request so the output has real values, not {{tokens}}). Enabled query params
 are folded into the URL; a Content-Type header is added for the body type
 unless the request already sets one. */
@@ -91,27 +106,31 @@ fun toCurl(inReq: ApiRequest): String {
         if (inReq.certPassword.isNotEmpty()) vSb.append(" \\\n  --pass ").append(shellQuote(inReq.certPassword))
     }
 
-    if (inReq.method.allowsBody && inReq.bodyType != BodyType.NONE) {
+    if (true && inReq.bodyType != BodyType.NONE) {
         val vContentType = inReq.bodyContentType()
         val vHasCt = inReq.headers.any { it.enabled && it.key.equals("content-type", ignoreCase = true) }
         if (vContentType != null && !vHasCt) {
             vSb.append(" \\\n  -H ").append(shellQuote("Content-Type: $vContentType"))
         }
         when (inReq.bodyType) {
-            BodyType.FORM -> if (inReq.form.any { it.enabled && it.key.isNotBlank() }) vSb.append(" \\\n  --data ").append(shellQuote(formEncode(inReq.form)))
-            BodyType.FILE -> if (inReq.body.isNotBlank()) vSb.append(" \\\n  --data-binary ").append(shellQuote("@${inReq.body}"))
+            BodyType.FORM -> if (inReq.form.any { it.enabled && it.key.isNotBlank() }) vSb.append(" \\\n  --data ")
+                .append(shellQuote(formEncode(inReq.form)))
+
+            BodyType.FILE -> if (inReq.body.isNotBlank()) vSb.append(" \\\n  --data-binary ")
+                .append(shellQuote("@${inReq.body}"))
+
             else -> if (inReq.body.isNotEmpty()) vSb.append(" \\\n  --data ").append(shellQuote(inReq.body))
         }
     }
     return vSb.toString()
 }
 
-/* URL-encode enabled form fields into an application/x-www-form-urlencoded body. */
+/** URL-encode enabled form fields into an application/x-www-form-urlencoded body. */
 fun formEncode(inForm: List<KeyVal>): String =
     inForm.filter { it.enabled && it.key.isNotBlank() }
         .joinToString("&") { "${urlEncode(it.key)}=${urlEncode(it.value)}" }
 
-/* The request URL with its enabled query params appended (percent-encoded). */
+/** The request URL with its enabled query params appended (percent-encoded). */
 internal fun urlWithParams(inReq: ApiRequest): String {
     val vTrimmed = inReq.url.trim()
     val vEnabled = inReq.params.filter { it.enabled && it.key.isNotBlank() }
@@ -121,10 +140,10 @@ internal fun urlWithParams(inReq: ApiRequest): String {
     return vTrimmed + vSep + vQuery
 }
 
-/* Single-quote a string for a POSIX shell, escaping any embedded quotes. */
+/** Single-quote a string for a POSIX shell, escaping any embedded quotes. */
 private fun shellQuote(inS: String): String = "'" + inS.replace("'", "'\\''") + "'"
 
-/* Minimal RFC-3986 percent-encoding for query keys / values. */
+/** Minimal RFC-3986 percent-encoding for query keys / values. */
 private fun urlEncode(inS: String): String = buildString {
     for (vByte in inS.encodeToByteArray()) {
         val vCode = vByte.toInt() and 0xFF

apidemo/src/commonMain/kotlin/UiAtoms.kt

@@ -30,12 +30,12 @@ import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
 // MARK: Small UI atoms (shared across panels / dialogs / sidebar)
 // ==================
 
-/* Method as a compact rounded badge (soft colour fill + coloured label), fixed
+/** Method as a compact rounded badge (soft colour fill + coloured label), fixed
 width so request names line up. */
 @Composable
 internal fun MethodTag(inMethod: ReqMethod) {
     val vCol = methodColor(inMethod)
-    // No background — just the coloured method name, fixed width so the request
+    // No background - just the coloured method name, fixed width so the request
     // names still line up in the sidebar list.
     Box(
         modifier = Modifier.width(46.dp).padding(vertical = 2.dp),
@@ -45,7 +45,7 @@ internal fun MethodTag(inMethod: ReqMethod) {
     }
 }
 
-/* Thin horizontal accent line showing where a dragged request row will drop
+/** Thin horizontal accent line showing where a dragged request row will drop
 (the open-tab strip uses the vertical DropBar). */
 @Composable
 internal fun RowDropBar() {
@@ -53,7 +53,7 @@ internal fun RowDropBar() {
     Box(modifier = Modifier.fillMaxWidth().height(2.dp).background(c.accent, RoundedCornerShape(1.dp)))
 }
 
-/* Tab indices listed in inDots get a small accent dot after their label — used
+/** Tab indices listed in inDots get a small accent dot after their label - used
 to flag a tab that holds content (e.g. a non-empty request body). */
 @Composable
 internal fun TabBar(inTabs: List<String>, inSelected: Int, inDots: Set<Int> = emptySet(), inOnSelect: (Int) -> Unit) {
@@ -90,10 +90,17 @@ internal fun TogglePill(inLabel: String, inSelected: Boolean, inOnClick: () -> U
     ) { Text(inLabel, color = if (inSelected) c.onAccent else c.dim, fontSize = 12.sp) }
 }
 
-/* Compact single-line (or fixed-height multi-line) input — a BasicTextField in
+/** Compact single-line (or fixed-height multi-line) input - a BasicTextField in
 a slim bordered box, much shorter than the 56 dp Material OutlinedTextField. */
 @Composable
-internal fun ThinField(inValue: String, inOnChange: (String) -> Unit, inModifier: Modifier = Modifier, inPlaceholder: String = "", inSingleLine: Boolean = true, inOnEnter: (() -> Unit)? = null) {
+internal fun ThinField(
+    inValue: String,
+    inOnChange: (String) -> Unit,
+    inModifier: Modifier = Modifier,
+    inPlaceholder: String = "",
+    inSingleLine: Boolean = true,
+    inOnEnter: (() -> Unit)? = null
+) {
     val c = LocalAppColors.current
     // Box is an ancestor of the field, so it sees Enter the single-line field
     // leaves unconsumed (it propagates up the focus → root chain).
@@ -102,7 +109,9 @@ internal fun ThinField(inValue: String, inOnChange: (String) -> Unit, inModifier
         .border(1.dp, c.border, RoundedCornerShape(6.dp))
         .padding(horizontal = 10.dp, vertical = 9.dp)
     if (inOnEnter != null) vBoxMod = vBoxMod.onKeyEvent { ev ->
-        if (ev.type == KeyEventType.KeyDown && (ev.key == Key.Enter || ev.key == Key.NumPadEnter)) { inOnEnter(); true } else false
+        if (ev.type == KeyEventType.KeyDown && (ev.key == Key.Enter || ev.key == Key.NumPadEnter)) {
+            inOnEnter(); true
+        } else false
     }
     Box(
         modifier = vBoxMod,
@@ -128,10 +137,17 @@ internal fun ThinField(inValue: String, inOnChange: (String) -> Unit, inModifier
     }
 }
 
-/* Small icon-only button (burger / pack / options / save / close). inPadding
+/** Small icon-only button (burger / pack / options / save / close). inPadding
 tightens the tap area for slimmer rows. */
 @Composable
-internal fun IconBtn(inIcon: Int, inDesc: String, inModifier: Modifier = Modifier, inSize: Dp = 18.dp, inPadding: Dp = 6.dp, inOnClick: () -> Unit) {
+internal fun IconBtn(
+    inIcon: Int,
+    inDesc: String,
+    inModifier: Modifier = Modifier,
+    inSize: Dp = 18.dp,
+    inPadding: Dp = 6.dp,
+    inOnClick: () -> Unit
+) {
     val c = LocalAppColors.current
     val vHoverSrc = remember { MutableInteractionSource() }
     val vHover by vHoverSrc.collectIsHoveredAsState()
@@ -152,16 +168,16 @@ internal fun IconBtn(inIcon: Int, inDesc: String, inModifier: Modifier = Modifie
     }
 }
 
-/* Outlined icon+label action (New request / Add row / pack actions). */
+/** Outlined icon+label action (New request / Add row / pack actions). */
 @Composable
 internal fun OutlinedAction(inIcon: Int, inLabel: String, inOnClick: () -> Unit) {
     val c = LocalAppColors.current
     OutlinedButton(onClick = inOnClick) { BtnContent(inIcon, inLabel, c.accent) }
 }
 
-/* Filled red icon+label button for destructive / stop actions (delete, cancel, quit).
+/** Filled red icon+label button for destructive / stop actions (delete, cancel, quit).
 Uses the m3 Button so its size + ripple + interaction match every other
-   Button in the app — previously handrolled Box + background + clickable + padding
+Button in the app - previously handrolled Box + background + clickable + padding
 gave it a different height / horizontal padding, and the Discard button sat
 next to a Button ("Save first…") looking noticeably smaller in dialogs. */
 @Composable
@@ -173,17 +189,7 @@ internal fun DangerButton(inLabel: String, inIcon: Int, inOnClick: () -> Unit) {
     ) { BtnContent(inIcon, inLabel, Color.White) }
 }
 
-/* Bordered icon+label chip (Copy / Save as / Cancel). */
-@Composable
-internal fun IconLabelChip(inIcon: Int, inLabel: String, inOnClick: () -> Unit) {
-    val c = LocalAppColors.current
-    Box(
-        modifier = Modifier.clip(RoundedCornerShape(6.dp)).border(1.dp, c.border, RoundedCornerShape(6.dp))
-            .clickable(onClick = inOnClick).padding(horizontal = 8.dp, vertical = 5.dp),
-    ) { BtnContent(inIcon, inLabel, c.dim, 14.dp) }
-}
-
-/* Icon + label row used inside buttons. */
+/** Icon + label row used inside buttons. */
 @Composable
 internal fun BtnContent(inIcon: Int, inLabel: String, inColor: Color, inSize: Dp = 16.dp) {
     Row(horizontalArrangement = Arrangement.spacedBy(6.dp), verticalAlignment = Alignment.CenterVertically) {

apidemo/src/commonMain/kotlin/ViewerPanel.kt

@@ -29,7 +29,6 @@ import androidx.compose.ui.input.pointer.isShiftPressed
 import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.layout.ContentScale
 import androidx.compose.ui.layout.onSizeChanged
-import androidx.compose.ui.platform.ClipEntry
 import androidx.compose.ui.platform.LocalClipboard
 import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.text.*
@@ -37,23 +36,18 @@ import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
+import apidemo.compat.*
+import apidemo.compat.ScrollbarStyle
+import apidemo.compat.rememberScrollbarAdapter
 import com.compose.sdl.icons.MaterialSymbols
 import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
-import com.compose.sdl.removeMemoryResource
-import com.compose.sdl.res.ResourceKind
-import com.compose.sdl.res.painterResource
-import com.compose.sdl.scrollbar.ScrollbarStyle
-import com.compose.sdl.scrollbar.VerticalScrollbar
-import com.compose.sdl.scrollbar.rememberScrollbarAdapter
-import com.compose.sdl.showSaveFileDialog
-import com.compose.sdl.text.currentTextMeasurer
 import kotlinx.coroutines.launch
 
 // ==================
 // MARK: Response
 // ==================
 
-/* Panel 4 — Request / Response viewer. Each tab stacks a HEADERS section over a
+/** Panel 4 - Request / Response viewer. Each tab stacks a HEADERS section over a
 BODY section. "Request" shows the resolved request that would be sent (the
 Preview); "Response" shows the result (image-aware). A copy / save toolbar
 acts on whichever view is showing. */
@@ -67,7 +61,7 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
     val vPreview = inRs.preview
     val vShowRequest = vPreview || inRs.viewTab == 0
 
-    // Pretty-print once per received body (not every recomposition) — the whole
+    // Pretty-print once per received body (not every recomposition) - the whole
     // body is shown; the renderer line-culls + wrap-caches so even a 20k-line
     // payload stays cheap. (Previously capped at 20000 chars, which silently cut
     // long responses off around line ~1100.)
@@ -93,9 +87,9 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                     Text("PREVIEW", color = c.accent, fontSize = 13.sp)
                 }
                 Spacer(Modifier.weight(1f))
-                Text("not sent", color = kWarnColor, fontSize = 11.sp)
+                Text("not sent", color = VolticTheme.extended.warning, fontSize = 11.sp)
             } else {
-                // Request tab — adds the coloured method only once the
+                // Request tab - adds the coloured method only once the
                 // request has actually been sent (sentReq != null).
                 val vSent = inRs.sentReq
                 ViewerTab(
@@ -105,7 +99,7 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                     inSelected = inRs.viewTab == 0,
                     inOnClick = { inRs.viewTab = 0 },
                 )
-                // Response tab — adds the coloured status only when a
+                // Response tab - adds the coloured status only when a
                 // response (or error) is in. No placeholder during the
                 // pre-send / loading state.
                 val (vRespAccent, vRespColor) = when {
@@ -121,7 +115,7 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                     inOnClick = { inRs.viewTab = 1 },
                 )
                 Spacer(Modifier.weight(1f))
-                // Spinner only — the Cancel control already lives next to
+                // Spinner only - the Cancel control already lives next to
                 // Send in the URL bar; no need for a duplicate here.
                 if (inRs.viewTab == 1 && vLoading) {
                     CircularProgressIndicator(modifier = Modifier.size(14.dp), color = c.accent, strokeWidth = 2.dp)
@@ -137,12 +131,14 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                 vShowRequest && vReqShown == null -> ViewerEmpty(MaterialSymbols.Send, "Not sent")
                 vShowRequest -> {
                     val vR = vReqShown!!
-                    val vSentHeaders = if (!vPreview) inRs.response?.requestHeaders?.takeIf { it.isNotEmpty() } else null
+                    val vSentHeaders =
+                        if (!vPreview) inRs.response?.requestHeaders?.takeIf { it.isNotEmpty() } else null
                     // Synthesize wire-level headers (Host, Content-Length, User-Agent)
-                    // the engine adds without telling Ktor — same set httpie shows.
-                    val vRawHeaders = if (vSentHeaders != null) vSentHeaders else parseHeaderLines(requestHeadersText(vR))
+                    // the engine adds without telling Ktor - same set httpie shows.
+                    val vRawHeaders =
+                        if (vSentHeaders != null) vSentHeaders else parseHeaderLines(requestHeadersText(vR))
                     val vHeaders = synthesizeRequestHeaders(vR, vRawHeaders)
-                    val vBody = if (!vR.method.allowsBody || vR.bodyType == BodyType.NONE) null else requestBodyText(vR)
+                    val vBody = if (!true || vR.bodyType == BodyType.NONE) null else requestBodyText(vR)
                     HttpFlowView(
                         inStatusLine = formatRequestLine(vR, inRs.response?.httpVersion ?: "HTTP/1.1", c),
                         inStatusLineAccentColor = methodColor(vR.method),
@@ -156,6 +152,7 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                         inSoftWrap = inRs.bodyWrap,
                     )
                 }
+
                 vResp == null && !vLoading -> ViewerEmpty(MaterialSymbols.Download, "Not received")
                 else -> {
                     val vHeaders = vResp?.headers ?: emptyList()
@@ -169,8 +166,8 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                         inBody = if (vRespImage) null else vBody,
                         inIsImage = vRespImage && !vLoading,
                         inImagePainter = if (vRespImage && !vLoading) {
-                            val vKind = if (vResp?.contentType?.contains("svg", ignoreCase = true) == true) ResourceKind.Svg else ResourceKind.Raster
-                            painterResource(inRs.imageKey!!, vKind)
+                            val vSvg = vResp.contentType?.contains("svg", ignoreCase = true) == true
+                            memoryImagePainter(inRs.imageKey!!, vSvg)
                         } else null,
                         inHeadersCollapsed = vHeadersCollapsed,
                         inOnToggleCollapse = { vHeadersCollapsed = !vHeadersCollapsed },
@@ -196,7 +193,7 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
             ) {
                 // Response viewer: format selector for the body. Auto-detected
                 // from Content-Type until the user overrides, then pinned.
-                if (vRespHasContent && vResp != null && !vRespImage) {
+                if (vRespHasContent && !vRespImage) {
                     val vAuto = autoFormatFor(vResp.contentType)
                     val vCurrent = inRs.respFormatOverride ?: vAuto
                     BodyFormatSelector(
@@ -207,10 +204,10 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                         inAutoLabel = if (inRs.respFormatOverride == null) vAuto.label else null,
                     )
                 }
-                // Wrap toggle — soft-wrap long lines (default) vs. no wrap +
+                // Wrap toggle - soft-wrap long lines (default) vs. no wrap +
                 // horizontal scroll (one source line per row). Shown for any text
                 // body (request preview or response), hidden for an image.
-                val vHasTextBody = (vRespHasContent && vResp != null && !vRespImage) || vReqHasContent
+                val vHasTextBody = (vRespHasContent && !vRespImage) || vReqHasContent
                 if (vHasTextBody) {
                     val vWrapOn = inRs.bodyWrap
                     Box(
@@ -234,7 +231,7 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                 }
                 vMsg?.let { Text(it, color = c.dim, fontSize = 11.sp) }
                 Spacer(Modifier.weight(1f))
-                if (vRespHasContent && vResp != null && vResp.error == null) {
+                if (vRespHasContent && vResp.error == null) {
                     Text(formatTimingSize(vResp), color = c.dim, fontSize = 11.sp)
                     Spacer(Modifier.width(8.dp))
                 }
@@ -247,7 +244,7 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
                     inResponseBody = vRespBody,
                     inOnMessage = { vMsg = it },
                     inOnClear = {
-                        inRs.imageKey?.let { removeMemoryResource(it) }
+                        inRs.imageKey?.let { removeMemoryImage(it) }
                         inRs.imageKey = null
                         inRs.response = null
                         inRs.sentReq = null
@@ -260,10 +257,10 @@ internal fun ViewerPanel(inRs: ReqState, inResolved: ApiRequest) {
 }
 
 // ==================
-// MARK: HttpFlowView — flat httpie-style request/response layout
+// MARK: HttpFlowView - flat httpie-style request/response layout
 // ==================
 
-/* Renders the body of a Request or Response tab in a httpie-flavoured
+/** Renders the body of a Request or Response tab in a httpie-flavoured
 layout: status line (with collapse arrow) + headers table + raw body
 inline, no card / rounded-rect chrome around each section. The
 headers section can be collapsed via the arrow. */
@@ -283,12 +280,12 @@ internal fun HttpFlowView(
 ) {
     val c = LocalAppColors.current
     val vState = rememberLazyListState()
-    // Editor-style selection state — anchor + caret in absolute character offsets
+    // Editor-style selection state - anchor + caret in absolute character offsets
     // into inBody. Resets when the body changes so a stale range never highlights
     // a shorter/different response. Lives outside any SelectionContainer so it
     // survives scroll and spans off-screen chunks (see the BodySel comment).
     var vSel: BodySel? by remember(inBody) { mutableStateOf(null) }
-    // Selection background from the app theme — same colour that
+    // Selection background from the app theme - same colour that
     // LocalTextSelectionColors publishes to Compose text selection elsewhere.
     val vSelColor = LocalTextSelectionColors.current.backgroundColor
     val vFocus = remember { FocusRequester() }
@@ -300,12 +297,12 @@ internal fun HttpFlowView(
     // auto-scroll effect that scrolls the LazyColumn while the pointer sits in
     // the top / bottom edge zone.
     var vDragPos: Offset? by remember { mutableStateOf(null) }
-    // The body is highlighted ONCE, then sliced into BLOCKS of lines — one BasicText
+    // The body is highlighted ONCE, then sliced into BLOCKS of lines - one BasicText
     // per block, NOT one per line. Far fewer nodes / selectables / paragraph set-ups
     // churn through the viewport while scrolling (the smoothness win), and the
     // O(total-spans) AnnotatedString.subSequence runs once per block at build time
     // (memoised) instead of per visible line every frame. LazyColumn still virtualizes,
-    // so only the ~2-3 on-screen blocks are composed/measured — 12k lines stay cheap.
+    // so only the ~2-3 on-screen blocks are composed/measured - 12k lines stay cheap.
     val vDark = isDarkBg(c.bg)
     val vChunks = remember(inBody, inBodyFormat, vDark) {
         if (inBody == null) emptyList()
@@ -318,26 +315,31 @@ internal fun HttpFlowView(
     // Per-visible-chunk TextLayoutResult, keyed by chunk index. Populated as each
     // BodyChunkRow's BasicText lays out, dropped implicitly when the chunks list
     // changes (new response) via the remember key. Off-screen chunks aren't in
-    // this map — we can't hit-test them via mouse either since they're not painted.
+    // this map - we can't hit-test them via mouse either since they're not painted.
     val vChunkLayouts = remember(vChunks) { mutableStateMapOf<Int, TextLayoutResult>() }
     val vTotalLines = remember(inBody) { if (inBody == null) 0 else inBody.count { it == '\n' } + 1 }
     // No-wrap mode pans horizontally; every block shares this one scroll state so the
-    // whole body pans together (the gutter stays pinned — not scrolled).
+    // whole body pans together (the gutter stays pinned - not scrolled).
     val vHScroll = rememberScrollState()
     val vGutterWidth = (vTotalLines.coerceAtLeast(1).toString().length * 7 + 4).dp
     // Per-line styles hoisted once (not allocated per line per frame). The rows use
-    // BasicText with these fixed styles instead of material3 Text — no per-node
-    // LocalTextStyle merge / LocalContentColor read — which is the main scroll-
+    // BasicText with these fixed styles instead of material3 Text - no per-node
+    // LocalTextStyle merge / LocalContentColor read - which is the main scroll-
     // smoothness win when thousands of line items churn through the viewport.
     val vBodyStyle = remember(c.text) { TextStyle(color = c.text, fontSize = 12.sp, fontFamily = monoFontFamily) }
     val vNumStyle = remember(c.dim) {
-        TextStyle(color = c.dim.copy(alpha = 0.45f), fontSize = 12.sp, fontFamily = monoFontFamily, textAlign = TextAlign.End)
+        TextStyle(
+            color = c.dim.copy(alpha = 0.45f),
+            fontSize = 12.sp,
+            fontFamily = monoFontFamily,
+            textAlign = TextAlign.End
+        )
     }
 
     // Body-relative x offset (px) of the block's BasicText inside the outer Box.
     // Mirrors BodyChunkRow's layout: 4dp Row start padding + gutter width + 6dp spacer.
     val vTextStartPx = with(density) { (4.dp + vGutterWidth + 6.dp).toPx() }
-    // LazyColumn item index of chunk index 0 — status row + optional header
+    // LazyColumn item index of chunk index 0 - status row + optional header
     // table + divider. Used to scroll a specific chunk into view when the caret
     // moves off-screen via keyboard. Only stable while we're on the "have body"
     // branch, but that's the only branch that renders chunks in the first place.
@@ -356,7 +358,7 @@ internal fun HttpFlowView(
         if (!vVisible) vScope.launch { vState.scrollToItem(vChunkItemOffset + vCi) }
     }
 
-    // Hit-test — turns a pointer position (outer Box local frame) into a global
+    // Hit-test - turns a pointer position (outer Box local frame) into a global
     // character offset into inBody, or null if the pointer isn't over any chunk.
     // Clamps past-viewport pointers to the nearest visible chunk boundary so a
     // drag that overshoots still keeps extending toward that end.
@@ -385,14 +387,14 @@ internal fun HttpFlowView(
     // Drag auto-scroll: while a drag is in progress (vDragPos != null), tick
     // every frame and scroll the LazyColumn when the pointer sits in a 40dp
     // edge zone at the top / bottom. Speed ramps linearly with depth into the
-    // zone up to 24dp per frame — roughly a page per second at 60fps at max
+    // zone up to 24dp per frame - roughly a page per second at 60fps at max
     // depth. After each scroll we re-hit-test the current pointer position so
     // the selection keeps extending onto the newly revealed chunks.
     val vEdgePx = with(density) { 40.dp.toPx() }
     val vMaxScrollPx = with(density) { 24.dp.toPx() }
     LaunchedEffect(Unit) {
         while (true) {
-            androidx.compose.runtime.withFrameNanos { }
+            withFrameNanos { }
             val vPos = vDragPos ?: continue
             val vVpH = vState.layoutInfo.viewportSize.height.toFloat()
             val vDelta = when {
@@ -410,7 +412,7 @@ internal fun HttpFlowView(
 
     // contentAlignment pins the narrow scrollbar to the right edge; the
     // fillMaxSize content fills the rest (this project's Box has no BoxScope, so
-    // there's no Modifier.align — alignment is via contentAlignment).
+    // there's no Modifier.align - alignment is via contentAlignment).
     Box(
         modifier = Modifier
             .fillMaxSize()
@@ -419,7 +421,7 @@ internal fun HttpFlowView(
             // Mouse: press starts a selection, drag extends it, Shift+press extends
             // from the existing anchor. We drive this by hand instead of going
             // through SelectionContainer because SC only sees composed selectables
-            // (visible chunks) — Ctrl+A and Shift+Arrow can't reach off-screen text
+            // (visible chunks) - Ctrl+A and Shift+Arrow can't reach off-screen text
             // through it. Header items above the chunks stay non-selectable, which
             // matches the previous DisableSelection wrappers.
             .pointerInput(vChunks) {
@@ -435,7 +437,7 @@ internal fun HttpFlowView(
                         val vDown = awaitPointerEvent()
                         if (vDown.type != PointerEventType.Press) continue
                         val vChange = vDown.changes.firstOrNull() ?: continue
-                        // Skip presses a child already handled — most importantly the
+                        // Skip presses a child already handled - most importantly the
                         // VerticalScrollbar sibling in this Box. Without this, dragging
                         // the scrollbar would also start (and continuously extend) a
                         // body selection because my hit-test still finds a chunk under
@@ -463,10 +465,12 @@ internal fun HttpFlowView(
                                 val vR = wordRangeAt(vBody, vOffset)
                                 BodySel(anchor = vR.first, caret = vR.last)
                             }
+
                             vPressCount >= 3 -> BodySel(
                                 anchor = lineStartAt(vBody, vOffset),
                                 caret = lineEndAt(vBody, vOffset),
                             )
+
                             else -> BodySel(anchor = vOffset, caret = vOffset)
                         }
                         vChange.consume()
@@ -504,47 +508,58 @@ internal fun HttpFlowView(
                     vMod && ev.key == Key.A -> {
                         vSel = BodySel(0, vBody.length); true
                     }
+
                     vMod && ev.key == Key.C -> {
                         val vS = vSel
                         if (vS != null && !vS.isEmpty) {
                             val vText = vBody.substring(vS.start, vS.end)
-                            vScope.launch { vClipboard.setClipEntry(ClipEntry.withPlainText(vText)) }
+                            vScope.launch { vClipboard.setClipEntry(clipEntryOfText(vText)) }
                             true
                         } else false
                     }
+
                     ev.key == Key.Escape -> {
-                        if (vSel != null) { vSel = null; true } else false
+                        if (vSel != null) {
+                            vSel = null; true
+                        } else false
                     }
+
                     vShift && ev.key == Key.DirectionRight -> {
                         val vCur = vSel ?: BodySel(0, 0)
                         vSel = vCur.copy(caret = (vCur.caret + 1).coerceAtMost(vBody.length))
                         vScrollCaretIntoView(); true
                     }
+
                     vShift && ev.key == Key.DirectionLeft -> {
                         val vCur = vSel ?: BodySel(0, 0)
                         vSel = vCur.copy(caret = (vCur.caret - 1).coerceAtLeast(0))
                         vScrollCaretIntoView(); true
                     }
+
                     vShift && ev.key == Key.DirectionDown -> {
                         val vCur = vSel ?: BodySel(0, 0)
                         vSel = vCur.copy(caret = moveDown(vBody, vCur.caret))
                         vScrollCaretIntoView(); true
                     }
+
                     vShift && ev.key == Key.DirectionUp -> {
                         val vCur = vSel ?: BodySel(0, 0)
                         vSel = vCur.copy(caret = moveUp(vBody, vCur.caret))
                         vScrollCaretIntoView(); true
                     }
+
                     vShift && ev.key == Key.MoveHome -> {
                         val vCur = vSel ?: BodySel(0, 0)
                         vSel = vCur.copy(caret = if (vMod) 0 else lineStartAt(vBody, vCur.caret))
                         vScrollCaretIntoView(); true
                     }
+
                     vShift && ev.key == Key.MoveEnd -> {
                         val vCur = vSel ?: BodySel(0, 0)
                         vSel = vCur.copy(caret = if (vMod) vBody.length else lineEndAt(vBody, vCur.caret))
                         vScrollCaretIntoView(); true
                     }
+
                     else -> false
                 }
             },
@@ -569,7 +584,7 @@ internal fun HttpFlowView(
                     if (inShowSecureLock) {
                         MaterialSymbolsOutlined(
                             icon = MaterialSymbols.Lock,
-                            tint = Color(0xFF36B37E),  // green — TLS verified by OS
+                            tint = Color(0xFF36B37E),  // green - TLS verified by OS
                             size = 14.dp,
                         )
                         Spacer(Modifier.width(6.dp))
@@ -577,7 +592,7 @@ internal fun HttpFlowView(
                     Text(inStatusLine, color = c.text, fontSize = 13.sp)
                 }
             }
-            // Headers as a key/value table — only when not collapsed.
+            // Headers as a key/value table - only when not collapsed.
             if (!inHeadersCollapsed && inHeaders.isNotEmpty()) {
                 item {
                     HeaderTable(inHeaders, modifier = Modifier.padding(horizontal = 12.dp, vertical = 4.dp))
@@ -596,7 +611,7 @@ internal fun HttpFlowView(
                         }
                     }
                 } else if (vChunks.isNotEmpty()) {
-                    // One BasicText per BLOCK of lines (not per line) — far fewer
+                    // One BasicText per BLOCK of lines (not per line) - far fewer
                     // nodes to churn while scrolling. Chunk key lets the pointer
                     // hit-test map a visible item back to its chunk index.
                     items(vChunks.size, key = { "chunk_$it" }, contentType = { "chunk" }) { vCi ->
@@ -637,13 +652,13 @@ internal fun HttpFlowView(
 // MARK: Body selection (editor-style, spans virtualized chunks)
 // ==================
 
-/* A response body's selection is a pair of character offsets in the whole body
+/** A response body's selection is a pair of character offsets in the whole body
 string: [anchor] is where the user pressed / started the selection, [caret] is
 where they've moved to. When they differ, the selected range is [ min..max ].
 When equal, it's a zero-width caret still useful as a starting point for
 subsequent Shift+Arrow / Shift+Click extensions.
 
-   Note this lives OUTSIDE the SelectionContainer machinery — that machinery only
+Note this lives OUTSIDE the SelectionContainer machinery - that machinery only
 tracks selectables composed by the LazyColumn (visible chunks), which is why
 Ctrl+A and drag-select cannot reach off-screen text through it. This state is
 plain integer offsets so it survives scroll and covers the whole body. */
@@ -653,7 +668,7 @@ private data class BodySel(val anchor: Int, val caret: Int) {
     val isEmpty get() = anchor == caret
 }
 
-/* Character offset of the start of the line containing [inOffset]. */
+/** Character offset of the start of the line containing [inOffset]. */
 private fun lineStartAt(inText: String, inOffset: Int): Int {
     if (inOffset <= 0) return 0
     val vClamped = inOffset.coerceAtMost(inText.length)
@@ -661,7 +676,7 @@ private fun lineStartAt(inText: String, inOffset: Int): Int {
     return if (vPrev < 0) 0 else vPrev + 1
 }
 
-/* Character offset of the end of the line containing [inOffset] — the position of
+/** Character offset of the end of the line containing [inOffset] - the position of
 its '\n', or the length of [inText] if this is the last line. */
 private fun lineEndAt(inText: String, inOffset: Int): Int {
     val vClamped = inOffset.coerceIn(0, inText.length)
@@ -669,7 +684,7 @@ private fun lineEndAt(inText: String, inOffset: Int): Int {
     return if (vNext < 0) inText.length else vNext
 }
 
-/* Move a caret one visual "row" down while trying to keep its column — i.e. the
+/** Move a caret one visual "row" down while trying to keep its column - i.e. the
 number of chars past the current line's start. If the target line is shorter,
 the caret snaps to its end. Off-by-one at EOF collapses to the body length. */
 private fun moveDown(inText: String, inOffset: Int): Int {
@@ -682,7 +697,7 @@ private fun moveDown(inText: String, inOffset: Int): Int {
     return (vNextStart + vCol).coerceAtMost(vNextEnd)
 }
 
-/* The Up counterpart to [moveDown]. */
+/** The Up counterpart to [moveDown]. */
 private fun moveUp(inText: String, inOffset: Int): Int {
     val vLineStart = lineStartAt(inText, inOffset)
     if (vLineStart == 0) return 0
@@ -692,7 +707,7 @@ private fun moveUp(inText: String, inOffset: Int): Int {
     return (vPrevStart + vCol).coerceAtMost(vPrevEnd)
 }
 
-/* Word boundary rule for double-click selection: contiguous run of "word chars"
+/** Word boundary rule for double-click selection: contiguous run of "word chars"
 (letters, digits, underscore) containing [inOffset], or an empty range at the
 click point when it lands on non-word text (whitespace, punctuation). Matches
 the boundary editors like VS Code / IntelliJ use for double-click select. */
@@ -712,8 +727,8 @@ private fun wordRangeAt(inText: String, inOffset: Int): IntRange {
     return vStart..vEnd
 }
 
-/* The index of the chunk in [inChunks] whose character range contains
-   [inOffset], or null when the body is empty. Uses a linear scan — the chunk
+/** The index of the chunk in [inChunks] whose character range contains
+[inOffset], or null when the body is empty. Uses a linear scan - the chunk
 count is O(body / kLinesPerChunk) which stays modest even for huge bodies. */
 private fun chunkContaining(inChunks: List<BodyChunk>, inOffset: Int): Int? {
     if (inChunks.isEmpty()) return null
@@ -729,7 +744,7 @@ private fun chunkContaining(inChunks: List<BodyChunk>, inOffset: Int): Int? {
 // measure at the viewport edges, large enough to slash node/selectable count.
 private const val kLinesPerChunk = 48
 
-/* One BLOCK of a read-only body: a right-aligned column of line numbers in the
+/** One BLOCK of a read-only body: a right-aligned column of line numbers in the
 gutter + the block's (syntax-coloured) text, each a single BasicText. Rendering
 blocks (not one-BasicText-per-line) keeps the node / selectable / paragraph-set-up
 count low as blocks scroll through the viewport. The gutter is pinned outside
@@ -776,7 +791,7 @@ private fun BodyChunkRow(
     // Precompute this block's slice of the selection in LOCAL offsets. `null`
     // when the selection is empty or doesn't touch this block. Also computes the
     // caret's local offset when the caret itself falls inside this block (drawn
-    // even when the range is empty — that's the read-only viewer's cursor).
+    // even when the range is empty - that's the read-only viewer's cursor).
     val vChunkStart = inChunk.startCharOffset
     val vChunkEnd = vChunkStart + inChunk.body.length
     val vLocalRange: IntRange? = if (inSel == null || inSel.isEmpty) null else {
@@ -830,7 +845,8 @@ private fun BodyChunkRow(
                         vSb.append(inChunk.firstLine + j)
                         if (vLen > 0) {
                             val vStart = inChunk.lineStartsInBlock[j].coerceIn(0, vMaxOff)
-                            val vEnd = (if (j + 1 < inChunk.lineCount) inChunk.lineStartsInBlock[j + 1] - 1 else vMaxOff)
+                            val vEnd =
+                                (if (j + 1 < inChunk.lineCount) inChunk.lineStartsInBlock[j + 1] - 1 else vMaxOff)
                                     .coerceIn(vStart, vMaxOff)
                             val vRows = layout.getLineForOffset(vEnd) - layout.getLineForOffset(vStart) + 1
                             repeat((vRows - 1).coerceAtLeast(0)) { vSb.append('\n') }
@@ -855,7 +871,7 @@ private fun BodyChunkRow(
     }
 }
 
-/* A block of consecutive source lines: 1-based number of the first line, the line
+/** A block of consecutive source lines: 1-based number of the first line, the line
 count, each source line's start offset WITHIN the block text (to map a wrapped body
 layout back to line numbers), the character offset of the block's first char in the
 full body (used to map local text offsets to global ones for cross-chunk selection),
@@ -868,9 +884,9 @@ private class BodyChunk(
     val body: AnnotatedString,
 )
 
-/* Slice a highlighted body into blocks of [inLinesPerChunk] lines. The O(total-spans)
+/** Slice a highlighted body into blocks of [inLinesPerChunk] lines. The O(total-spans)
 subSequence runs once per block HERE (build time, memoised) instead of once per
-   visible line every frame — the difference between smooth and janky on a big body. */
+visible line every frame - the difference between smooth and janky on a big body. */
 private fun buildBodyChunks(inText: String, inAnn: AnnotatedString, inLinesPerChunk: Int): List<BodyChunk> {
     val vStarts = lineStartOffsets(inText)
     val vN = vStarts.size
@@ -890,9 +906,9 @@ private fun buildBodyChunks(inText: String, inAnn: AnnotatedString, inLinesPerCh
     return vOut
 }
 
-/* Offsets where each source line starts (line i spans [starts[i], starts[i+1]-1),
+/** Offsets where each source line starts (line i spans [starts[ i], starts[i+1]-1),
 the -1 dropping the '\n'; the last line runs to the string end). One cheap O(n)
-   scan, memoised — replaces the old gutter pre-pass that ran measurer.wrap() on
+scan, memoised - replaces the old gutter pre-pass that measured wrapping on
 every one of N lines on each width change (the other half of the freeze). */
 private fun lineStartOffsets(inText: String): IntArray {
     val vStarts = ArrayList<Int>(64)
@@ -901,7 +917,7 @@ private fun lineStartOffsets(inText: String): IntArray {
     return vStarts.toIntArray()
 }
 
-/* Header table: each row is (key | value) where the key column has a
+/** Header table: each row is (key | value) where the key column has a
 fixed width so values line up. Long keys wrap; long values wrap too.
 Keys render in accent colour, values in regular text. */
 @Composable
@@ -927,7 +943,7 @@ internal fun HeaderTable(inHeaders: List<Pair<String, String>>, modifier: Modifi
     }
 }
 
-/* Body view with line numbers in the gutter — mimics the code panel
+/** Body view with line numbers in the gutter - mimics the code panel
 in httpie. Numbers are dim; body text uses the regular colour. */
 @Composable
 internal fun BodyView(
@@ -947,25 +963,25 @@ internal fun BodyView(
     val vGutterWidth = (vDigits * 7 + 4).dp
     // Body wrap width (physical px, from onSizeChanged), reported by the body
     // Box once it's laid out (0 on the first frame). The gutter numbering
-    // depends on it — see vNumbers. NativeTextMeasurer.wrap expects the font
+    // depends on it - see vNumbers. Wrap measurement expects the font
     // size + max-width in the SAME unit (both physical px on Retina), so we
-    // scale 12.sp through the current density here, matching what SdlParagraph
-    // does when it builds the body's real paragraph.
+    // scale 12.sp through the current density here, matching what the paragraph
+    // engine does when it builds the body's real paragraph.
     var vBodyWidthPx by remember { mutableStateOf(0) }
     val vFontPx = with(LocalDensity.current) { 12.sp.toPx().toInt() }
     // Horizontal scroll for no-wrap mode (read-only body only); dormant when wrapping.
     val vHScroll = rememberScrollState()
     Row(modifier = modifier) {
-        // Numbers are reference-only — half-alpha so they stay legible without
+        // Numbers are reference-only - half-alpha so they stay legible without
         // competing with the body. Rendered as ONE '\n'-joined multi-line Text
         // (not one Text per line): a 1000-line gutter is then a single node the
         // renderer line-culls + wrap-caches exactly like the body, instead of
-        // 1000 leaf nodes — which lagged and tripped SDL's ~16384px draw-
+        // 1000 leaf nodes - which lagged and tripped SDL's ~16384px draw-
         // coordinate limit (line numbers vanished past ~955).
         //
         // When the body soft-wraps, a source line can span several visual rows.
         // To keep the numbers aligned we emit each line's number once (on its
-        // first row) followed by one blank row per wrapped continuation — by
+        // first row) followed by one blank row per wrapped continuation - by
         // re-running the SAME wrap the body uses (same measurer, font, width),
         // so the gutter ends up with exactly as many rows as the body. Without
         // this, a line wrapping into 3 rows would read 10/11/12 instead of
@@ -974,18 +990,18 @@ internal fun BodyView(
         // also use it for the first frame, before the body reports its width).
         val vNumColor = c.dim.copy(alpha = 0.45f)
         val vNumbers = remember(inText, vBodyWidthPx, inSoftWrap, vFontPx) {
-            val vM = if (inSoftWrap && vBodyWidthPx > 0) currentTextMeasurer else null
+            val vWrapRows = inSoftWrap && vBodyWidthPx > 0
             buildString {
                 for ((vIdx, vSrc) in vLines.withIndex()) {
                     if (vIdx > 0) append('\n')
                     append(vIdx + 1)
-                    if (vM != null) {
+                    if (vWrapRows) {
                         // Pass the density-scaled font size so this wrap matches the body's
-                        // actual glyph pixel widths — passing 12 (sp) here counted each
+                        // actual glyph pixel widths - passing 12 (sp) here counted each
                         // char as half its rendered size, so long lines that visually
                         // wrapped into 3 rows in the body were estimated as 1 or 2 rows
                         // here and the gutter numbers drifted upward.
-                        val vRows = vM.wrap(vSrc, vFontPx, vBodyWidthPx, monoFontFamilyName).lines.size.coerceAtLeast(1)
+                        val vRows = wrappedRowCount(vSrc, vFontPx, vBodyWidthPx, monoFontFamilyName).coerceAtLeast(1)
                         repeat(vRows - 1) { append('\n') }
                     }
                 }
@@ -1008,7 +1024,8 @@ internal fun BodyView(
         // anywhere (not just on the text line) focuses it and starts writing.
         // Read-only (response) keeps wrap-height so it grows with content.
         val vEditable = inOnChange != null
-        Box(modifier = Modifier.weight(1f)
+        Box(
+            modifier = Modifier.weight(1f)
                 .onSizeChanged { vBodyWidthPx = it.width }
                 .then(if (vEditable) Modifier.fillMaxHeight() else Modifier)) {
             if (inText.isEmpty() && inPlaceholder.isNotEmpty()) {
@@ -1016,7 +1033,7 @@ internal fun BodyView(
             }
             if (inOnChange != null) {
                 // EDITABLE request body: BasicTextField with a colour-only
-                // syntax-highlight visualTransform — cursor / selection map to
+                // syntax-highlight visualTransform - cursor / selection map to
                 // the plain text. RAW = no highlight. Remembered per (format,
                 // theme) so typing and cursor-blink reuse it.
                 val vDark = isDarkBg(c.bg)
@@ -1031,7 +1048,7 @@ internal fun BodyView(
                         }
                     }
                 androidx.compose.runtime.CompositionLocalProvider(
-                    androidx.compose.foundation.text.selection.LocalTextSelectionColors provides
+                    LocalTextSelectionColors provides
                             androidx.compose.foundation.text.selection.TextSelectionColors(
                                 handleColor = c.accent,
                                 backgroundColor = c.accent.copy(alpha = 0.35f),
@@ -1040,7 +1057,7 @@ internal fun BodyView(
                     BasicTextField(
                         value = inText,
                         onValueChange = inOnChange,
-                        textStyle = androidx.compose.ui.text.TextStyle(
+                        textStyle = TextStyle(
                             color = c.text,
                             fontSize = 12.sp,
                             fontFamily = monoFontFamily,
@@ -1062,7 +1079,7 @@ internal fun BodyView(
                 }
                 SelectionContainer {
                     // No-wrap mode: one source line per row, long lines overflow
-                    // and the body pans horizontally (the gutter stays pinned —
+                    // and the body pans horizontally (the gutter stays pinned -
                     // it's outside this scroll). The scroll must sit on a PARENT
                     // of the Text: a node's own scroll offset shifts its children,
                     // not itself. Wrap mode: plain soft-wrapping Text.
@@ -1079,7 +1096,7 @@ internal fun BodyView(
     }
 }
 
-/* "Request" + colored "GET" tab. inAccent is shown next to the label
+/** "Request" + colored "GET" tab. inAccent is shown next to the label
 when non-null (e.g. method name once sent, status code once received);
 when null the tab is just the label, no placeholder dash. Selected
 tab gets full-strength labels and a 2dp underline; unselected tabs
@@ -1103,7 +1120,11 @@ internal fun ViewerTab(
         ) {
             Text(inLabel, color = if (inSelected) c.dim else c.dim.copy(alpha = 0.6f), fontSize = 14.sp)
             if (inAccent != null) {
-                Text(inAccent, color = if (inSelected) inAccentColor else inAccentColor.copy(alpha = 0.6f), fontSize = 14.sp)
+                Text(
+                    inAccent,
+                    color = if (inSelected) inAccentColor else inAccentColor.copy(alpha = 0.6f),
+                    fontSize = 14.sp
+                )
             }
         }
         Spacer(Modifier.height(4.dp))
@@ -1117,12 +1138,12 @@ internal fun ViewerTab(
 }
 
 // ==================
-// MARK: Helpers — header parsing / formatting
+// MARK: Helpers - header parsing / formatting
 // ==================
 
-/* "HTTP/1.1   200 OK" status line for a Response, with the protocol
+/** "HTTP/1.1   200 OK" status line for a Response, with the protocol
 token dimmed (it's structural) and the status code + reason in the
-   status colour. Just "HTTP/1.1" pre-response — no placeholder. Triple-
+status colour. Just "HTTP/1.1" pre-response - no placeholder. Triple-
 spaced to match the request-line formatting. */
 internal fun formatStatusLine(inResp: ApiResponse?, inColors: AppColors): AnnotatedString {
     if (inResp == null) return buildAnnotatedString {
@@ -1150,14 +1171,15 @@ internal fun formatStatusLine(inResp: ApiResponse?, inColors: AppColors): Annota
     }
 }
 
-/* "GET   /path   HTTP/1.1" status line for a Request. Each part takes
+/** "GET   /path   HTTP/1.1" status line for a Request. Each part takes
 its own colour: method in its canonical method colour, URL in the
 default text colour, protocol token dimmed so the eye lands on the
 request target first. Triple-spaced so the columns read at a glance.
 The protocol string comes from the matching response when we have
 one (so HTTP/2 servers show "HTTP/2"); fallback "HTTP/1.1" before
 send. */
-internal fun formatRequestLine(inReq: ApiRequest, inHttpVersion: String, inColors: AppColors): AnnotatedString = buildAnnotatedString {
+internal fun formatRequestLine(inReq: ApiRequest, inHttpVersion: String, inColors: AppColors): AnnotatedString =
+    buildAnnotatedString {
         pushStyle(SpanStyle(color = methodColor(inReq.method), fontWeight = FontWeight.Bold))
         append(inReq.method.name)
         pop()
@@ -1174,8 +1196,8 @@ internal fun formatRequestLine(inReq: ApiRequest, inHttpVersion: String, inColor
         pop()
     }
 
-/* Pull the path (+ query) out of a URL, dropping scheme + host. The
-   request line in HTTP is "METHOD path HTTP/x.y" — the host lives on a
+/** Pull the path (+ query) out of a URL, dropping scheme + host. The
+request line in HTTP is "METHOD path HTTP/x.y" - the host lives on a
 separate Host: header line, not in the path. Falls back to the input
 string when no "://" is present (relative URL). */
 internal fun urlPathOnly(inUrl: String): String {
@@ -1186,7 +1208,7 @@ internal fun urlPathOnly(inUrl: String): String {
     return if (vSlash < 0) "/" else vAfterScheme.substring(vSlash)
 }
 
-/* Extract the host (+ port) from a URL — used to synthesize a Host
+/** Extract the host (+ port) from a URL - used to synthesize a Host
 header for display when the engine didn't surface one. */
 internal fun urlHost(inUrl: String): String? {
     val vIdx = inUrl.indexOf("://")
@@ -1197,12 +1219,12 @@ internal fun urlHost(inUrl: String): String? {
     return vAuthority.ifEmpty { null }
 }
 
-/* The user-agent string our Darwin engine sends is opaque to Ktor —
+/** The user-agent string our Darwin engine sends is opaque to Ktor -
 NSURLSession picks the default. Match what httpie does: identify
 ourselves so the wire log isn't missing the field entirely. */
 internal const val kUserAgent: String = "compose-apidemo/1.0"
 
-/* Combine Ktor's reported request headers with the ones the engine
+/** Combine Ktor's reported request headers with the ones the engine
 adds at the wire level (Host, Content-Length, User-Agent) so the
 Request tab shows the actual on-the-wire header set rather than
 just the subset Ktor sees. Sorted alphabetically. */
@@ -1210,23 +1232,23 @@ internal fun synthesizeRequestHeaders(
     inReq: ApiRequest,
     inReported: List<Pair<String, String>>,
 ): List<Pair<String, String>> {
-    val vByKey = inReported.associate { it.first.lowercase() to it }.toMutableMap()
+    val vByKey = inReported.associateBy { it.first.lowercase() }.toMutableMap()
     urlHost(inReq.url)?.let { vHost ->
         vByKey.getOrPut("host") { "Host" to vHost }
     }
     if (!vByKey.containsKey("user-agent")) {
         vByKey["user-agent"] = "User-Agent" to kUserAgent
     }
-    if (inReq.method.allowsBody && inReq.bodyType != BodyType.NONE && !vByKey.containsKey("content-length")) {
+    if (true && inReq.bodyType != BodyType.NONE && !vByKey.containsKey("content-length")) {
         val vLen = computedBodyLength(inReq)
         if (vLen != null) vByKey["content-length"] = "Content-Length" to vLen.toString()
     }
     return vByKey.values.sortedBy { it.first.lowercase() }
 }
 
-/* Body length in bytes for the headers synthesis. JSON / TEXT use the
+/** Body length in bytes for the headers synthesis. JSON / TEXT use the
 raw UTF-8 byte count; FORM serialises and counts; FILE skips
-   (loading the file just for the count would be wasteful — the engine
+(loading the file just for the count would be wasteful - the engine
 sets the field anyway). */
 internal fun computedBodyLength(inReq: ApiRequest): Int? = when (inReq.bodyType) {
     BodyType.TEXT -> inReq.body.encodeToByteArray().size
@@ -1234,7 +1256,7 @@ internal fun computedBodyLength(inReq: ApiRequest): Int? = when (inReq.bodyType)
     BodyType.FILE, BodyType.NONE -> null
 }
 
-/* Format the timing / size footer text shown bottom-right. */
+/** Format the timing / size footer text shown bottom-right. */
 internal fun formatTimingSize(inResp: ApiResponse): String {
     val vSize = when {
         inResp.sizeBytes < 1024 -> "${inResp.sizeBytes} B"
@@ -1245,12 +1267,12 @@ internal fun formatTimingSize(inResp: ApiResponse): String {
 }
 
 // ==================
-// MARK: ViewerOverflowMenu — 3-dot menu in the bottom-right of the viewer
+// MARK: ViewerOverflowMenu - 3-dot menu in the bottom-right of the viewer
 // ==================
 
-/* Replaces the inline Copy / Save chips with a single MoreHoriz menu.
+/** Replaces the inline Copy / Save chips with a single MoreHoriz menu.
 Copy actions target whichever tab is showing (request or response);
-   Clear is global — wipes the response, sentReq, preview state, and any
+Clear is global - wipes the response, sentReq, preview state, and any
 memory-backed image resource for the current request. */
 @Composable
 internal fun ViewerOverflowMenu(
@@ -1309,18 +1331,18 @@ internal fun ViewerOverflowMenu(
         }
         DropdownMenu(expanded = vOpen, onDismissRequest = { vOpen = false }) {
             DropdownMenuItem(text = { Text("Copy all") }, onClick = {
-                vScope.launch { vClipboard.setClipEntry(ClipEntry.withPlainText(copyAll())) }
+                vScope.launch { vClipboard.setClipEntry(clipEntryOfText(copyAll())) }
                 inOnMessage("Copied all.")
                 vOpen = false
             })
             DropdownMenuItem(text = { Text("Copy headers") }, onClick = {
-                vScope.launch { vClipboard.setClipEntry(ClipEntry.withPlainText(vHeadersText)) }
+                vScope.launch { vClipboard.setClipEntry(clipEntryOfText(vHeadersText)) }
                 inOnMessage("Copied headers.")
                 vOpen = false
             })
             if (vCanCopyBody) {
                 DropdownMenuItem(text = { Text("Copy body") }, onClick = {
-                    vScope.launch { vClipboard.setClipEntry(ClipEntry.withPlainText(vBodyText)) }
+                    vScope.launch { vClipboard.setClipEntry(clipEntryOfText(vBodyText)) }
                     inOnMessage("Copied body.")
                     vOpen = false
                 })
@@ -1341,12 +1363,14 @@ internal fun ViewerOverflowMenu(
                 vOpen = false
             })
             HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp), color = c.border)
-            DropdownMenuItem(text = { Text("Clear", color = Color(0xFFFF5630)) }, onClick = { inOnClear(); vOpen = false })
+            DropdownMenuItem(
+                text = { Text("Clear", color = Color(0xFFFF5630)) },
+                onClick = { inOnClear(); vOpen = false })
         }
     }
 }
 
-/* Perceptual luminance check — true when the colour reads as "dark"
+/** Perceptual luminance check - true when the colour reads as "dark"
 (background gets a light foreground). Standard Rec. 709 weights. */
 internal fun isDarkBg(inColor: Color): Boolean {
     val vY = 0.299f * inColor.red + 0.587f * inColor.green + 0.114f * inColor.blue
@@ -1354,10 +1378,10 @@ internal fun isDarkBg(inColor: Color): Boolean {
 }
 
 // ==================
-// MARK: BodyFormatSelector — small dropdown for RAW / JSON / XML / YAML / HTML
+// MARK: BodyFormatSelector - small dropdown for RAW / JSON / XML / YAML / HTML
 // ==================
 
-/* Format / "type" picker. inBordered renders it as a full dropdown matching
+/** Format / "type" picker. inBordered renders it as a full dropdown matching
 BodyTypeMenu (the Body-tab Text-type picker); otherwise it's the compact inline
 control used by the response viewer. */
 @Composable
@@ -1381,21 +1405,26 @@ internal fun BodyFormatSelector(
             horizontalArrangement = Arrangement.spacedBy(if (inBordered) 5.dp else 4.dp),
         ) {
             Text(vLabel, color = if (inBordered) c.text else c.dim, fontSize = if (inBordered) 13.sp else 11.sp)
-            MaterialSymbolsOutlined(if (inBordered) MaterialSymbols.UnfoldMore else MaterialSymbols.ArrowDropDown, tint = c.dim, size = if (inBordered) 15.dp else 14.dp)
+            MaterialSymbolsOutlined(
+                if (inBordered) MaterialSymbols.UnfoldMore else MaterialSymbols.ArrowDropDown,
+                tint = c.dim,
+                size = if (inBordered) 15.dp else 14.dp
+            )
         }
         DropdownMenu(expanded = vOpen, onDismissRequest = { vOpen = false }) {
-            for (vF in BodyFormat.values()) {
-                DropdownMenuItem(text = { Text(vF.label, color = if (vF == inSelected) c.accent else c.text) },
+            for (vF in BodyFormat.entries) {
+                DropdownMenuItem(
+                    text = { Text(vF.label, color = if (vF == inSelected) c.accent else c.text) },
                     onClick = { inOnChange(vF); vOpen = false })
             }
         }
     }
 }
 
-/* TLS validation indicator: only true when the URL is https AND we got
+/** TLS validation indicator: only true when the URL is https AND we got
 a real response back (i.e. the OS engine completed the TLS handshake
-   without an error). The engines we ship — NSURLSession on macOS,
-   WinHttp on Windows, libcurl on Linux — all reject an untrusted
+without an error). The engines we ship - NSURLSession on macOS,
+WinHttp on Windows, libcurl on Linux - all reject an untrusted
 certificate by default, so a non-error response is implicit proof
 that the OS validated the chain. */
 internal fun isTlsValidated(inUrl: String, inResp: ApiResponse?): Boolean {
@@ -1405,7 +1434,7 @@ internal fun isTlsValidated(inUrl: String, inResp: ApiResponse?): Boolean {
     return inResp.status > 0
 }
 
-/* Parse "Key: value\nKey2: value2" into a list of pairs so the headers
+/** Parse "Key: value\nKey2: value2" into a list of pairs so the headers
 table renderer can lay them out as a key/value grid. */
 internal fun parseHeaderLines(inText: String): List<Pair<String, String>> {
     if (inText.isBlank() || inText == "(no headers)") return emptyList()
@@ -1415,7 +1444,7 @@ internal fun parseHeaderLines(inText: String): List<Pair<String, String>> {
     }
 }
 
-/* "content-type" → "Content-Type"; preserves single-word keys; leaves
+/** "content-type" → "Content-Type"; preserves single-word keys; leaves
 already-correct ones unchanged. */
 internal fun titleCaseHeader(inKey: String): String =
     inKey.split('-').joinToString("-") { vWord ->
@@ -1423,7 +1452,7 @@ internal fun titleCaseHeader(inKey: String): String =
         else vWord[0].uppercaseChar() + vWord.drop(1).lowercase()
     }
 
-/* Centered icon + label placeholder for the viewer (Not sent / Not received /
+/** Centered icon + label placeholder for the viewer (Not sent / Not received /
 No Body). Fills its parent unless a sized modifier is supplied. */
 @Composable
 internal fun ViewerEmpty(inIcon: Int, inText: String, inModifier: Modifier = Modifier.fillMaxSize()) {
@@ -1436,64 +1465,32 @@ internal fun ViewerEmpty(inIcon: Int, inText: String, inModifier: Modifier = Mod
     }
 }
 
-/* A labelled, read-only (selectable) code block used by the viewer sections. */
-@Composable
-internal fun CodeSection(inLabel: String, inText: String) {
-    val c = LocalAppColors.current
-    Column(modifier = Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(4.dp)) {
-        Text(inLabel, color = c.dim, fontSize = 11.sp)
-        Box(
-            modifier = Modifier.fillMaxWidth().clip(RoundedCornerShape(8.dp))
-                .background(c.bg, RoundedCornerShape(8.dp)).border(1.dp, c.border, RoundedCornerShape(8.dp)).padding(12.dp),
-        ) {
-            androidx.compose.runtime.CompositionLocalProvider(
-                androidx.compose.foundation.text.selection.LocalTextSelectionColors provides
-                    androidx.compose.foundation.text.selection.TextSelectionColors(
-                        handleColor = c.accent,
-                        backgroundColor = c.accent.copy(alpha = 0.35f),
-                    ),
-            ) {
-                BasicTextField(
-                    value = inText.ifEmpty { "(empty)" }, onValueChange = {}, readOnly = true,
-                    textStyle = androidx.compose.ui.text.TextStyle(color = c.text, fontSize = 12.sp),
-                    cursorBrush = androidx.compose.ui.graphics.SolidColor(c.accent),
-                    modifier = Modifier.fillMaxWidth(),
-                )
-            }
-        }
-    }
-}
-
-/* Format an actual header list (key: value per line). */
+/** Format an actual header list (key: value per line). */
 internal fun headersText(inHeaders: List<Pair<String, String>>): String =
     inHeaders.joinToString("\n") { (vK, vV) -> "$vK: $vV" }.ifEmpty { "(no headers)" }
 
-/* The headers that *would* be sent — explicit enabled headers plus the inferred
+/** The headers that *would* be sent - explicit enabled headers plus the inferred
 Content-Type for the body type (unless one is already set). Used for Preview;
 a sent request shows the real headers via headersText(response.requestHeaders). */
 internal fun requestHeadersText(inReq: ApiRequest): String {
     val vLines = mutableListOf<String>()
     inReq.headers.filter { it.enabled && it.key.isNotBlank() }.forEach { vLines.add("${it.key}: ${it.value}") }
     val vCt = inReq.bodyContentType()
-    if (inReq.method.allowsBody && vCt != null && inReq.headers.none { it.enabled && it.key.equals("content-type", ignoreCase = true) }) {
+    if (true && vCt != null && inReq.headers.none {
+            it.enabled && it.key.equals(
+                "content-type",
+                ignoreCase = true
+            )
+        }) {
         vLines.add("Content-Type: $vCt")
     }
     return vLines.joinToString("\n").ifEmpty { "(no headers)" }
 }
 
-/* The body that would be sent, rendered as text for the preview. */
+/** The body that would be sent, rendered as text for the preview. */
 internal fun requestBodyText(inReq: ApiRequest): String = when (inReq.bodyType) {
     BodyType.NONE -> "(no body)"
     BodyType.TEXT -> inReq.body.ifEmpty { "(empty)" }
     BodyType.FORM -> formEncode(inReq.form).ifEmpty { "(empty form)" }
     BodyType.FILE -> if (inReq.body.isBlank()) "(no file)" else "(file) ${inReq.body}"
 }
-
-@Composable
-internal fun StatusPill(inStatus: Int, inLabel: String) {
-    val vC = statusColor(inStatus)
-    Box(modifier = Modifier.clip(RoundedCornerShape(6.dp)).background(vC.copy(alpha = 0.20f), RoundedCornerShape(6.dp)).padding(horizontal = 12.dp, vertical = 6.dp)) {
-        Text(inLabel, color = vC, fontSize = 14.sp)
-    }
-}
-

apidemo/src/commonMain/kotlin/VolticThemes.kt

@@ -0,0 +1,212 @@
+package apidemo
+
+import androidx.compose.material3.ColorScheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.graphics.Color
+
+// ==================
+// MARK: Voltic themes - selectable Material 3 palettes
+// ==================
+// The three "voltic" brand palettes (Kotlin purple, orange, and a stock-M3
+// purple), each a full light + dark M3 ColorScheme plus an EXTENDED group that
+// M3 has no slot for (warning). The app runs on MaterialTheme(colorScheme = …)
+// driven by the selected palette; the legacy AppColors abstraction is DERIVED
+// from the active scheme (appColorsFromScheme) so existing widgets follow along.
+
+/** Colors M3's ColorScheme has no slot for. Warning is the amber "unsaved /
+undefined variable" accent; read it with VolticTheme.extended.warning. */
+@Immutable
+data class VolticExtendedColors(
+    val warning: Color,
+    val onWarning: Color,
+    val warningContainer: Color,
+    val onWarningContainer: Color,
+)
+
+/** One palette's four schemes: the M3 light/dark ColorSchemes + the matching
+extended groups. */
+@Immutable
+class VolticScheme(
+    val light: ColorScheme,
+    val dark: ColorScheme,
+    val lightExtended: VolticExtendedColors,
+    val darkExtended: VolticExtendedColors,
+)
+
+/** The palettes the user can pick from. `id` is the stable persistence key. */
+enum class VolticPalette(val id: String, val label: String) {
+    Purple("purple", "Kotlin Purple"),
+    Orange("orange", "Voltic Orange"),
+    PurpleStock("purple-stock", "Purple");
+
+    val scheme: VolticScheme
+        get() = when (this) {
+            Purple -> kPurpleScheme
+            Orange -> kOrangeScheme
+            PurpleStock -> kPurpleStockScheme
+        }
+
+    companion object {
+        fun fromId(inId: String?): VolticPalette = entries.firstOrNull { it.id == inId } ?: Purple
+    }
+}
+
+// Usage: MaterialTheme.colorScheme.primary, VolticTheme.extended.warning
+val LocalVolticExtended = staticCompositionLocalOf { kPurpleScheme.darkExtended }
+
+object VolticTheme {
+    val extended: VolticExtendedColors
+        @Composable get() = LocalVolticExtended.current
+}
+
+/** Maps the active M3 ColorScheme onto the app's legacy AppColors slots, so the
+~50 existing `LocalAppColors.current` call sites theme with the palette:
+panel = surface, field = surfaceVariant, border = the subtle outlineVariant,
+dim = onSurfaceVariant, accent = primary. */
+internal fun appColorsFromScheme(inScheme: ColorScheme): AppColors = AppColors(
+    bg = inScheme.background,
+    panel = inScheme.surface,
+    field = inScheme.surfaceVariant,
+    border = inScheme.outlineVariant,
+    accent = inScheme.primary,
+    text = inScheme.onSurface,
+    dim = inScheme.onSurfaceVariant,
+    onAccent = inScheme.onPrimary,
+)
+
+// ==================
+// MARK: Palette definitions (from voltic-pack/theme)
+// ==================
+
+private val kPurpleScheme = VolticScheme(
+    light = lightColorScheme(
+        primary = Color(0xFF7F52FF), onPrimary = Color(0xFFFFFFFF),
+        primaryContainer = Color(0xFFE3D4FF), onPrimaryContainer = Color(0xFF2A1065),
+        secondary = Color(0xFF5F5873), onSecondary = Color(0xFFFFFFFF),
+        secondaryContainer = Color(0xFFE5DFF3), onSecondaryContainer = Color(0xFF1B1626),
+        tertiary = Color(0xFFF5B437), onTertiary = Color(0xFF3F2E00),
+        tertiaryContainer = Color(0xFFFFE8B8), onTertiaryContainer = Color(0xFF2F2000),
+        error = Color(0xFFBA1A1A), onError = Color(0xFFFFFFFF),
+        errorContainer = Color(0xFFFFDAD6), onErrorContainer = Color(0xFF410002),
+        background = Color(0xFFFAF8FF), onBackground = Color(0xFF1B1626),
+        surface = Color(0xFFFFFFFF), onSurface = Color(0xFF1B1626),
+        surfaceVariant = Color(0xFFECE6F6), onSurfaceVariant = Color(0xFF453D5C),
+        outline = Color(0xFF6A5F8A), outlineVariant = Color(0xFFD7CDEB),
+        inverseSurface = Color(0xFF2E2840), inverseOnSurface = Color(0xFFF3EFFB),
+        inversePrimary = Color(0xFF9D7BFF), surfaceTint = Color(0xFF7F52FF), scrim = Color(0xFF000000),
+    ),
+    dark = darkColorScheme(
+        primary = Color(0xFF9D7BFF), onPrimary = Color(0xFF1F0068),
+        primaryContainer = Color(0xFF4A22C4), onPrimaryContainer = Color(0xFFE3D4FF),
+        secondary = Color(0xFFC9C1DC), onSecondary = Color(0xFF2E2840),
+        secondaryContainer = Color(0xFF453D5C), onSecondaryContainer = Color(0xFFE5DFF3),
+        tertiary = Color(0xFFF5B437), onTertiary = Color(0xFF3F2E00),
+        tertiaryContainer = Color(0xFF6D5000), onTertiaryContainer = Color(0xFFFFE8B8),
+        error = Color(0xFFFFB4AB), onError = Color(0xFF690005),
+        errorContainer = Color(0xFF93000A), onErrorContainer = Color(0xFFFFDAD6),
+        background = Color(0xFF0F0D17), onBackground = Color(0xFFE6E1F2),
+        surface = Color(0xFF171423), onSurface = Color(0xFFE6E1F2),
+        surfaceVariant = Color(0xFF37304A), onSurfaceVariant = Color(0xFFCFC6E4),
+        outline = Color(0xFF8F86A8), outlineVariant = Color(0xFF37304A),
+        inverseSurface = Color(0xFFE6E1F2), inverseOnSurface = Color(0xFF171423),
+        inversePrimary = Color(0xFF7F52FF), surfaceTint = Color(0xFF9D7BFF), scrim = Color(0xFF000000),
+    ),
+    lightExtended = VolticExtendedColors(
+        warning = Color(0xFFB26A00), onWarning = Color(0xFFFFFFFF),
+        warningContainer = Color(0xFFFFDF9E), onWarningContainer = Color(0xFF2A1800),
+    ),
+    darkExtended = VolticExtendedColors(
+        warning = Color(0xFFFFC960), onWarning = Color(0xFF3F2E00),
+        warningContainer = Color(0xFF5C4300), onWarningContainer = Color(0xFFFFDF9E),
+    ),
+)
+
+private val kOrangeScheme = VolticScheme(
+    light = lightColorScheme(
+        primary = Color(0xFFE86A33), onPrimary = Color(0xFFFFFFFF),
+        primaryContainer = Color(0xFFFFDBCB), onPrimaryContainer = Color(0xFF380D00),
+        secondary = Color(0xFF9C4E2A), onSecondary = Color(0xFFFFFFFF),
+        secondaryContainer = Color(0xFFFFE0D2), onSecondaryContainer = Color(0xFF3A0F00),
+        tertiary = Color(0xFF8F6A00), onTertiary = Color(0xFFFFFFFF),
+        tertiaryContainer = Color(0xFFFBE08A), onTertiaryContainer = Color(0xFF2D2000),
+        error = Color(0xFFBA1A1A), onError = Color(0xFFFFFFFF),
+        errorContainer = Color(0xFFFFDAD6), onErrorContainer = Color(0xFF410002),
+        background = Color(0xFFFFF8F5), onBackground = Color(0xFF221A15),
+        surface = Color(0xFFFFF8F5), onSurface = Color(0xFF221A15),
+        surfaceVariant = Color(0xFFF4DED4), onSurfaceVariant = Color(0xFF52443C),
+        outline = Color(0xFF85736B), outlineVariant = Color(0xFFD7C2B8),
+        inverseSurface = Color(0xFF382E29), inverseOnSurface = Color(0xFFFFEDE5),
+        inversePrimary = Color(0xFFFFB598), surfaceTint = Color(0xFFE86A33), scrim = Color(0xFF000000),
+    ),
+    dark = darkColorScheme(
+        primary = Color(0xFFFFB598), onPrimary = Color(0xFF5B1B00),
+        primaryContainer = Color(0xFFC1531F), onPrimaryContainer = Color(0xFFFFDBCB),
+        secondary = Color(0xFFFFB599), onSecondary = Color(0xFF5E1A00),
+        secondaryContainer = Color(0xFF7D3715), onSecondaryContainer = Color(0xFFFFE0D2),
+        tertiary = Color(0xFFF5B437), onTertiary = Color(0xFF3F2E00),
+        tertiaryContainer = Color(0xFF6D5000), onTertiaryContainer = Color(0xFFFBE08A),
+        error = Color(0xFFFFB4AB), onError = Color(0xFF690005),
+        errorContainer = Color(0xFF93000A), onErrorContainer = Color(0xFFFFDAD6),
+        background = Color(0xFF101B28), onBackground = Color(0xFFE3E7ED),
+        surface = Color(0xFF16283A), onSurface = Color(0xFFE3E7ED),
+        surfaceVariant = Color(0xFF33414F), onSurfaceVariant = Color(0xFFC9D3DD),
+        outline = Color(0xFF7C8A97), outlineVariant = Color(0xFF33414F),
+        inverseSurface = Color(0xFFE3E7ED), inverseOnSurface = Color(0xFF16283A),
+        inversePrimary = Color(0xFFE86A33), surfaceTint = Color(0xFFFFB598), scrim = Color(0xFF000000),
+    ),
+    lightExtended = VolticExtendedColors(
+        warning = Color(0xFF7D5800), onWarning = Color(0xFFFFFFFF),
+        warningContainer = Color(0xFFFFDF9E), onWarningContainer = Color(0xFF271900),
+    ),
+    darkExtended = VolticExtendedColors(
+        warning = Color(0xFFF2C13D), onWarning = Color(0xFF3E2E00),
+        warningContainer = Color(0xFF5E4600), onWarningContainer = Color(0xFFFFDF9E),
+    ),
+)
+
+private val kPurpleStockScheme = VolticScheme(
+    light = lightColorScheme(
+        primary = Color(0xFF7F52FF), onPrimary = Color(0xFFFFFFFF),
+        primaryContainer = Color(0xFFE9DDFF), onPrimaryContainer = Color(0xFF22005D),
+        secondary = Color(0xFF615B71), onSecondary = Color(0xFFFFFFFF),
+        secondaryContainer = Color(0xFFE7DEF8), onSecondaryContainer = Color(0xFF1D192B),
+        tertiary = Color(0xFF9A25AE), onTertiary = Color(0xFFFFFFFF),
+        tertiaryContainer = Color(0xFFFFD6FE), onTertiaryContainer = Color(0xFF35003F),
+        error = Color(0xFFBA1A1A), onError = Color(0xFFFFFFFF),
+        errorContainer = Color(0xFFFFDAD6), onErrorContainer = Color(0xFF410002),
+        background = Color(0xFFFDF7FF), onBackground = Color(0xFF1C1B20),
+        surface = Color(0xFFFDF7FF), onSurface = Color(0xFF1C1B20),
+        surfaceVariant = Color(0xFFE7E0EB), onSurfaceVariant = Color(0xFF49454E),
+        outline = Color(0xFF7A757F), outlineVariant = Color(0xFFCBC4CF),
+        inverseSurface = Color(0xFF313035), inverseOnSurface = Color(0xFFF4EFF4),
+        inversePrimary = Color(0xFFCFBCFF), surfaceTint = Color(0xFF7F52FF), scrim = Color(0xFF000000),
+    ),
+    dark = darkColorScheme(
+        primary = Color(0xFFCFBCFF), onPrimary = Color(0xFF3A0AA5),
+        primaryContainer = Color(0xFF6236E0), onPrimaryContainer = Color(0xFFE9DDFF),
+        secondary = Color(0xFFCBC2DB), onSecondary = Color(0xFF332D41),
+        secondaryContainer = Color(0xFF494458), onSecondaryContainer = Color(0xFFE7DEF8),
+        tertiary = Color(0xFFF9ABFF), onTertiary = Color(0xFF570066),
+        tertiaryContainer = Color(0xFF7B0E8F), onTertiaryContainer = Color(0xFFFFD6FE),
+        error = Color(0xFFFFB4AB), onError = Color(0xFF690005),
+        errorContainer = Color(0xFF93000A), onErrorContainer = Color(0xFFFFDAD6),
+        background = Color(0xFF141220), onBackground = Color(0xFFE6E1E9),
+        surface = Color(0xFF1D1A2C), onSurface = Color(0xFFE6E1E9),
+        surfaceVariant = Color(0xFF3B3548), onSurfaceVariant = Color(0xFFCBC4CF),
+        outline = Color(0xFF948F99), outlineVariant = Color(0xFF3B3548),
+        inverseSurface = Color(0xFFE6E1E9), inverseOnSurface = Color(0xFF1D1A2C),
+        inversePrimary = Color(0xFF7F52FF), surfaceTint = Color(0xFFCFBCFF), scrim = Color(0xFF000000),
+    ),
+    lightExtended = VolticExtendedColors(
+        warning = Color(0xFFB26A00), onWarning = Color(0xFFFFFFFF),
+        warningContainer = Color(0xFFFFDF9E), onWarningContainer = Color(0xFF2A1800),
+    ),
+    darkExtended = VolticExtendedColors(
+        warning = Color(0xFFFFC960), onWarning = Color(0xFF3F2E00),
+        warningContainer = Color(0xFF5C4300), onWarningContainer = Color(0xFFFFDF9E),
+    ),
+)

apidemo/src/commonMain/kotlin/compat/Compat.kt

@@ -0,0 +1,77 @@
+package apidemo.compat
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.platform.ClipEntry
+import io.ktor.client.*
+import okio.FileSystem
+
+// ==================
+// MARK: Platform seams (native = com.compose.sdl / SDL3, jvm = AWT + upstream desktop)
+// ==================
+// The port modules are native-only, so shared code can't call com.compose.sdl
+// directly - every SDL-backed API the app uses goes through these expects.
+// Signatures mirror the native originals so the native actuals are pure
+// delegation (same pattern as :demo's demo.shim package).
+
+/** Per-user app-data dir (created on demand, ends with a separator) or null. */
+expect fun appDataDir(inOrg: String, inApp: String): String?
+
+/** Open the OS file manager showing the given path. Fire-and-forget. */
+expect fun revealInFileManager(inPath: String, inOnResult: ((Boolean) -> Unit)? = null)
+
+/** "Explorer" / "Finder" / "Files" - for menu labels. */
+expect fun fileManagerName(): String
+
+/** Async save-file dialog; the callback gets the chosen absolute path or null. */
+expect fun showSaveFileDialog(inDefaultName: String? = null, inOnResult: (String?) -> Unit)
+
+/** Async open-file dialog; the callback gets the chosen absolute path or null. */
+expect fun showOpenFileDialog(inOnResult: (String?) -> Unit)
+
+/** A plain-text clipboard entry (ClipEntry construction differs per stack). */
+expect fun clipEntryOfText(inText: String): ClipEntry
+
+// ============
+//  In-memory response images
+
+/** Register/replace decoded-image source bytes under a key (resp-image://N). */
+expect fun registerMemoryImage(inKey: String, inBytes: ByteArray)
+
+/** Drop a registered image's bytes. */
+expect fun removeMemoryImage(inKey: String)
+
+/** Painter for a registered image key (raster or SVG). */
+@Composable
+expect fun memoryImagePainter(inKey: String, inSvg: Boolean): Painter
+
+// ============
+//  Text layout
+
+/** Rows the given line occupies when soft-wrapped to inMaxWidthPx at
+inFontPx (already density-scaled). Used by the body gutter so its line
+numbers stay aligned with the wrapped body text. */
+expect fun wrappedRowCount(inText: String, inFontPx: Int, inMaxWidthPx: Int, inFamilyName: String?): Int
+
+/** Editor tab width in spaces - how wide a typed '\t' renders. On the native
+stack this drives the project text pipeline (TextLayoutConfig); the jvm
+parity app only stores the preference. */
+expect var editorTabWidth: Int
+
+// ============
+//  Infrastructure
+
+/** okio's FileSystem.SYSTEM is declared per-platform, not in its common
+metadata - surface it through a seam. */
+internal expect val systemFileSystem: FileSystem
+
+/** The app's Ktor client: Curl on native (bundled libcurl - same TLS stack as
+the mTLS path), CIO on the jvm parity target. */
+expect fun createApiHttpClient(): HttpClient
+
+/** Window-shell integration: an intercepting close handler (return true to
+allow the close) and an app-wide key-shortcut handler; both cleared when
+the composition leaves. */
+@Composable
+expect fun InstallWindowHooks(inOnCloseRequest: () -> Boolean, inOnKeyShortcut: (KeyEvent) -> Boolean)

apidemo/src/commonMain/kotlin/compat/LayoutExt.kt

@@ -0,0 +1,16 @@
+package apidemo.compat
+
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.positionInWindow
+
+// COPY of the port's com.compose.sdl.layout LayoutCoordinates sugar so the
+// same helpers resolve on the jvm parity target (the port modules are
+// native-only). Guards `isAttached`: a menu/tooltip anchor can be read while
+// its node is mid-recycle, and positionInWindow() throws on a detached
+// coordinator.
+
+/** Logical-point X of this layout in the window. */
+val LayoutCoordinates.x: Int get() = if (isAttached) positionInWindow().x.toInt() else 0
+
+/** Logical-point Y of this layout in the window. */
+val LayoutCoordinates.y: Int get() = if (isAttached) positionInWindow().y.toInt() else 0

apidemo/src/commonMain/kotlin/compat/Scrollbar.kt

@@ -0,0 +1,316 @@
+// COPY of the port's Scrollbar (package com.compose.sdl.scrollbar) so the SAME
+// implementation runs on the jvm parity target - the port modules are
+// native-only, so apidemo's commonMain cannot reference them directly.
+// Keep in sync with the original when it changes.
+package apidemo.compat
+
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.awaitEachGesture
+import androidx.compose.foundation.gestures.awaitFirstDown
+import androidx.compose.foundation.gestures.scrollBy
+import androidx.compose.foundation.hoverable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsHoveredAsState
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Shape
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.launch
+import kotlin.math.abs
+import kotlin.math.roundToInt
+
+// ==================
+// MARK: Scrollbar (Compose Desktop-style)
+// ==================
+
+/** A faithful subset of Compose Desktop's scrollbar (androidx.compose.foundation).
+You overlay a VerticalScrollbar / HorizontalScrollbar on a scrollable and feed
+it a ScrollbarAdapter built from the same ScrollState. This project's Box has
+no BoxScope (so no Modifier.align) - pin the bar with the Box's
+contentAlignment; the fillMaxSize content fills the rest:
+
+Box(Modifier.fillMaxSize(), contentAlignment = Alignment.CenterEnd) {
+val state = rememberScrollState()
+Column(Modifier.fillMaxSize().verticalScroll(state)) { ... }
+VerticalScrollbar(
+adapter = rememberScrollbarAdapter(state),
+modifier = Modifier.fillMaxHeight(),
+)
+}
+
+Always visible (no auto-hide); the thumb tweens unhoverColor -> hoverColor on
+hover over hoverDurationMillis, matching upstream. Drag the thumb to scroll;
+click the track to page. */
+
+@Immutable
+class ScrollbarStyle(
+    val minimalHeight: Dp,
+    val thickness: Dp,
+    val shape: Shape,
+    val hoverDurationMillis: Int,
+    val unhoverColor: Color,
+    val hoverColor: Color,
+)
+
+/** Upstream default: an 8dp black thumb that's faint until hovered. Dark UIs
+provide a white-tinted style via LocalScrollbarStyle or the `style` param. */
+fun defaultScrollbarStyle(): ScrollbarStyle = ScrollbarStyle(
+    minimalHeight = 16.dp,
+    thickness = 8.dp,
+    shape = RoundedCornerShape(4.dp),
+    hoverDurationMillis = 300,
+    unhoverColor = Color.Black.copy(alpha = 0.12f),
+    hoverColor = Color.Black.copy(alpha = 0.50f),
+)
+
+val LocalScrollbarStyle = compositionLocalOf { defaultScrollbarStyle() }
+
+// ==================
+// MARK: ScrollbarAdapter
+// ==================
+
+/** Bridges a scrollable's state to the scrollbar in pixels. scrollOffset /
+contentSize / viewportSize are along the scroll axis; the thumb is sized by
+viewportSize / contentSize and positioned by scrollOffset / (content - viewport). */
+interface ScrollbarAdapter {
+    val scrollOffset: Double
+    val contentSize: Double
+    val viewportSize: Double
+    suspend fun scrollTo(scrollOffset: Double)
+}
+
+// (The port also ships a ScrollState-based adapter; it reads foundation
+// internals (ScrollState.contentSize/viewportSize) that a copy outside
+// :foundation cannot access. apidemo only scrollbars a LazyColumn.)
+
+/** Adapter for a virtualized LazyColumn / LazyRow. A lazy list only knows the
+size of its VISIBLE items, so exact pixel geometry of off-screen content is
+unknowable - we estimate it from the average visible item size × total item
+count (the same approach as Compose Desktop). Accurate enough for a thumb
+whose length/position track the scroll position; the estimate self-corrects
+as items of different sizes scroll through the viewport. */
+@Composable
+fun rememberScrollbarAdapter(scrollState: LazyListState): ScrollbarAdapter =
+    remember(scrollState) { LazyListScrollbarAdapter(scrollState) }
+
+private class LazyListScrollbarAdapter(private val state: LazyListState) : ScrollbarAdapter {
+    // Mean main-axis size of the currently-visible items, in px (>= 1 to avoid /0).
+    private fun averageItemSize(): Double {
+        val vVisible = state.layoutInfo.visibleItemsInfo
+        if (vVisible.isEmpty()) return 0.0
+        val vSpan = (vVisible.last().offset + vVisible.last().size) - vVisible.first().offset
+        return (vSpan.toDouble() / vVisible.size).coerceAtLeast(1.0)
+    }
+
+    override val scrollOffset: Double
+        get() = averageItemSize() * state.firstVisibleItemIndex + state.firstVisibleItemScrollOffset
+
+    override val contentSize: Double
+        get() = averageItemSize() * state.layoutInfo.totalItemsCount
+
+    override val viewportSize: Double
+        get() = (state.layoutInfo.viewportEndOffset - state.layoutInfo.viewportStartOffset).toDouble()
+
+    override suspend fun scrollTo(scrollOffset: Double) {
+        val vDistance = scrollOffset - this.scrollOffset
+        // Within a viewport, scroll by EXACT pixels so a drag stays smooth. A lazy
+        // list's pixel geometry is only ESTIMATED (average visible item size), and
+        // that estimate drifts as differently-sized items scroll through the
+        // viewport - so index-snapping every frame makes the thumb jump. scrollBy
+        // sidesteps the estimate entirely. This is what Compose Desktop's own
+        // LazyListScrollbarAdapter does, and for the same reason.
+        if (abs(vDistance) <= viewportSize) {
+            state.scrollBy(vDistance.toFloat())
+            return
+        }
+        // Far jump (track-click paging past a viewport): no exact geometry to lean
+        // on, so estimate an index/offset from the average and snap to it.
+        val vAvg = averageItemSize()
+        if (vAvg <= 0.0) return
+        val vTarget = scrollOffset.coerceAtLeast(0.0)
+        val vTotal = state.layoutInfo.totalItemsCount
+        val vIndex = (vTarget / vAvg).toInt().coerceIn(0, (vTotal - 1).coerceAtLeast(0))
+        val vItemOffset = (vTarget - vIndex * vAvg).toInt().coerceAtLeast(0)
+        state.scrollToItem(vIndex, vItemOffset)
+    }
+}
+
+// ==================
+// MARK: VerticalScrollbar / HorizontalScrollbar
+// ==================
+
+@Composable
+fun VerticalScrollbar(
+    adapter: ScrollbarAdapter,
+    modifier: Modifier = Modifier,
+    reverseLayout: Boolean = false,
+    style: ScrollbarStyle = LocalScrollbarStyle.current,
+    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
+) = Scrollbar(adapter, modifier, reverseLayout, style, interactionSource, isVertical = true)
+
+/** Shared impl. The root Box is the track (fixed thickness on the cross axis,
+filling the main axis from the caller's modifier); a child Box is the thumb,
+positioned with an offset. Drag + track-click are handled on the track in
+track-relative coordinates (a stable origin), so the grab point stays under
+the pointer with no feedback from the thumb moving. interactionSource is
+accepted for API parity; hover here is driven by Modifier.hoverable. */
+@Composable
+private fun Scrollbar(
+    adapter: ScrollbarAdapter,
+    modifier: Modifier,
+    reverseLayout: Boolean,
+    style: ScrollbarStyle,
+    @Suppress("UNUSED_PARAMETER") interactionSource: MutableInteractionSource,
+    isVertical: Boolean,
+) {
+    val vScope = rememberCoroutineScope()
+    var vTrackPx by remember { mutableStateOf(0) }
+    val vHoverSource = remember { MutableInteractionSource() }
+    val vHovered by vHoverSource.collectIsHoveredAsState()
+    var vDraggingThumb by remember { mutableStateOf(false) }
+    // onSizeChanged reports PHYSICAL pixels (Option-B density flow), so every
+    // int/px carried through here - vTrackPx, vThumbLen, vThumbPos - is in
+    // physical pixels. Passing them into `.dp` doubles again through
+    // density.toPx() on Retina, which visibly bloated the thumb (filled the
+    // whole track) and made drag/track-click positions land 2× too far down.
+    // Route pixel-sized modifiers through the current density so `.dp` and the
+    // pixel value stay in the same coord space.
+    val vDensity = LocalDensity.current
+
+    val vContent = adapter.contentSize
+    val vViewport = adapter.viewportSize
+    val vOffset = adapter.scrollOffset
+    val vMaxScroll = vContent - vViewport
+    val vScrollable = vMaxScroll > 0.5 && vViewport > 0.0
+
+    val vColor by animateColorAsState(
+        targetValue = if (vHovered || vDraggingThumb) style.hoverColor else style.unhoverColor,
+        animationSpec = tween(style.hoverDurationMillis),
+    )
+
+    val vRoot = (if (isVertical) modifier.width(style.thickness) else modifier.height(style.thickness))
+        .onSizeChanged { vTrackPx = if (isVertical) it.height else it.width }
+        .hoverable(vHoverSource)
+
+    Box(modifier = vRoot) {
+        if (!vScrollable || vTrackPx <= 0) return@Box
+
+        // ============
+        //  Thumb metrics (px)
+        val vMinLen = style.minimalHeight.value.toInt()
+        val vThumbLen = (vTrackPx * (vViewport / vContent)).roundToInt()
+            .coerceIn(vMinLen.coerceAtMost(vTrackPx), vTrackPx)
+        val vTravel = vTrackPx - vThumbLen
+        val vRawPos = if (vTravel <= 0) 0 else (vTravel * (vOffset / vMaxScroll)).roundToInt()
+        val vThumbPos = (if (reverseLayout) vTravel - vRawPos else vRawPos).coerceIn(0, vTravel)
+
+        val vThumbLenDp = with(vDensity) { vThumbLen.toDp() }
+        val vThumbMod = (
+                if (isVertical) Modifier.offset { IntOffset(0, vThumbPos) }.width(style.thickness).height(vThumbLenDp)
+                else Modifier.offset { IntOffset(vThumbPos, 0) }.height(style.thickness).width(vThumbLenDp)
+                )
+            .clip(style.shape)
+            .background(vColor)
+
+        Box(modifier = vThumbMod)
+
+        // ============
+        //  Drag the thumb / page on track click - handled on the track so the
+        //  coordinates have a stable (non-moving) origin. The press is CONSUMED:
+        //  a scrollbar owns the pointer input it handles, so content sharing this
+        //  region (the scrollable beneath, or a parent that also reads pointer
+        //  input) never reacts to the same press. Geometry is read LIVE from the
+        //  adapter at press time - not from the captured render metrics above,
+        //  which go stale between pointerInput relaunches - so a grab after a
+        //  wheel-scroll still hit-tests against the thumb's current position.
+        Box(
+            modifier = Modifier
+                .matchTrackSize(isVertical, with(vDensity) { vTrackPx.toDp() }, style.thickness)
+                .pointerInput(isVertical, adapter, vTrackPx, reverseLayout) {
+                    awaitEachGesture {
+                        val vDown = awaitFirstDown(requireUnconsumed = false)
+                        vDown.consume()
+
+                        // Live geometry - stable for the drag's duration (content /
+                        // viewport / track sizes don't change mid-drag).
+                        val vContentPx = adapter.contentSize
+                        val vViewportPx = adapter.viewportSize
+                        val vMaxScrollPx = vContentPx - vViewportPx
+                        if (vMaxScrollPx <= 0.0 || vTrackPx <= 0) return@awaitEachGesture
+                        val vMinLen = style.minimalHeight.value.toInt()
+                        val vLen = (vTrackPx * (vViewportPx / vContentPx)).roundToInt()
+                            .coerceIn(vMinLen.coerceAtMost(vTrackPx), vTrackPx)
+                        val vTravelPx = vTrackPx - vLen
+                        val vRaw = if (vTravelPx <= 0) 0
+                        else (vTravelPx * (adapter.scrollOffset / vMaxScrollPx)).roundToInt()
+                        val vPos = (if (reverseLayout) vTravelPx - vRaw else vRaw).coerceIn(0, vTravelPx)
+
+                        // Map a track-relative thumb-top to a scroll offset. The
+                        // target uses the LIVE max scroll (read fresh each move),
+                        // not the press-time value - the adapter compares it against
+                        // its live scrollOffset, and mixing a stale scale with a live
+                        // one makes the delta run away (grab at the bottom, drag up,
+                        // and the list overshoots to the middle).
+                        fun scrollToTrackPos(inThumbTop: Int) {
+                            if (vTravelPx <= 0) return
+                            val vLiveMax = adapter.contentSize - adapter.viewportSize
+                            if (vLiveMax <= 0.0) return
+                            val vClamped = inThumbTop.coerceIn(0, vTravelPx)
+                            val vFrac = (if (reverseLayout) vTravelPx - vClamped else vClamped).toDouble() / vTravelPx
+                            vScope.launch { adapter.scrollTo(vFrac * vLiveMax) }
+                        }
+
+                        val vPress = (if (isVertical) vDown.position.y else vDown.position.x).toInt()
+                        val vGrab: Int
+                        if (vPress in vPos..(vPos + vLen)) {
+                            vDraggingThumb = true
+                            vGrab = vPress - vPos
+                        } else {
+                            // Page toward the click by one viewport.
+                            vDraggingThumb = false
+                            vGrab = 0
+                            val vDir = if (vPress < vPos) -1.0 else 1.0
+                            vScope.launch { adapter.scrollTo(adapter.scrollOffset + vDir * vViewportPx) }
+                        }
+
+                        // Follow the pressed pointer to release, consuming every
+                        // change so the interaction can't leak. Only a thumb grab
+                        // drags-to-scroll; a track press just consumes.
+                        do {
+                            val vEvent = awaitPointerEvent()
+                            val vChange = vEvent.changes.firstOrNull { it.id == vDown.id } ?: break
+                            if (vDraggingThumb) {
+                                val vCur = (if (isVertical) vChange.position.y else vChange.position.x).toInt()
+                                scrollToTrackPos(vCur - vGrab)
+                            }
+                            vChange.consume()
+                        } while (vEvent.changes.any { it.id == vDown.id && it.pressed })
+
+                        vDraggingThumb = false
+                    }
+                }
+        )
+    }
+}
+
+/** Sizes the invisible drag-capture overlay to the full track. `inTrackDp`
+comes from the caller pre-converted via LocalDensity (Option-B: layout
+coords are physical px, so px-to-dp goes through the current density). */
+private fun Modifier.matchTrackSize(inVertical: Boolean, inTrackDp: Dp, inThickness: Dp): Modifier =
+    if (inVertical) this.width(inThickness).height(inTrackDp)
+    else this.height(inThickness).width(inTrackDp)

apidemo/src/commonMain/kotlin/compat/SplitPane.kt

@@ -0,0 +1,99 @@
+// COPY of the port's SplitPane (package com.compose.sdl.widgets) so the SAME
+// implementation runs on the jvm parity target - the port modules are
+// native-only, so apidemo's commonMain cannot reference them directly.
+// Keep in sync with the original when it changes.
+package apidemo.compat
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectDragGestures
+import androidx.compose.foundation.hoverable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.collectIsHoveredAsState
+import androidx.compose.foundation.layout.*
+import androidx.compose.runtime.*
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+
+// ==================
+// MARK: SplitPane
+// ==================
+
+/** Two-pane resizable split. `initialFirstSize` seeds the first pane's width
+ *  (horizontal split) or height (vertical split); after first layout it tracks
+ *  the user's drag. `minFirstSize` / `minSecondSize` clamp so neither pane can
+ *  shrink past its minimum.
+ *
+ *  Internal sizing is in **pixels** to match this port's pixel-space layout
+ *  tree (Option-B density flow). `Modifier.width((px / density).dp)` converts
+ *  back at the modifier boundary. */
+@Composable
+fun HorizontalSplitPane(
+    modifier: Modifier = Modifier,
+    initialFirstSize: Dp = 200.dp,
+    minFirstSize: Dp = 50.dp,
+    minSecondSize: Dp = 50.dp,
+    dividerColor: Color = Color(0x33FFFFFFL),
+    dividerHoverColor: Color = Color(0x66FFFFFFL),
+    first: @Composable () -> Unit,
+    second: @Composable () -> Unit,
+) {
+    val vDensity = LocalDensity.current
+    val vDividerPx = with(vDensity) { SplitPaneDefaults.DividerThickness.toPx().toInt() }
+    val vMinFirstPx = with(vDensity) { minFirstSize.toPx().toInt() }
+    val vMinSecondPx = with(vDensity) { minSecondSize.toPx().toInt() }
+    val vInitialFirstPx = with(vDensity) { initialFirstSize.toPx().toInt() }
+
+    var vTotalWidthPx by remember { mutableStateOf(0) }
+    var vFirstWidthPx by remember { mutableStateOf(vInitialFirstPx) }
+    val vDividerSource = remember { MutableInteractionSource() }
+    val vDividerHover by vDividerSource.collectIsHoveredAsState()
+    var vDragging by remember { mutableStateOf(false) }
+
+    Row(
+        modifier = modifier
+            .fillMaxSize()
+            .onSizeChanged { vTotalWidthPx = it.width },
+    ) {
+        val vClampedFirstPx = if (vTotalWidthPx > 0)
+            vFirstWidthPx.coerceIn(vMinFirstPx, (vTotalWidthPx - vDividerPx - vMinSecondPx).coerceAtLeast(vMinFirstPx))
+        else vFirstWidthPx
+        val vSecondWidthPx = (vTotalWidthPx - vClampedFirstPx - vDividerPx).coerceAtLeast(0)
+
+        Box(modifier = Modifier.width(with(vDensity) { vClampedFirstPx.toDp() }).fillMaxHeight()) { first() }
+
+        // Solid divider that fills its own slot - what you see is exactly what
+        // you can grab. Hover or an in-progress drag just changes the colour (no
+        // size change → no layout shift, and no flicker when the pointer briefly
+        // leaves the slot mid-drag).
+        val vActive = vDividerHover || vDragging
+        Box(
+            modifier = Modifier
+                .width(SplitPaneDefaults.DividerThickness)
+                .fillMaxHeight()
+                .background(if (vActive) dividerHoverColor else dividerColor)
+                .hoverable(vDividerSource)
+                .pointerInput(Unit) {
+                    detectDragGestures(
+                        onDragStart = { vDragging = true },
+                        onDragEnd = { vDragging = false },
+                        onDragCancel = { vDragging = false },
+                        onDrag = { _, delta ->
+                            val vMax = (vTotalWidthPx - vDividerPx - vMinSecondPx).coerceAtLeast(vMinFirstPx)
+                            vFirstWidthPx = (vFirstWidthPx + delta.x.toInt()).coerceIn(vMinFirstPx, vMax)
+                        },
+                    )
+                },
+        )
+
+        Box(modifier = Modifier.width(with(vDensity) { vSecondWidthPx.toDp() }).fillMaxHeight()) { second() }
+    }
+}
+
+object SplitPaneDefaults {
+    val DividerThickness: Dp = 4.dp        // divider width = hit/drag area (solid; what you see is what you grab)
+}

apidemo/src/jvmMain/kotlin/Fonts.jvm.kt

@@ -0,0 +1,35 @@
+package apidemo
+
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.platform.Font
+
+// ==================
+// MARK: Monospace body font - JVM actuals (classpath font/ staged by
+// jvmProcessResources)
+// ==================
+
+actual val monoFontFamily: FontFamily? by lazy {
+    val vBytes = object {}.javaClass.getResourceAsStream("/font/NotoSansMono.ttf")?.use { it.readBytes() }
+    if (vBytes == null) {
+        println("apidemo: NotoSansMono.ttf not on the classpath - body uses the default font")
+        null
+    } else {
+        FontFamily(Font(identity = kMonoFamily, data = vBytes))
+    }
+}
+
+actual val monoFontFamilyName: String? by lazy {
+    if (monoFontFamily != null) kMonoFamily else null
+}
+
+/** The JVM leg would otherwise inherit a SYSTEM font here; load the same bundled
+NotoSans the native build uses so the two stacks are comparable. */
+actual val defaultFontFamily: FontFamily? by lazy {
+    val vBytes = object {}.javaClass.getResourceAsStream("/font/NotoSans.ttf")?.use { it.readBytes() }
+    if (vBytes == null) {
+        println("apidemo: NotoSans.ttf not on the classpath - using the platform default font")
+        null
+    } else {
+        FontFamily(Font(identity = kDefaultFamily, data = vBytes))
+    }
+}

apidemo/src/jvmMain/kotlin/MainJvm.kt

@@ -0,0 +1,107 @@
+package apidemo
+
+import androidx.compose.runtime.remember
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.ImageComposeScene
+import androidx.compose.ui.graphics.painter.BitmapPainter
+import androidx.compose.ui.platform.InfiniteAnimationPolicy
+import androidx.compose.ui.res.useResource
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Window
+import androidx.compose.ui.window.application
+import androidx.compose.ui.window.rememberWindowState
+import apidemo.compat.jvmOnCloseRequest
+import apidemo.compat.jvmOnKeyShortcut
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import org.jetbrains.compose.resources.decodeToImageBitmap
+import org.jetbrains.skia.EncodedImageFormat
+import java.io.File
+
+// The JVM comparison app's entry point. Runs the SAME shared App() as the
+// native :apidemo, but on Compose Desktop (JVM) against upstream
+// org.jetbrains.compose. Client-certificate (mTLS) features are native-only
+// (they drive the bundled libcurl); the jvm actuals report that instead.
+//
+//   --screenshot=<path.png>   render headlessly to quiescence, write, exit
+//
+// The screenshot mode is the JVM half of the native-vs-JVM drift check; the
+// native half is `apidemo.exe --screenshot=<path.bmp>`. Both render offscreen
+// (ImageComposeScene here, a GPU readback there), so neither needs a visible
+// window and the comparison is unaffected by whatever is on screen.
+fun main(args: Array<String>) {
+    val screenshot = args.firstOrNull { it.startsWith("--screenshot=") }?.substringAfter('=')
+    if (screenshot != null) {
+        screenshotApp(File(screenshot), kWidth, kHeight)
+        return
+    }
+    runInteractive()
+}
+
+private const val kWidth = 1240
+private const val kHeight = 820
+
+private fun runInteractive() = application {
+    // Voltic window icon (mirrors the native window icon). Staged onto the
+    // classpath at icon/ by jvmProcessResources.
+    val vIcon = remember {
+        BitmapPainter(useResource("icon/voltic-icon-256.png") { it.readAllBytes().decodeToImageBitmap() })
+    }
+    Window(
+        // The shared App installs a persist-then-close hook (InstallWindowHooks).
+        onCloseRequest = { if (jvmOnCloseRequest?.invoke() != false) exitApplication() },
+        onPreviewKeyEvent = { jvmOnKeyShortcut?.invoke(it) ?: false },
+        title = "API Manager - JVM (upstream Compose)",
+        icon = vIcon,
+        state = rememberWindowState(width = kWidth.dp, height = kHeight.dp),
+    ) {
+        App()
+    }
+}
+
+// ==================
+// MARK: Headless screenshot (drift check vs the native leg)
+// ==================
+
+private const val kFrameNanos = 16_666_667L
+private const val kMaxFrames = 300
+
+/** Infinite animations would never let the scene go quiet; upstream's test policy
+freezes them at their initial value (same trick :demo's parity leg uses). */
+private object CancelInfiniteAnimations : InfiniteAnimationPolicy {
+    override suspend fun <R> onInfiniteOperation(block: suspend () -> R): R =
+        throw CancellationException("infinite animations disabled for the drift screenshot")
+}
+
+/** Render [App] offscreen at density 1 - matching the native leg, which lays out in
+physical pixels - stepping a virtual 60fps clock until the scene stops invalidating. */
+@OptIn(ExperimentalComposeUiApi::class)
+private fun screenshotApp(outFile: File, width: Int, height: Int) {
+    outFile.parentFile?.mkdirs()
+    val scene = ImageComposeScene(
+        width, height, density = Density(1f),
+        coroutineContext = Dispatchers.Unconfined + CancelInfiniteAnimations,
+    ) {
+        App()
+    }
+    try {
+        var nanos = 0L
+        var frames = 0
+        var image = scene.render(nanos)
+        while (scene.hasInvalidations() && frames < kMaxFrames) {
+            nanos += kFrameNanos
+            image = scene.render(nanos)
+            frames++
+        }
+        val png = image.encodeToData(EncodedImageFormat.PNG)
+        if (png == null) {
+            println("jvm screenshot: PNG encode failed")
+            return
+        }
+        outFile.writeBytes(png.bytes)
+        println("jvm screenshot: ${outFile.path} (settled after $frames frame(s))")
+    } finally {
+        scene.close()
+    }
+}

apidemo/src/jvmMain/kotlin/TlsJvm.kt

@@ -0,0 +1,25 @@
+package apidemo
+
+// ==================
+// MARK: TLS chain / client-certificate - JVM actuals (native-only feature)
+// ==================
+// The native builds drive the bundled libcurl (CURLOPT_SSLCERT / CERTINFO);
+// there is no libcurl on the jvm parity stack, so both entry points report
+// the limitation instead of half-implementing it over JSSE.
+
+private const val kNativeOnly =
+    "Client-certificate (mTLS) features need the native build - they drive the bundled libcurl directly."
+
+actual fun inspectTlsChain(inReq: ApiRequest): TlsChain = TlsChain(emptyList(), kNativeOnly)
+
+actual fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse = ApiResponse(
+    status = 0,
+    statusText = "",
+    timeMs = 0,
+    sizeBytes = 0,
+    headers = emptyList(),
+    body = "",
+    error = kNativeOnly,
+)
+
+actual fun sweepTempClientCerts() {}

apidemo/src/jvmMain/kotlin/compat/Compat.jvm.kt

@@ -0,0 +1,165 @@
+@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class)
+
+package apidemo.compat
+
+import androidx.compose.runtime.*
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.painter.BitmapPainter
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.graphics.toComposeImageBitmap
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.platform.ClipEntry
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.TextMeasurer
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.createFontFamilyResolver
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.sp
+import apidemo.monoFontFamily
+import org.jetbrains.compose.resources.decodeToSvgPainter
+import org.jetbrains.skia.Image
+import java.awt.Desktop
+import java.awt.EventQueue
+import java.awt.FileDialog
+import java.awt.Frame
+import java.awt.datatransfer.StringSelection
+import java.io.File
+
+// ==================
+// MARK: JVM actuals - AWT + upstream Compose Desktop
+// ==================
+
+private val kIsWindows = System.getProperty("os.name").startsWith("Windows")
+private val kIsMac = System.getProperty("os.name").startsWith("Mac")
+
+internal actual val systemFileSystem: okio.FileSystem = okio.FileSystem.SYSTEM
+
+actual fun createApiHttpClient(): io.ktor.client.HttpClient =
+    io.ktor.client.HttpClient(io.ktor.client.engine.cio.CIO)
+
+// ============
+//  Window hooks - the shared App installs them; MainJvm wires them into the
+//  upstream Window() (onCloseRequest / onPreviewKeyEvent).
+
+internal var jvmOnCloseRequest: (() -> Boolean)? = null
+internal var jvmOnKeyShortcut: ((KeyEvent) -> Boolean)? = null
+
+@Composable
+actual fun InstallWindowHooks(inOnCloseRequest: () -> Boolean, inOnKeyShortcut: (KeyEvent) -> Boolean) {
+    androidx.compose.runtime.DisposableEffect(inOnCloseRequest, inOnKeyShortcut) {
+        jvmOnCloseRequest = inOnCloseRequest
+        jvmOnKeyShortcut = inOnKeyShortcut
+        onDispose { jvmOnCloseRequest = null; jvmOnKeyShortcut = null }
+    }
+}
+
+/** Mirrors SDL_GetPrefPath's layout: <os user-data dir>/<org>/<app>/ with a
+trailing separator, created on demand. */
+actual fun appDataDir(inOrg: String, inApp: String): String? {
+    val vHome = System.getProperty("user.home") ?: return null
+    val vBase = when {
+        kIsWindows -> System.getenv("APPDATA") ?: "$vHome/AppData/Roaming"
+        kIsMac -> "$vHome/Library/Application Support"
+        else -> System.getenv("XDG_DATA_HOME") ?: "$vHome/.local/share"
+    }
+    val vDir = File(File(vBase, inOrg), inApp)
+    if (!vDir.exists() && !vDir.mkdirs()) return null
+    return vDir.absolutePath + File.separator
+}
+
+/** Opens the path's containing folder (AWT has no cross-platform "select in
+file manager"); fire-and-forget off the EDT. */
+actual fun revealInFileManager(inPath: String, inOnResult: ((Boolean) -> Unit)?) {
+    Thread {
+        val vOk = runCatching {
+            val vFile = File(inPath)
+            Desktop.getDesktop().open(if (vFile.isDirectory) vFile else vFile.parentFile ?: vFile)
+        }.isSuccess
+        inOnResult?.invoke(vOk)
+    }.apply { isDaemon = true }.start()
+}
+
+actual fun fileManagerName(): String = when {
+    kIsWindows -> "Explorer"
+    kIsMac -> "Finder"
+    else -> "Files"
+}
+
+/** AWT FileDialog runs its own nested event loop, so invoking from the EDT
+(where Compose Desktop also runs) keeps the UI serviced while modal. */
+actual fun showSaveFileDialog(inDefaultName: String?, inOnResult: (String?) -> Unit) {
+    EventQueue.invokeLater {
+        val vDlg = FileDialog(null as Frame?, "Save", FileDialog.SAVE)
+        inDefaultName?.let { vDlg.file = it }
+        vDlg.isVisible = true
+        inOnResult(vDlg.file?.let { vDlg.directory + it })
+    }
+}
+
+actual fun showOpenFileDialog(inOnResult: (String?) -> Unit) {
+    EventQueue.invokeLater {
+        val vDlg = FileDialog(null as Frame?, "Open", FileDialog.LOAD)
+        vDlg.isVisible = true
+        inOnResult(vDlg.file?.let { vDlg.directory + it })
+    }
+}
+
+/** Upstream desktop's ClipEntry wraps an AWT Transferable. */
+actual fun clipEntryOfText(inText: String): ClipEntry = ClipEntry(StringSelection(inText))
+
+// ============
+//  In-memory response images
+
+private val kMemoryImages = HashMap<String, ByteArray>()
+
+actual fun registerMemoryImage(inKey: String, inBytes: ByteArray) {
+    kMemoryImages[inKey] = inBytes
+}
+
+actual fun removeMemoryImage(inKey: String) {
+    kMemoryImages.remove(inKey)
+}
+
+@Composable
+actual fun memoryImagePainter(inKey: String, inSvg: Boolean): Painter {
+    val vDensity = LocalDensity.current
+    return remember(inKey, inSvg) {
+        val vBytes = kMemoryImages[inKey]
+        runCatching {
+            if (vBytes == null) error("no bytes for $inKey")
+            if (inSvg) vBytes.inputStream().readAllBytes().decodeToSvgPainter(vDensity)
+            else BitmapPainter(Image.makeFromEncoded(vBytes).toComposeImageBitmap())
+        }.getOrElse { BitmapPainter(ImageBitmap(1, 1)) }
+    }
+}
+
+// ============
+//  Text layout
+
+/** Upstream TextMeasurer at density 1 so the px-valued font size maps 1:1
+(the caller passes an already density-scaled size). */
+private val kRowMeasurer: TextMeasurer by lazy {
+    TextMeasurer(createFontFamilyResolver(), Density(1f), LayoutDirection.Ltr)
+}
+
+actual fun wrappedRowCount(inText: String, inFontPx: Int, inMaxWidthPx: Int, inFamilyName: String?): Int =
+    runCatching {
+        kRowMeasurer.measure(
+            AnnotatedString(inText),
+            TextStyle(fontSize = inFontPx.sp, fontFamily = monoFontFamily ?: FontFamily.Monospace),
+            constraints = Constraints(maxWidth = inMaxWidthPx),
+        ).lineCount
+    }.getOrDefault(1)
+
+/** The jvm parity app only stores the preference - upstream's text pipeline has
+no global tab-width knob. Backed by state so menu checkmarks recompose. */
+private var fTabWidth by mutableStateOf(4)
+actual var editorTabWidth: Int
+    get() = fTabWidth
+    set(value) {
+        fTabWidth = value
+    }

apidemo/src/linuxMain/kotlin/ClientCertLinux.kt

@@ -1,9 +1,9 @@
 package apidemo
 
 // Linux: Ktor bundles an OpenSSL-backed libcurl, which reads PEM / DER / PKCS#12
-// certificate and key files directly — no certificate-store dance needed.
+// certificate and key files directly - no certificate-store dance needed.
 
-/* Point libcurl straight at the certificate / key files. */
+/** Point libcurl straight at the certificate / key files. */
 actual fun prepareClientCert(inReq: ApiRequest): PreparedCert =
     PreparedCert(
         sslCert = inReq.certPath,
@@ -14,9 +14,9 @@ actual fun prepareClientCert(inReq: ApiRequest): PreparedCert =
         cleanup = {},
     )
 
-/* No temporary certificate store off Windows. */
+/** No temporary certificate store off Windows. */
 actual fun sweepTempClientCerts() {}
 
-/* No OS-store issuer resolution here — just continue with the name-only issuer. */
+/** No OS-store issuer resolution here - just continue with the name-only issuer. */
 actual fun extendChain(inServerCerts: List<List<Pair<String, String>>>): List<ChainCert> =
     serverChainWithIssuerName(inServerCerts)

apidemo/src/mingwX64Main/kotlin/ClientCertWindows.kt

@@ -3,7 +3,6 @@ package apidemo
 import kotlinx.cinterop.*
 import platform.windows.*
 import kotlin.io.encoding.Base64
-import kotlin.io.encoding.ExperimentalEncodingApi
 
 // ==================
 // MARK: Windows client-certificate store import (Schannel mTLS)
@@ -12,14 +11,14 @@ import kotlin.io.encoding.ExperimentalEncodingApi
 // Windows certificate store, referenced by SHA-1 thumbprint. So for a request
 // that carries a certificate we import the cert + private key into the standard
 // CurrentUser\MY ("Personal") store, hand curl "CurrentUser\MY\<thumbprint>",
-// and delete it again the instant the request finishes — nothing accumulates.
+// and delete it again the instant the request finishes - nothing accumulates.
 //
 // Our entries are tagged (friendly name + key-container name) with a unique
 // prefix so the startup sweep can clear crash leftovers without ever touching
 // the user's own certificates.
 //
 // Kotlin/Native maps several CryptoAPI LPCSTR params to String?, which makes the
-// CryptDecodeObjectEx route (numeric struct-type sentinels) unusable — so the
+// CryptDecodeObjectEx route (numeric struct-type sentinels) unusable - so the
 // RSA private key is parsed here (ASN.1) and laid out as a CryptoAPI
 // PRIVATEKEYBLOB directly, then handed to CryptImportKey. RSA (PKCS#1 or PKCS#8)
 // and PKCS#12 are handled; EC PEM/DER is reported as unsupported with a hint.
@@ -32,20 +31,18 @@ private const val kCryptUserKeyset = 0x00001000u        // CRYPT_USER_KEYSET (no
 
 private val kEncoding: UInt = X509_ASN_ENCODING.toUInt() or PKCS_7_ASN_ENCODING.toUInt()
 
-/* Import the request's certificate into CurrentUser\MY and return a libcurl
+/** Import the request's certificate into CurrentUser\MY and return a libcurl
 store reference plus a cleanup that removes it again. */
 @OptIn(ExperimentalForeignApi::class)
-actual fun prepareClientCert(inReq: ApiRequest): PreparedCert
-	{
+actual fun prepareClientCert(inReq: ApiRequest): PreparedCert {
     val vCertBytes = readFileBytes(inReq.certPath)
-	val (vThumb, vContainer) = when (inReq.certFormat)
-		{
+    val (vThumb, vContainer) = when (inReq.certFormat) {
         CertFormat.PKCS12 -> importPkcs12(vCertBytes, inReq.certPassword)
         else -> importPemDerRsa(vCertBytes, inReq)
     }
     return PreparedCert(
         sslCert = "$kStorePath\\$vThumb",
-		sslCertType = null,                 // store reference — not a file type
+        sslCertType = null,                 // store reference - not a file type
         sslKey = null,
         sslKeyType = null,
         keyPassword = null,
@@ -57,60 +54,69 @@ actual fun prepareClientCert(inReq: ApiRequest): PreparedCert
 //  PEM / DER (RSA) → store
 // ============
 
-/* Build a cert context from PEM/DER, import its RSA private key into a named
+/** Build a cert context from PEM/DER, import its RSA private key into a named
 container, link the two, tag and add to CurrentUser\MY. Returns
 (thumbprintHex, containerName). */
 @OptIn(ExperimentalForeignApi::class)
-private fun importPemDerRsa(inCertBytes: ByteArray, inReq: ApiRequest): Pair<String, String?>
-	{
+private fun importPemDerRsa(inCertBytes: ByteArray, inReq: ApiRequest): Pair<String, String?> {
     val vCertDer = derFromMaybePem(inCertBytes, "CERTIFICATE")
     val vKeyBytes = if (inReq.keyPath.isNotBlank()) readFileBytes(inReq.keyPath) else inCertBytes
     val vKeyDer = privateKeyDer(vKeyBytes)
-		?: throw RuntimeException("No private key found — PEM/DER on Windows needs the RSA key (a key file, or a key block in the certificate file).")
-	val vBlob = try { rsaKeyDerToBlob(vKeyDer) }
-		catch (e: Throwable) { throw RuntimeException("Unsupported private key (RSA PKCS#1/PKCS#8 is supported; EC isn't yet). Convert to PKCS#12: openssl pkcs12 -export -inkey key.pem -in cert.pem -out client.p12") }
+        ?: throw RuntimeException("No private key found - PEM/DER on Windows needs the RSA key (a key file, or a key block in the certificate file).")
+    val vBlob = try {
+        rsaKeyDerToBlob(vKeyDer)
+    } catch (e: Throwable) {
+        throw RuntimeException("Unsupported private key (RSA PKCS#1/PKCS#8 is supported; EC isn't yet). Convert to PKCS#12: openssl pkcs12 -export -inkey key.pem -in cert.pem -out client.p12")
+    }
 
     val vCert = vCertDer.usePinned { vPin ->
         CertCreateCertificateContext(kEncoding, vPin.addressOf(0).reinterpret(), vCertDer.size.convert())
     } ?: winError("CertCreateCertificateContext")
 
-	try
-		{
+    try {
         val vThumb = thumbprintHex(vCert)
         val vContainer = kTagPrefix + vThumb
         importRsaIntoContainer(vContainer, vBlob)
-		try
-			{
+        try {
             linkKeyToCert(vCert, vContainer)
             tagFriendlyName(vCert, kTagPrefix + vThumb)
             addToStore(vCert)
             return vThumb to vContainer
+        } catch (e: Throwable) {
+            deleteContainer(vContainer); throw e
         }
-		catch (e: Throwable) { deleteContainer(vContainer); throw e }
+    } finally {
+        CertFreeCertificateContext(vCert)
     }
-	finally { CertFreeCertificateContext(vCert) }
 }
 
-/* Create a fresh named key container and import the RSA blob into it. */
+/** Create a fresh named key container and import the RSA blob into it. */
 @OptIn(ExperimentalForeignApi::class)
 private fun importRsaIntoContainer(inContainer: String, inBlob: ByteArray) = memScoped {
     deleteContainer(inContainer)   // drop a stale one if it somehow exists
     val vProv = alloc<ULongVar>()
     if (CryptAcquireContextW(vProv.ptr, inContainer, kProvName, PROV_RSA_FULL.toUInt(), CRYPT_NEWKEYSET.toUInt()) == 0)
         winError("CryptAcquireContext(NEWKEYSET)")
-	try
-		{
+    try {
         val vKey = alloc<ULongVar>()
         val vOk = inBlob.usePinned { vPin ->
-			CryptImportKey(vProv.value, vPin.addressOf(0).reinterpret(), inBlob.size.convert(), 0uL, CRYPT_EXPORTABLE.toUInt(), vKey.ptr)
+            CryptImportKey(
+                vProv.value,
+                vPin.addressOf(0).reinterpret(),
+                inBlob.size.convert(),
+                0uL,
+                CRYPT_EXPORTABLE.toUInt(),
+                vKey.ptr
+            )
         }
         if (vOk == 0) winError("CryptImportKey")
         CryptDestroyKey(vKey.value)
+    } finally {
+        CryptReleaseContext(vProv.value, 0u)
     }
-	finally { CryptReleaseContext(vProv.value, 0u) }
 }
 
-/* Attach the named container to the cert so Schannel can find its key. */
+/** Attach the named container to the cert so Schannel can find its key. */
 @OptIn(ExperimentalForeignApi::class)
 private fun linkKeyToCert(inCert: CPointer<CERT_CONTEXT>, inContainer: String) = memScoped {
     val vInfo = alloc<CRYPT_KEY_PROV_INFO>()
@@ -129,63 +135,86 @@ private fun linkKeyToCert(inCert: CPointer<CERT_CONTEXT>, inContainer: String) =
 //  RSA key ASN.1 → CryptoAPI PRIVATEKEYBLOB
 // ============
 
-/* Minimal DER reader for the RSA key structures. */
-private class Der(val b: ByteArray)
-	{
+/** Minimal DER reader for the RSA key structures. */
+private class Der(val b: ByteArray) {
     var p = 0
     fun tag(): Int = b[p++].toInt() and 0xFF
-	fun len(): Int
-		{
+    fun len(): Int {
         val vFirst = b[p++].toInt() and 0xFF
         if (vFirst and 0x80 == 0) return vFirst
         var vLen = 0
         repeat(vFirst and 0x7F) { vLen = (vLen shl 8) or (b[p++].toInt() and 0xFF) }
         return vLen
     }
-	fun sequence() { require(tag() == 0x30) { "SEQUENCE expected" }; len() }
+
+    fun sequence() {
+        require(tag() == 0x30) { "SEQUENCE expected" }; len()
+    }
+
     fun peek(): Int = b[p].toInt() and 0xFF
-	fun skip() { tag(); val vL = len(); p += vL }
-	fun octetString(): ByteArray { require(tag() == 0x04) { "OCTET STRING expected" }; val vL = len(); return b.copyOfRange(p, p + vL).also { p += vL } }
+    fun skip() {
+        tag()
+        val vL = len(); p += vL
+    }
+
+    fun octetString(): ByteArray {
+        require(tag() == 0x04) { "OCTET STRING expected" }
+        val vL = len(); return b.copyOfRange(p, p + vL).also { p += vL }
+    }
+
     // An INTEGER's magnitude (big-endian, leading zero stripped).
-	fun integer(): ByteArray
-		{
+    fun integer(): ByteArray {
         require(tag() == 0x02) { "INTEGER expected" }
-		val vL = len(); val vV = b.copyOfRange(p, p + vL); p += vL
+        val vL = len()
+        val vV = b.copyOfRange(p, p + vL); p += vL
         var vS = 0; while (vS < vV.size - 1 && vV[vS].toInt() == 0) vS++
         return vV.copyOfRange(vS, vV.size)
     }
 }
 
-/* Turn a PKCS#1 or PKCS#8 RSA private-key DER into a CryptoAPI PRIVATEKEYBLOB.
+/** Turn a PKCS#1 or PKCS#8 RSA private-key DER into a CryptoAPI PRIVATEKEYBLOB.
 Throws if it isn't an RSA key we can lay out. */
-private fun rsaKeyDerToBlob(inDer: ByteArray): ByteArray
-	{
+private fun rsaKeyDerToBlob(inDer: ByteArray): ByteArray {
     val vR = Der(inDer)
     vR.sequence(); vR.integer()           // outer version
-	return if (vR.peek() == 0x30)
-		{
+    return if (vR.peek() == 0x30) {
         // PKCS#8 PrivateKeyInfo: skip AlgorithmIdentifier, parse the inner key.
         vR.skip()
         parsePkcs1(vR.octetString())
-		}
-	else
+    } else
     // PKCS#1: n, e, d, p, q, dp, dq, iqmp follow the version we just read.
-		buildBlob(vR.integer(), vR.integer(), vR.integer(), vR.integer(), vR.integer(), vR.integer(), vR.integer(), vR.integer())
+        buildBlob(
+            vR.integer(),
+            vR.integer(),
+            vR.integer(),
+            vR.integer(),
+            vR.integer(),
+            vR.integer(),
+            vR.integer(),
+            vR.integer()
+        )
 }
 
-private fun parsePkcs1(inDer: ByteArray): ByteArray
-	{
+private fun parsePkcs1(inDer: ByteArray): ByteArray {
     val vR = Der(inDer)
     vR.sequence(); vR.integer()           // version
-	return buildBlob(vR.integer(), vR.integer(), vR.integer(), vR.integer(), vR.integer(), vR.integer(), vR.integer(), vR.integer())
+    return buildBlob(
+        vR.integer(),
+        vR.integer(),
+        vR.integer(),
+        vR.integer(),
+        vR.integer(),
+        vR.integer(),
+        vR.integer(),
+        vR.integer()
+    )
 }
 
-/* Lay out the MS PRIVATEKEYBLOB (all little-endian) from the RSA components. */
+/** Lay out the MS PRIVATEKEYBLOB (all little-endian) from the RSA components. */
 private fun buildBlob(
     inN: ByteArray, inE: ByteArray, inD: ByteArray,
     inP: ByteArray, inQ: ByteArray, inDp: ByteArray, inDq: ByteArray, inIq: ByteArray,
-): ByteArray
-	{
+): ByteArray {
     val vMod = inN.size            // modulus length in bytes
     val vHalf = vMod / 2
     val vOut = ArrayList<Byte>(20 + vMod * 2 + vHalf * 5)
@@ -204,19 +233,22 @@ private fun buildBlob(
     return vOut.toByteArray()
 }
 
-/* A big-endian magnitude reversed to little-endian and zero-padded to inSize. */
-private fun leField(inBe: ByteArray, inSize: Int): ByteArray
-	{
+/** A big-endian magnitude reversed to little-endian and zero-padded to inSize. */
+private fun leField(inBe: ByteArray, inSize: Int): ByteArray {
     val vOut = ByteArray(inSize)
     for (vI in inBe.indices) if (vI < inSize) vOut[vI] = inBe[inBe.size - 1 - vI]
     return vOut
 }
 
 private fun le32(inV: UInt): ByteArray =
-	byteArrayOf((inV and 0xFFu).toByte(), ((inV shr 8) and 0xFFu).toByte(), ((inV shr 16) and 0xFFu).toByte(), ((inV shr 24) and 0xFFu).toByte())
+    byteArrayOf(
+        (inV and 0xFFu).toByte(),
+        ((inV shr 8) and 0xFFu).toByte(),
+        ((inV shr 16) and 0xFFu).toByte(),
+        ((inV shr 24) and 0xFFu).toByte()
+    )
 
-private fun beToUInt(inBe: ByteArray): UInt
-	{
+private fun beToUInt(inBe: ByteArray): UInt {
     var vV = 0u
     for (vB in inBe) vV = (vV shl 8) or (vB.toInt() and 0xFF).toUInt()
     return vV
@@ -226,7 +258,7 @@ private fun beToUInt(inBe: ByteArray): UInt
 //  PKCS#12 → store
 // ============
 
-/* Import a .p12/.pfx into a memory store, then copy its cert (with the key
+/** Import a .p12/.pfx into a memory store, then copy its cert (with the key
 container PFXImportCertStore created) into CurrentUser\MY. */
 @OptIn(ExperimentalForeignApi::class)
 private fun importPkcs12(inBytes: ByteArray, inPassword: String): Pair<String, String?> = memScoped {
@@ -236,27 +268,40 @@ private fun importPkcs12(inBytes: ByteArray, inPassword: String): Pair<String, S
         vBlob.pbData = vPin.addressOf(0).reinterpret()
         val vMem = PFXImportCertStore(vBlob.ptr, inPassword, kCryptUserKeyset or CRYPT_EXPORTABLE.toUInt())
             ?: winError("PFXImportCertStore (wrong password, or not a PKCS#12 file?)")
-		try
-			{
-			val vSrc = CertEnumCertificatesInStore(vMem, null) ?: throw RuntimeException("PKCS#12 contained no certificate.")
+        try {
+            val vSrc =
+                CertEnumCertificatesInStore(vMem, null) ?: throw RuntimeException("PKCS#12 contained no certificate.")
             val vThumb = thumbprintHex(vSrc)
             val vContainer = containerNameOf(vSrc)
             tagFriendlyName(vSrc, kTagPrefix + vThumb)
             addToStore(vSrc)
             vThumb to vContainer
+        } finally {
+            CertCloseStore(vMem, 0u)
         }
-		finally { CertCloseStore(vMem, 0u) }
     }
 }
 
-/* The key-container name PFXImportCertStore assigned to a cert (from its
+/** The key-container name PFXImportCertStore assigned to a cert (from its
 CERT_KEY_PROV_INFO), so cleanup can delete it. */
 @OptIn(ExperimentalForeignApi::class)
 private fun containerNameOf(inCert: CPointer<CERT_CONTEXT>): String? = memScoped {
     val vLen = alloc<UIntVar>()
-	if (CertGetCertificateContextProperty(inCert, CERT_KEY_PROV_INFO_PROP_ID.toUInt(), null, vLen.ptr) == 0) return@memScoped null
+    if (CertGetCertificateContextProperty(
+            inCert,
+            CERT_KEY_PROV_INFO_PROP_ID.toUInt(),
+            null,
+            vLen.ptr
+        ) == 0
+    ) return@memScoped null
     val vBuf = allocArray<ByteVar>(vLen.value.toInt())
-	if (CertGetCertificateContextProperty(inCert, CERT_KEY_PROV_INFO_PROP_ID.toUInt(), vBuf, vLen.ptr) == 0) return@memScoped null
+    if (CertGetCertificateContextProperty(
+            inCert,
+            CERT_KEY_PROV_INFO_PROP_ID.toUInt(),
+            vBuf,
+            vLen.ptr
+        ) == 0
+    ) return@memScoped null
     vBuf.reinterpret<CRYPT_KEY_PROV_INFO>().pointed.pwszContainerName?.toKStringFromUtf16()
 }
 
@@ -264,7 +309,7 @@ private fun containerNameOf(inCert: CPointer<CERT_CONTEXT>): String? = memScoped
 //  Shared store helpers
 // ============
 
-/* Tag a cert with our friendly-name prefix so the startup sweep recognises it. */
+/** Tag a cert with our friendly-name prefix so the startup sweep recognises it. */
 @OptIn(ExperimentalForeignApi::class)
 private fun tagFriendlyName(inCert: CPointer<CERT_CONTEXT>, inName: String) = memScoped {
     val vBlob = alloc<CRYPT_INTEGER_BLOB>()
@@ -273,38 +318,40 @@ private fun tagFriendlyName(inCert: CPointer<CERT_CONTEXT>, inName: String) = me
     CertSetCertificateContextProperty(inCert, CERT_FRIENDLY_NAME_PROP_ID.toUInt(), 0u, vBlob.ptr)
 }
 
-/* Add a cert context to CurrentUser\MY (replacing any same-thumbprint entry). */
+/** Add a cert context to CurrentUser\MY (replacing any same-thumbprint entry). */
 @OptIn(ExperimentalForeignApi::class)
-private fun addToStore(inCert: CPointer<CERT_CONTEXT>)
-	{
+private fun addToStore(inCert: CPointer<CERT_CONTEXT>) {
     val vStore = openMyStore() ?: winError("CertOpenSystemStore(MY)")
-	try
-		{
+    try {
         if (CertAddCertificateContextToStore(vStore, inCert, CERT_STORE_ADD_REPLACE_EXISTING.toUInt(), null) == 0)
             winError("CertAddCertificateContextToStore")
+    } finally {
+        CertCloseStore(vStore, 0u)
     }
-	finally { CertCloseStore(vStore, 0u) }
 }
 
-/* Open CurrentUser\MY (the current user's Personal store). */
+/** Open CurrentUser\MY (the current user's Personal store). */
 @OptIn(ExperimentalForeignApi::class)
 private fun openMyStore() = CertOpenSystemStoreW(0.convert(), kStoreName)
 
-/* The SHA-1 thumbprint of a cert as uppercase hex. */
+/** The SHA-1 thumbprint of a cert as uppercase hex. */
 @OptIn(ExperimentalForeignApi::class)
 private fun thumbprintHex(inCert: CPointer<CERT_CONTEXT>): String = memScoped {
     val vLen = alloc<UIntVar>().apply { value = 20u }
     val vBuf = allocArray<UByteVar>(20)
     if (CertGetCertificateContextProperty(inCert, CERT_SHA1_HASH_PROP_ID.toUInt(), vBuf, vLen.ptr) == 0)
         winError("CertGetCertificateContextProperty(SHA1)")
-	buildString { for (vI in 0 until vLen.value.toInt()) append(vBuf[vI].toInt().toString(16).uppercase().padStart(2, '0')) }
+    buildString {
+        for (vI in 0 until vLen.value.toInt()) append(
+            vBuf[vI].toInt().toString(16).uppercase().padStart(2, '0')
+        )
+    }
 }
 
-/* Remove a temporary cert (by thumbprint) from CurrentUser\MY and delete its
+/** Remove a temporary cert (by thumbprint) from CurrentUser\MY and delete its
 key container. Called per-request in finally; ignores what's already gone. */
 @OptIn(ExperimentalForeignApi::class)
-private fun deleteTempCert(inThumbHex: String, inContainer: String?)
-	{
+private fun deleteTempCert(inThumbHex: String, inContainer: String?) {
     val vStore = openMyStore()
     if (vStore != null) memScoped {
         val vHash = hexToBytes(inThumbHex)
@@ -320,23 +367,21 @@ private fun deleteTempCert(inThumbHex: String, inContainer: String?)
     if (inContainer != null) deleteContainer(inContainer)
 }
 
-/* Delete a named key container (best-effort). */
+/** Delete a named key container (best-effort). */
 @OptIn(ExperimentalForeignApi::class)
 private fun deleteContainer(inContainer: String) = memScoped {
     val vProv = alloc<ULongVar>()
     CryptAcquireContextW(vProv.ptr, inContainer, kProvName, PROV_RSA_FULL.toUInt(), CRYPT_DELETEKEYSET.toUInt())
 }
 
-/* Remove every temp cert we ever added (prefix-tagged) plus its container — for
+/** Remove every temp cert we ever added (prefix-tagged) plus its container - for
 clearing crash leftovers at startup. The user's own certs are never matched. */
 @OptIn(ExperimentalForeignApi::class)
-actual fun sweepTempClientCerts()
-	{
+actual fun sweepTempClientCerts() {
     val vStore = openMyStore() ?: return
     val vDoomed = mutableListOf<Pair<String, String?>>()   // thumbprint, container
     var vCert = CertEnumCertificatesInStore(vStore, null)
-	while (vCert != null)
-		{
+    while (vCert != null) {
         val vFriendly = friendlyNameOf(vCert)
         if (vFriendly != null && vFriendly.startsWith(kTagPrefix))
             vDoomed.add(thumbprintHex(vCert) to containerNameOf(vCert))
@@ -346,13 +391,25 @@ actual fun sweepTempClientCerts()
     vDoomed.forEach { deleteTempCert(it.first, it.second) }
 }
 
-/* A cert's friendly name, or null. */
+/** A cert's friendly name, or null. */
 @OptIn(ExperimentalForeignApi::class)
 private fun friendlyNameOf(inCert: CPointer<CERT_CONTEXT>): String? = memScoped {
     val vLen = alloc<UIntVar>()
-	if (CertGetCertificateContextProperty(inCert, CERT_FRIENDLY_NAME_PROP_ID.toUInt(), null, vLen.ptr) == 0) return@memScoped null
+    if (CertGetCertificateContextProperty(
+            inCert,
+            CERT_FRIENDLY_NAME_PROP_ID.toUInt(),
+            null,
+            vLen.ptr
+        ) == 0
+    ) return@memScoped null
     val vBuf = allocArray<ByteVar>(vLen.value.toInt())
-	if (CertGetCertificateContextProperty(inCert, CERT_FRIENDLY_NAME_PROP_ID.toUInt(), vBuf, vLen.ptr) == 0) return@memScoped null
+    if (CertGetCertificateContextProperty(
+            inCert,
+            CERT_FRIENDLY_NAME_PROP_ID.toUInt(),
+            vBuf,
+            vLen.ptr
+        ) == 0
+    ) return@memScoped null
     vBuf.reinterpret<UShortVar>().toKStringFromUtf16()
 }
 
@@ -360,61 +417,58 @@ private fun friendlyNameOf(inCert: CPointer<CERT_CONTEXT>): String? = memScoped
 //  Chain extension via the OS certificate store
 // ============
 
-/* Continue the server's chain by asking the OS to build it from the leaf — this
+/** Continue the server's chain by asking the OS to build it from the leaf - this
 pulls intermediates/roots from the Windows store with full info. Falls back to
 a name-only issuer if the OS can't (or the leaf can't be parsed). */
 @OptIn(ExperimentalForeignApi::class)
-actual fun extendChain(inServerCerts: List<List<Pair<String, String>>>): List<ChainCert>
-	{
+actual fun extendChain(inServerCerts: List<List<Pair<String, String>>>): List<ChainCert> {
     val vLeafPem = inServerCerts.firstOrNull()?.let { certFieldOf(it, "Cert") }
         ?: return serverChainWithIssuerName(inServerCerts)
     val vOs = runCatching { osChain(vLeafPem, inServerCerts.size) }.getOrNull()
     return if (!vOs.isNullOrEmpty()) vOs else serverChainWithIssuerName(inServerCerts)
 }
 
-/* Build the full chain from the leaf via CertGetCertificateChain (OS store). */
+/** Build the full chain from the leaf via CertGetCertificateChain (OS store). */
 @OptIn(ExperimentalForeignApi::class)
 private fun osChain(inLeafPem: String, inServerCount: Int): List<ChainCert> = memScoped {
     val vDer = derFromMaybePem(inLeafPem.encodeToByteArray(), "CERTIFICATE")
-	val vLeaf = vDer.usePinned { CertCreateCertificateContext(kEncoding, it.addressOf(0).reinterpret(), vDer.size.convert()) }
+    val vLeaf =
+        vDer.usePinned { CertCreateCertificateContext(kEncoding, it.addressOf(0).reinterpret(), vDer.size.convert()) }
             ?: return@memScoped emptyList()
-	try
-		{
+    try {
         val vPara = alloc<CERT_CHAIN_PARA>()
         vPara.cbSize = sizeOf<CERT_CHAIN_PARA>().convert()
         val vChainPtr = alloc<CPointerVar<CERT_CHAIN_CONTEXT>>()
         if (CertGetCertificateChain(null, vLeaf, null, null, vPara.ptr, 0u, null, vChainPtr.ptr) == 0)
             return@memScoped emptyList()
         val vChain = vChainPtr.value ?: return@memScoped emptyList()
-		try
-			{
+        try {
             val vSimple = vChain.pointed.rgpChain?.get(0)?.pointed ?: return@memScoped emptyList()
             val vElems = vSimple.rgpElement ?: return@memScoped emptyList()
             val vResult = ArrayList<ChainCert>()
-			for (vI in 0 until vSimple.cElement.toInt())
-				{
+            for (vI in 0 until vSimple.cElement.toInt()) {
                 val vCtx = vElems[vI]?.pointed?.pCertContext ?: continue
                 vResult.add(ChainCert(certFieldsFromContext(vCtx), vI < inServerCount))
             }
             // If the chain didn't reach a self-signed root, end with the name only.
             val vLast = vResult.lastOrNull()
-			if (vLast != null)
-				{
+            if (vLast != null) {
                 val vSub = certFieldOf(vLast.fields, "Subject")
                 val vIss = certFieldOf(vLast.fields, "Issuer")
                 if (!vIss.isNullOrBlank() && vIss != vSub) vResult.add(ChainCert(listOf("Subject" to vIss), false))
             }
             vResult
+        } finally {
+            CertFreeCertificateChain(vChain)
         }
-		finally { CertFreeCertificateChain(vChain) }
+    } finally {
+        CertFreeCertificateContext(vLeaf)
     }
-	finally { CertFreeCertificateContext(vLeaf) }
 }
 
-/* Subject / Issuer (RDN strings) + the PEM, read from a cert context. */
+/** Subject / Issuer (RDN strings) + the PEM, read from a cert context. */
 @OptIn(ExperimentalForeignApi::class)
-private fun certFieldsFromContext(inCtx: CPointer<CERT_CONTEXT>): List<Pair<String, String>>
-	{
+private fun certFieldsFromContext(inCtx: CPointer<CERT_CONTEXT>): List<Pair<String, String>> {
     val vFields = ArrayList<Pair<String, String>>()
     certNameString(inCtx, 0u)?.let { vFields.add("Subject" to it) }
     certNameString(inCtx, CERT_NAME_ISSUER_FLAG.toUInt())?.let { vFields.add("Issuer" to it) }
@@ -422,7 +476,7 @@ private fun certFieldsFromContext(inCtx: CPointer<CERT_CONTEXT>): List<Pair<Stri
     return vFields
 }
 
-/* A cert's Subject (inFlags=0) or Issuer (CERT_NAME_ISSUER_FLAG) as an X.500 string. */
+/** A cert's Subject (inFlags=0) or Issuer (CERT_NAME_ISSUER_FLAG) as an X.500 string. */
 @OptIn(ExperimentalForeignApi::class)
 private fun certNameString(inCtx: CPointer<CERT_CONTEXT>, inFlags: UInt): String? = memScoped {
     val vType = alloc<UIntVar>().apply { value = CERT_X500_NAME_STR.toUInt() }
@@ -433,15 +487,29 @@ private fun certNameString(inCtx: CPointer<CERT_CONTEXT>, inFlags: UInt): String
     vBuf.toKString()
 }
 
-/* The PEM (base64-with-header) of a cert context. */
+/** The PEM (base64-with-header) of a cert context. */
 @OptIn(ExperimentalForeignApi::class)
 private fun certPem(inCtx: CPointer<CERT_CONTEXT>): String? = memScoped {
     val vData = inCtx.pointed.pbCertEncoded ?: return@memScoped null
     val vSize = inCtx.pointed.cbCertEncoded
     val vLen = alloc<UIntVar>()
-	if (CryptBinaryToStringA(vData, vSize, CRYPT_STRING_BASE64HEADER.toUInt(), null, vLen.ptr) == 0) return@memScoped null
+    if (CryptBinaryToStringA(
+            vData,
+            vSize,
+            CRYPT_STRING_BASE64HEADER.toUInt(),
+            null,
+            vLen.ptr
+        ) == 0
+    ) return@memScoped null
     val vBuf = allocArray<ByteVar>(vLen.value.toInt())
-	if (CryptBinaryToStringA(vData, vSize, CRYPT_STRING_BASE64HEADER.toUInt(), vBuf, vLen.ptr) == 0) return@memScoped null
+    if (CryptBinaryToStringA(
+            vData,
+            vSize,
+            CRYPT_STRING_BASE64HEADER.toUInt(),
+            vBuf,
+            vLen.ptr
+        ) == 0
+    ) return@memScoped null
     vBuf.toKString()
 }
 
@@ -449,47 +517,43 @@ private fun certPem(inCtx: CPointer<CERT_CONTEXT>): String? = memScoped {
 //  Small helpers
 // ============
 
-/* Decode a PEM block (by label) to DER, or pass bytes through if already DER. */
-@OptIn(ExperimentalEncodingApi::class)
-private fun derFromMaybePem(inBytes: ByteArray, inLabel: String): ByteArray
-	{
+/** Decode a PEM block (by label) to DER, or pass bytes through if already DER. */
+private fun derFromMaybePem(inBytes: ByteArray, inLabel: String): ByteArray {
     val vText = inBytes.decodeToString()
     if (!vText.contains("-----BEGIN")) return inBytes
     val vBegin = vText.indexOf("-----BEGIN $inLabel-----")
     val vEnd = vText.indexOf("-----END $inLabel-----")
     val vBlock = if (vBegin >= 0 && vEnd >= 0) vText.substring(vBegin, vEnd) else vText
-	return Base64.Default.decode(pemBody(vBlock))
+    return Base64.decode(pemBody(vBlock))
 }
 
-/* Extract + DER-decode the first PRIVATE KEY block from PEM text, or pass DER
+/** Extract + DER-decode the first PRIVATE KEY block from PEM text, or pass DER
 bytes through. Null if no key. */
-@OptIn(ExperimentalEncodingApi::class)
-private fun privateKeyDer(inBytes: ByteArray): ByteArray?
-	{
+private fun privateKeyDer(inBytes: ByteArray): ByteArray? {
     val vText = inBytes.decodeToString()
     if (!vText.contains("-----BEGIN")) return inBytes   // already DER
     val vMatch = Regex("-----BEGIN [A-Z 0-9]*PRIVATE KEY-----[\\s\\S]*?-----END [A-Z 0-9]*PRIVATE KEY-----").find(vText)
         ?: return null
-	return Base64.Default.decode(pemBody(vMatch.value))
+    return Base64.decode(pemBody(vMatch.value))
 }
 
-/* The base64 body of a PEM block (drop the BEGIN/END lines and whitespace). */
+/** The base64 body of a PEM block (drop the BEGIN/END lines and whitespace). */
 private fun pemBody(inPem: String): String =
     inPem.lineSequence().filterNot { it.startsWith("-----") }.joinToString("") { it.trim() }
 
 private fun hexToBytes(inHex: String): ByteArray =
     ByteArray(inHex.length / 2) { inHex.substring(it * 2, it * 2 + 2).toInt(16).toByte() }
 
-/* Read a null-terminated UTF-16 (wide) string. */
+/** Read a null-terminated UTF-16 (wide) string. */
 @OptIn(ExperimentalForeignApi::class)
-private fun CPointer<UShortVar>.toKStringFromUtf16(): String
-	{
+private fun CPointer<UShortVar>.toKStringFromUtf16(): String {
     val vSb = StringBuilder()
     var vI = 0
-	while (true) { val vC = this[vI].toInt(); if (vC == 0) break; vSb.append(vC.toChar()); vI++ }
+    while (true) {
+        val vC = this[vI].toInt(); if (vC == 0) break; vSb.append(vC.toChar()); vI++
+    }
     return vSb.toString()
 }
 
-@OptIn(ExperimentalForeignApi::class)
 private fun winError(inWhat: String): Nothing =
     throw RuntimeException("$inWhat failed (Windows error 0x${GetLastError().toString(16)})")

apidemo/src/nativeMain/kotlin/CertParse.kt

@@ -1,202 +0,0 @@
-package apidemo
-
-import kotlin.io.encoding.Base64
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-// ==================
-// MARK: Minimal X.509 / DER parser
-// ==================
-// Some TLS backends (notably Schannel on Windows) expose only Subject / Issuer /
-// the PEM through CURLINFO_CERTINFO — not the parsed fields (validity, serial,
-// SAN, algorithms). Since every backend gives us the PEM, we parse it ourselves
-// to fill in the detail. Just enough ASN.1 to walk a Certificate; anything odd
-// is swallowed and the field is simply omitted.
-
-/* Parsed certificate detail, all nullable/empty when not found or unparseable. */
-class CertDetails(
-	val version: Int?,                 // X.509 version (1/2/3)
-	val serial: String?,               // colon-separated hex
-	val sigAlg: String?,               // signature algorithm (friendly name or OID)
-	val keyAlg: String?,               // public-key algorithm (friendly name or OID)
-	val notBefore: String?,            // "YYYY-MM-DD HH:MM:SS UTC"
-	val notAfter: String?,
-	val sans: List<String>,            // dNSName SANs
-	)
-
-// ============
-//  DER reader: each next() returns [tag, contentStart, contentEnd] and advances.
-private class DerReader(val b: ByteArray, var pos: Int, val end: Int)
-	{
-	fun hasMore() = pos < end
-	fun next(): IntArray
-		{
-		val vTag = b[pos++].toInt() and 0xFF
-		var vLen = b[pos++].toInt() and 0xFF
-		if (vLen and 0x80 != 0)
-			{
-			val vN = vLen and 0x7F
-			vLen = 0
-			repeat(vN) { vLen = (vLen shl 8) or (b[pos++].toInt() and 0xFF) }
-			}
-		val vStart = pos
-		pos += vLen
-		return intArrayOf(vTag, vStart, vStart + vLen)
-		}
-	}
-
-/* Parse the PEM into the fields the chain dialog shows. Returns null on any
-   structural surprise (the UI just falls back to whatever the backend gave). */
-fun parseCertDetails(inPem: String): CertDetails?
-	{
-	val vDer = pemToDer(inPem) ?: return null
-	return try
-		{
-		val vCert = DerReader(vDer, 0, vDer.size).next()                 // Certificate SEQUENCE
-		val vCertInner = DerReader(vDer, vCert[1], vCert[2])
-		val vTbs = vCertInner.next()                                     // tbsCertificate
-		val vSigAlg = firstOidName(vDer, vCertInner.next())              // signatureAlgorithm
-
-		val vT = DerReader(vDer, vTbs[1], vTbs[2])
-		var vE = vT.next()
-		var vVersion: Int? = null
-		if (vE[0] == 0xA0)                                               // [0] EXPLICIT version
-			{
-			val vVi = DerReader(vDer, vE[1], vE[2]).next()
-			if (vVi[0] == 0x02 && vVi[2] > vVi[1]) vVersion = (vDer[vVi[1]].toInt() and 0xFF) + 1
-			vE = vT.next()
-			}
-		val vSerial = if (vE[0] == 0x02) bytesToHex(vDer, vE[1], vE[2]) else null
-		vT.next()                                                        // signature
-		vT.next()                                                        // issuer
-		val vValidity = vT.next()                                        // validity SEQUENCE
-		val vVr = DerReader(vDer, vValidity[1], vValidity[2])
-		val vNotBefore = parseAsn1Time(vDer, vVr.next())
-		val vNotAfter = parseAsn1Time(vDer, vVr.next())
-		vT.next()                                                        // subject
-		val vSpki = vT.next()                                            // subjectPublicKeyInfo SEQUENCE
-		// SPKI = SEQUENCE { algorithm AlgorithmIdentifier SEQUENCE { OID … }, key BIT STRING }
-		val vKeyAlg = firstOidName(vDer, DerReader(vDer, vSpki[1], vSpki[2]).next())
-		val vSans = ArrayList<String>()
-		while (vT.hasMore())
-			{
-			val vX = vT.next()
-			if (vX[0] == 0xA3) parseSans(vDer, vX, vSans)                // extensions [3]
-			}
-		CertDetails(vVersion, vSerial, vSigAlg, vKeyAlg, vNotBefore, vNotAfter, vSans)
-		}
-	catch (e: Throwable) { null }
-	}
-
-// ============
-//  Helpers
-
-@OptIn(ExperimentalEncodingApi::class)
-private fun pemToDer(inPem: String): ByteArray?
-	{
-	val vBody = inPem.lineSequence().filterNot { it.contains("-----") }.joinToString("") { it.trim() }
-	if (vBody.isBlank()) return null
-	return try { Base64.decode(vBody) } catch (e: Throwable) { null }
-	}
-
-/* The friendly name (or dotted OID) of the first child OID of a SEQUENCE — used
-   for signatureAlgorithm and subjectPublicKeyInfo's AlgorithmIdentifier. */
-private fun firstOidName(inB: ByteArray, inSeq: IntArray): String?
-	{
-	val vR = DerReader(inB, inSeq[1], inSeq[2])
-	val vOid = vR.next()
-	if (vOid[0] != 0x06) return null
-	return oidName(oidToString(inB, vOid[1], vOid[2]))
-	}
-
-/* Pull dNSName entries out of the SubjectAltName extension under [3]. */
-private fun parseSans(inB: ByteArray, inExt3: IntArray, inOut: MutableList<String>)
-	{
-	val vSeq = DerReader(inB, inExt3[1], inExt3[2]).next()               // SEQUENCE OF Extension
-	val vEs = DerReader(inB, vSeq[1], vSeq[2])
-	while (vEs.hasMore())
-		{
-		val vExtn = vEs.next()
-		val vEr = DerReader(inB, vExtn[1], vExtn[2])
-		val vOid = vEr.next()                                           // extnID
-		// SAN OID 2.5.29.17 == bytes 55 1D 11
-		val vIsSan = vOid[2] - vOid[1] == 3 &&
-			(inB[vOid[1]].toInt() and 0xFF) == 0x55 &&
-			(inB[vOid[1] + 1].toInt() and 0xFF) == 0x1D &&
-			(inB[vOid[1] + 2].toInt() and 0xFF) == 0x11
-		var vVal = vEr.next()
-		if (vVal[0] == 0x01) vVal = vEr.next()                          // skip critical BOOLEAN
-		if (vIsSan && vVal[0] == 0x04)                                  // OCTET STRING wrapping GeneralNames
-			{
-			val vGnSeq = DerReader(inB, vVal[1], vVal[2]).next()
-			val vGn = DerReader(inB, vGnSeq[1], vGnSeq[2])
-			while (vGn.hasMore())
-				{
-				val vName = vGn.next()
-				if (vName[0] == 0x82) inOut.add(inB.copyOfRange(vName[1], vName[2]).decodeToString())  // [2] dNSName
-				}
-			}
-		}
-	}
-
-/* ASN.1 UTCTime (YYMMDD…) / GeneralizedTime (YYYYMMDD…) → readable UTC string. */
-private fun parseAsn1Time(inB: ByteArray, inTlv: IntArray): String?
-	{
-	val vS = inB.copyOfRange(inTlv[1], inTlv[2]).decodeToString()
-	return try
-		{
-		val vYear: String
-		val vRest: String
-		if (inTlv[0] == 0x18)                                           // GeneralizedTime
-			{ vYear = vS.substring(0, 4); vRest = vS.substring(4) }
-		else                                                            // UTCTime — RFC 5280 pivot at 50
-			{
-			val vYy = vS.substring(0, 2).toInt()
-			vYear = (if (vYy >= 50) "19" else "20") + vS.substring(0, 2)
-			vRest = vS.substring(2)
-			}
-		val vMo = vRest.substring(0, 2); val vDa = vRest.substring(2, 4)
-		val vHh = vRest.substring(4, 6); val vMi = vRest.substring(6, 8)
-		val vSs = if (vRest.length >= 10 && vRest[8].isDigit()) vRest.substring(8, 10) else "00"
-		"$vYear-$vMo-$vDa $vHh:$vMi:$vSs UTC"
-		}
-	catch (e: Throwable) { vS }
-	}
-
-/* Colon-separated hex of a byte range (serial number rendering). */
-private fun bytesToHex(inB: ByteArray, inFrom: Int, inTo: Int): String =
-	(inFrom until inTo).joinToString(":") { (inB[it].toInt() and 0xFF).toString(16).padStart(2, '0') }
-
-/* Decode an OID's content bytes to dotted-decimal. */
-private fun oidToString(inB: ByteArray, inFrom: Int, inTo: Int): String
-	{
-	if (inTo <= inFrom) return ""
-	val vSb = StringBuilder()
-	val vFirst = inB[inFrom].toInt() and 0xFF
-	vSb.append(vFirst / 40).append('.').append(vFirst % 40)
-	var vAcc = 0L
-	for (vI in (inFrom + 1) until inTo)
-		{
-		val vByte = inB[vI].toInt() and 0xFF
-		vAcc = (vAcc shl 7) or (vByte and 0x7F).toLong()
-		if (vByte and 0x80 == 0) { vSb.append('.').append(vAcc); vAcc = 0 }
-		}
-	return vSb.toString()
-	}
-
-/* Friendly name for the common signature / public-key OIDs, else the OID. */
-private fun oidName(inOid: String): String = when (inOid)
-	{
-	"1.2.840.113549.1.1.1" -> "RSA"
-	"1.2.840.113549.1.1.5" -> "SHA1withRSA"
-	"1.2.840.113549.1.1.11" -> "SHA256withRSA"
-	"1.2.840.113549.1.1.12" -> "SHA384withRSA"
-	"1.2.840.113549.1.1.13" -> "SHA512withRSA"
-	"1.2.840.113549.1.1.10" -> "RSASSA-PSS"
-	"1.2.840.10045.2.1" -> "EC"
-	"1.2.840.10045.4.3.2" -> "ECDSAwithSHA256"
-	"1.2.840.10045.4.3.3" -> "ECDSAwithSHA384"
-	"1.2.840.10045.4.3.4" -> "ECDSAwithSHA512"
-	"1.3.101.112" -> "Ed25519"
-	"1.3.101.113" -> "Ed448"
-	else -> inOid
-	}

apidemo/src/nativeMain/kotlin/CurlMtls.kt

@@ -1,6 +1,6 @@
 package apidemo
 
-import io.ktor.http.HttpStatusCode
+import io.ktor.http.*
 import kotlinx.cinterop.*
 import libcurl.*
 import okio.Buffer
@@ -11,7 +11,7 @@ import kotlin.time.TimeSource
 // MARK: Client-certificate (mTLS) sending via libcurl
 // ==================
 // Ktor's native engines expose no client-certificate API, so a request that
-// carries a client certificate is sent here instead — straight through the
+// carries a client certificate is sent here instead - straight through the
 // libcurl that ktor-client-curl already bundles (package `libcurl`, embedded
 // static archive; Schannel on Windows, OpenSSL on macOS/Linux). This is the
 // same TLS stack the default engine uses, so behaviour matches; we just get to
@@ -19,9 +19,9 @@ import kotlin.time.TimeSource
 //
 // The transfer is synchronous (curl_easy_perform) and runs on Dispatchers.Default
 // from HttpRunner.run(); cancellation is best-effort (an in-flight perform can't
-// be interrupted — the result is simply discarded if the caller cancelled).
+// be interrupted - the result is simply discarded if the caller cancelled).
 
-/* A client certificate readied for libcurl: the CURLOPT_SSLCERT value plus the
+/** A client certificate readied for libcurl: the CURLOPT_SSLCERT value plus the
 other SSL options to set, and a cleanup to run once the request is done.
 macOS/Linux (OpenSSL) just point curl at the files. Windows (Schannel) imports
 the cert + key into CurrentUser\MY, references it by SHA-1 thumbprint, and the
@@ -35,45 +35,32 @@ class PreparedCert(
     val cleanup: () -> Unit,
 )
 
-/* Ready the request's client certificate for libcurl (platform-specific).
+/** Ready the request's client certificate for libcurl (platform-specific).
 Throws with a user-facing message if the cert/key can't be loaded. */
 expect fun prepareClientCert(inReq: ApiRequest): PreparedCert
 
-/* Remove any temporary client certs (and their key containers) a previous run
-   left behind in the Windows store after a crash — identified by our prefix, so
-   the user's own certificates are never touched. No-op off Windows. Call once
-   at startup. */
-expect fun sweepTempClientCerts()
+// ChainCert / TlsChain and the sweepTempClientCerts / inspectTlsChain /
+// curlSendWithClientCert expects live in commonMain (TlsCommon.kt) - the UI
+// consumes them from shared code; the per-OS ClientCert*.kt actuals below the
+// native tree actualize sweepTempClientCerts directly.
 
-/* One certificate in the chain: its CURLINFO_CERTINFO-style fields (Subject /
-   Issuer / the PEM under "Cert" / dates …) and whether the server actually
-   presented it. Derived certs — an issuer resolved from the OS store, or a
-   name-only placeholder — have fromServer = false and are drawn dotted. */
-class ChainCert(val fields: List<Pair<String, String>>, val fromServer: Boolean)
-
-/* The server's TLS certificate chain. error is set instead when it couldn't be
-   fetched; fields vary by TLS backend. */
-class TlsChain(val certs: List<ChainCert>, val error: String?)
-
-/* Continue a server-presented chain with its issuer(s). Where possible the
+/** Continue a server-presented chain with its issuer(s). Where possible the
 issuer is resolved from the OS certificate store with full info; otherwise the
 chain ends with a name-only placeholder. Every derived (non-server) cert is
 flagged fromServer = false. Platform-specific (OS store on Windows). */
 expect fun extendChain(inServerCerts: List<List<Pair<String, String>>>): List<ChainCert>
 
-/* A CURLINFO_CERTINFO field by name (case-insensitive). */
+/** A CURLINFO_CERTINFO field by name (case-insensitive). */
 internal fun certFieldOf(inFields: List<Pair<String, String>>, inName: String): String? =
     inFields.firstOrNull { it.first.equals(inName, ignoreCase = true) }?.second
 
-/* Server certs as ChainCerts; if the last one isn't self-signed, append a
+/** Server certs as ChainCerts; if the last one isn't self-signed, append a
 dotted, name-only issuer so the chain visibly continues. The cross-platform
 fallback when the OS store can't (or isn't able to) resolve the real issuer. */
-internal fun serverChainWithIssuerName(inServer: List<List<Pair<String, String>>>): List<ChainCert>
-	{
+internal fun serverChainWithIssuerName(inServer: List<List<Pair<String, String>>>): List<ChainCert> {
     val vOut = inServer.map { ChainCert(it, true) }.toMutableList()
     val vLast = inServer.lastOrNull()
-	if (vLast != null)
-		{
+    if (vLast != null) {
         val vSubject = certFieldOf(vLast, "Subject")
         val vIssuer = certFieldOf(vLast, "Issuer")
         if (!vIssuer.isNullOrBlank() && vIssuer != vSubject)
@@ -82,51 +69,65 @@ internal fun serverChainWithIssuerName(inServer: List<List<Pair<String, String>>
     return vOut
 }
 
-/* Per-transfer accumulators handed to the C callbacks through a StableRef. */
-private class CurlSink
-	{
+/** Per-transfer accumulators handed to the C callbacks through a StableRef. */
+private class CurlSink {
     val body = Buffer()                 // response body bytes (already decompressed by curl)
     val headerRaw = StringBuilder()     // raw response header lines, all responses incl. redirects
 }
 
-/* Body write callback — appends each chunk to the sink's buffer. */
+/** Body write callback - appends each chunk to the sink's buffer. */
 @OptIn(ExperimentalForeignApi::class)
-private fun onCurlBody(inBuffer: CPointer<ByteVar>, inSize: size_t, inCount: size_t, inUserdata: COpaquePointer): size_t
-	{
+private fun onCurlBody(
+    inBuffer: CPointer<ByteVar>,
+    inSize: size_t,
+    inCount: size_t,
+    inUserdata: COpaquePointer
+): size_t {
     val vSink = inUserdata.asStableRef<CurlSink>().get()
     val vLen = (inSize * inCount).toLong()
     if (vLen > 0) vSink.body.write(inBuffer.readBytes(vLen.toInt()))
     return vLen.convert()
 }
 
-/* Header callback — one parsed header line per call; accumulated for parsing. */
+/** Header callback - one parsed header line per call; accumulated for parsing. */
 @OptIn(ExperimentalForeignApi::class)
-private fun onCurlHeader(inBuffer: CPointer<ByteVar>, inSize: size_t, inCount: size_t, inUserdata: COpaquePointer): size_t
-	{
+private fun onCurlHeader(
+    inBuffer: CPointer<ByteVar>,
+    inSize: size_t,
+    inCount: size_t,
+    inUserdata: COpaquePointer
+): size_t {
     val vSink = inUserdata.asStableRef<CurlSink>().get()
     val vLen = (inSize * inCount).toLong()
     if (vLen > 0) vSink.headerRaw.append(inBuffer.readBytes(vLen.toInt()).decodeToString())
     return vLen.convert()
 }
 
-/* Sink callback that discards everything (used by the TLS-chain probe so the
+/** Sink callback that discards everything (used by the TLS-chain probe so the
 response body/headers don't spill to stdout). */
 @OptIn(ExperimentalForeignApi::class)
-private fun onCurlDiscard(inBuffer: CPointer<ByteVar>, inSize: size_t, inCount: size_t, inUserdata: COpaquePointer): size_t =
+private fun onCurlDiscard(
+    inBuffer: CPointer<ByteVar>,
+    inSize: size_t,
+    inCount: size_t,
+    inUserdata: COpaquePointer
+): size_t =
     (inSize * inCount)
 
-/* Open a TLS connection to the request's URL (handshake only — no body) and
+/** Open a TLS connection to the request's URL (handshake only - no body) and
 return the server's certificate chain via CURLINFO_CERTINFO. Reuses the
 request's client certificate if it has one (so mTLS endpoints work too).
 inReq is already var-resolved. */
 @OptIn(ExperimentalForeignApi::class)
-fun inspectTlsChain(inReq: ApiRequest): TlsChain
-	{
-	val vCert = try { if (inReq.hasClientCert) prepareClientCert(inReq) else null }
-		catch (e: Throwable) { return TlsChain(emptyList(), e.message ?: "Client certificate error") }
-	val vCurl = curl_easy_init() ?: run { vCert?.cleanup(); return TlsChain(emptyList(), "Could not initialize libcurl") }
-	try
-		{
+actual fun inspectTlsChain(inReq: ApiRequest): TlsChain {
+    val vCert = try {
+        if (inReq.hasClientCert) prepareClientCert(inReq) else null
+    } catch (e: Throwable) {
+        return TlsChain(emptyList(), e.message ?: "Client certificate error")
+    }
+    val vCurl =
+        curl_easy_init() ?: run { vCert?.cleanup(); return TlsChain(emptyList(), "Could not initialize libcurl") }
+    try {
         curl_easy_setopt(vCurl, CURLOPT_URL, urlWithParams(inReq))
         curl_easy_setopt(vCurl, CURLOPT_NOBODY, 1L)            // just the handshake + headers
         curl_easy_setopt(vCurl, CURLOPT_CERTINFO, 1L)
@@ -144,17 +145,18 @@ fun inspectTlsChain(inReq: ApiRequest): TlsChain
         if (vCode != CURLE_OK)
             return TlsChain(emptyList(), curl_easy_strerror(vCode)?.toKString() ?: "libcurl error $vCode")
         val vRaw = readCertInfo(vCurl)
-		if (vRaw.isEmpty()) return TlsChain(emptyList(), "No certificate chain reported (not an HTTPS URL, or the TLS backend didn't expose it).")
+        if (vRaw.isEmpty()) return TlsChain(
+            emptyList(),
+            "No certificate chain reported (not an HTTPS URL, or the TLS backend didn't expose it)."
+        )
         return TlsChain(extendChain(vRaw), null)
-		}
-	finally
-		{
+    } finally {
         curl_easy_cleanup(vCurl)
         vCert?.cleanup()
     }
 }
 
-/* Read CURLINFO_CERTINFO off a performed handle into per-cert field lists. */
+/** Read CURLINFO_CERTINFO off a performed handle into per-cert field lists. */
 @OptIn(ExperimentalForeignApi::class)
 private fun readCertInfo(inCurl: COpaquePointer): List<List<Pair<String, String>>> = memScoped {
     val vPtr = alloc<COpaquePointerVar>()
@@ -162,15 +164,12 @@ private fun readCertInfo(inCurl: COpaquePointer): List<List<Pair<String, String>
     val vInfo = vPtr.value?.reinterpret<curl_certinfo>()?.pointed ?: return@memScoped emptyList()
     val vArr = vInfo.certinfo ?: return@memScoped emptyList()
     val vResult = ArrayList<List<Pair<String, String>>>()
-	for (vI in 0 until vInfo.num_of_certs)
-		{
+    for (vI in 0 until vInfo.num_of_certs) {
         val vFields = ArrayList<Pair<String, String>>()
         var vNode = vArr[vI]
-		while (vNode != null)
-			{
+        while (vNode != null) {
             val vData = vNode.pointed.data?.toKString()
-			if (vData != null)
-				{
+            if (vData != null) {
                 val vColon = vData.indexOf(':')
                 if (vColon > 0) vFields.add(vData.substring(0, vColon) to vData.substring(vColon + 1))
                 else vFields.add("" to vData)
@@ -182,23 +181,29 @@ private fun readCertInfo(inCurl: COpaquePointer): List<List<Pair<String, String>
     vResult
 }
 
-/* Send a client-certificate request through libcurl and adapt the result into
+/** Send a client-certificate request through libcurl and adapt the result into
 the same ApiResponse the Ktor path produces. inReq is already var-resolved. */
 @OptIn(ExperimentalForeignApi::class)
-fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse
-	{
+actual fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse {
     val vMark = TimeSource.Monotonic.markNow()
-	val vCert = try { prepareClientCert(inReq) }
-		catch (e: Throwable) { return errorResponse(e.message ?: "Client certificate error", vMark.elapsedNow().inWholeMilliseconds) }
+    val vCert = try {
+        prepareClientCert(inReq)
+    } catch (e: Throwable) {
+        return errorResponse(e.message ?: "Client certificate error", vMark.elapsedNow().inWholeMilliseconds)
+    }
     val vCurl = curl_easy_init()
-		?: run { vCert.cleanup(); return errorResponse("Could not initialize libcurl", vMark.elapsedNow().inWholeMilliseconds) }
+        ?: run {
+            vCert.cleanup(); return errorResponse(
+            "Could not initialize libcurl",
+            vMark.elapsedNow().inWholeMilliseconds
+        )
+        }
 
     val vSink = CurlSink()
     val vSinkRef = StableRef.create(vSink)
     var vHeaders: CPointer<curl_slist>? = null
 
-	try
-		{
+    try {
         curl_easy_setopt(vCurl, CURLOPT_URL, urlWithParams(inReq))
         curl_easy_setopt(vCurl, CURLOPT_FOLLOWLOCATION, 1L)
         curl_easy_setopt(vCurl, CURLOPT_ACCEPT_ENCODING, "")   // advertise + auto-decompress
@@ -210,8 +215,7 @@ fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse
             curl_easy_setopt(vCurl, CURLOPT_NOBODY, 1L)
         else
             curl_easy_setopt(vCurl, CURLOPT_CUSTOMREQUEST, inReq.method.name)
-		if (vBody != null && vBody.bytes.isNotEmpty())
-			{
+        if (vBody != null && vBody.bytes.isNotEmpty()) {
             curl_easy_setopt(vCurl, CURLOPT_POSTFIELDSIZE_LARGE, vBody.bytes.size.toLong())
             vBody.bytes.usePinned { curl_easy_setopt(vCurl, CURLOPT_COPYPOSTFIELDS, it.addressOf(0)) }
         }
@@ -251,9 +255,27 @@ fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse
             return errorResponse(curl_easy_strerror(vCode)?.toKString() ?: "libcurl error $vCode", vMs)
 
         val vBytes = vSink.body.readByteArray()
-		val vStatus = memScoped { val p = alloc<LongVar>(); curl_easy_getinfo(vCurl, CURLINFO_RESPONSE_CODE, p.ptr); p.value.toInt() }
-		val vCt = memScoped { val p = alloc<CPointerVar<ByteVar>>(); curl_easy_getinfo(vCurl, CURLINFO_CONTENT_TYPE, p.ptr); p.value?.toKString() }
-		val vVer = memScoped { val p = alloc<LongVar>(); curl_easy_getinfo(vCurl, CURLINFO_HTTP_VERSION, p.ptr); httpVersionName(p.value) }
+        val vStatus = memScoped {
+            val p = alloc<LongVar>(); curl_easy_getinfo(
+            vCurl,
+            CURLINFO_RESPONSE_CODE,
+            p.ptr
+        ); p.value.toInt()
+        }
+        val vCt = memScoped {
+            val p = alloc<CPointerVar<ByteVar>>(); curl_easy_getinfo(
+            vCurl,
+            CURLINFO_CONTENT_TYPE,
+            p.ptr
+        ); p.value?.toKString()
+        }
+        val vVer = memScoped {
+            val p = alloc<LongVar>(); curl_easy_getinfo(
+            vCurl,
+            CURLINFO_HTTP_VERSION,
+            p.ptr
+        ); httpVersionName(p.value)
+        }
         val vIsImage = vCt?.startsWith("image/", ignoreCase = true) == true
         val vBinary = !vIsImage && isBinaryBody(vCt, vBytes)
 
@@ -265,7 +287,6 @@ fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse
         }.sortedBy { it.first.lowercase() }
 
         return ApiResponse(
-			ok = true,
             status = vStatus,
             statusText = runCatching { HttpStatusCode.fromValue(vStatus).description }.getOrDefault(""),
             timeMs = vMs,
@@ -273,7 +294,7 @@ fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse
             headers = parseRawHeaders(vSink.headerRaw.toString()),
             body = when {
                 vIsImage -> ""
-				vBinary -> "(${vCt ?: "binary"} · ${vBytes.size} bytes — not shown; use Save as…)"
+                vBinary -> "(${vCt ?: "binary"} · ${vBytes.size} bytes - not shown; use Save as…)"
                 else -> vBytes.decodeToString()
             },
             bytes = vBytes,
@@ -281,9 +302,7 @@ fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse
             requestHeaders = vSent,
             httpVersion = vVer,
         )
-		}
-	finally
-		{
+    } finally {
         vHeaders?.let { curl_slist_free_all(it) }
         curl_easy_cleanup(vCurl)
         vSinkRef.dispose()
@@ -291,37 +310,47 @@ fun curlSendWithClientCert(inReq: ApiRequest): ApiResponse
     }
 }
 
-/* A failed-request ApiResponse with a message (mirrors HttpRunner's catch). */
+/** A failed-request ApiResponse with a message (mirrors HttpRunner's catch). */
 private fun errorResponse(inMessage: String, inMs: Long): ApiResponse =
-	ApiResponse(ok = false, status = 0, statusText = "—", timeMs = inMs, sizeBytes = 0, headers = emptyList(), body = "", error = inMessage)
+    ApiResponse(
+        status = 0,
+        statusText = "-",
+        timeMs = inMs,
+        sizeBytes = 0,
+        headers = emptyList(),
+        body = "",
+        error = inMessage
+    )
 
-/* The encoded body for the request's body type, with the Content-Type curl
+/** The encoded body for the request's body type, with the Content-Type curl
 should send (null when there's no body). Mirrors HttpRunner.run(). */
 private class CurlBody(val contentType: String?, val bytes: ByteArray)
 
-private fun requestBodyBytes(inReq: ApiRequest): CurlBody?
-	{
+private fun requestBodyBytes(inReq: ApiRequest): CurlBody? {
     if (inReq.bodyType == BodyType.NONE) return null
-	return when (inReq.bodyType)
-		{
+    return when (inReq.bodyType) {
         BodyType.TEXT -> CurlBody(inReq.bodyContentType(), inReq.body.encodeToByteArray())
         BodyType.FORM -> CurlBody(inReq.bodyContentType(), formEncode(inReq.form).encodeToByteArray())
-		BodyType.FILE -> if (inReq.body.isBlank()) null else CurlBody(inReq.bodyContentType(), readFileBytes(inReq.body))
+        BodyType.FILE -> if (inReq.body.isBlank()) null else CurlBody(
+            inReq.bodyContentType(),
+            readFileBytes(inReq.body)
+        )
+
         BodyType.NONE -> null
     }
 }
 
-/* Parse libcurl's accumulated raw header text into ordered key/value pairs,
-   keeping only the final response's block (a new "HTTP/" status line — emitted
-   per redirect hop — resets what we've gathered). */
-private fun parseRawHeaders(inRaw: String): List<Pair<String, String>>
-	{
+/** Parse libcurl's accumulated raw header text into ordered key/value pairs,
+keeping only the final response's block (a new "HTTP/" status line - emitted
+per redirect hop - resets what we've gathered). */
+private fun parseRawHeaders(inRaw: String): List<Pair<String, String>> {
     var vCurrent = mutableListOf<Pair<String, String>>()
-	for (vRawLine in inRaw.split("\r\n", "\n"))
-		{
+    for (vRawLine in inRaw.split("\r\n", "\n")) {
         val vLine = vRawLine.trimEnd()
         if (vLine.isEmpty()) continue
-		if (vLine.startsWith("HTTP/", ignoreCase = true)) { vCurrent = mutableListOf(); continue }
+        if (vLine.startsWith("HTTP/", ignoreCase = true)) {
+            vCurrent = mutableListOf(); continue
+        }
         val vColon = vLine.indexOf(':')
         if (vColon <= 0) continue
         vCurrent.add(vLine.substring(0, vColon).trim() to vLine.substring(vColon + 1).trim())
@@ -329,10 +358,9 @@ private fun parseRawHeaders(inRaw: String): List<Pair<String, String>>
     return vCurrent.sortedBy { it.first.lowercase() }
 }
 
-/* libcurl's CURLINFO_HTTP_VERSION code → a human protocol string. */
+/** libcurl's CURLINFO_HTTP_VERSION code → a human protocol string. */
 @OptIn(ExperimentalForeignApi::class)
-private fun httpVersionName(inCode: Long): String = when (inCode)
-	{
+private fun httpVersionName(inCode: Long): String = when (inCode) {
     CURL_HTTP_VERSION_1_0.toLong() -> "HTTP/1.0"
     CURL_HTTP_VERSION_1_1.toLong() -> "HTTP/1.1"
     CURL_HTTP_VERSION_2_0.toLong() -> "HTTP/2"

apidemo/src/nativeMain/kotlin/Fonts.kt

@@ -6,20 +6,13 @@ import com.compose.sdl.loadComposeResourceBytes
 import com.compose.sdl.text.namedFontFamily
 
 // ==================
-// MARK: Monospace body font
+// MARK: Monospace body font - native actuals (data.kres + IconFont)
 // ==================
 
-// Family name the body editor passes for monospace text. Resolves to the bundled
-// Noto Sans Mono once registered; null means the font isn't in data.kres, in
-// which case the body falls back to the default (proportional Noto Sans).
-const val kMonoFamily = "noto-mono"
-
-// The raw project family name string — used by the SyntaxHighlight tokeniser's
-// wrap() call which measures via NativeTextMeasurer (accepts a name string).
-val monoFontFamilyName: String? by lazy {
+actual val monoFontFamilyName: String? by lazy {
     val vBytes = loadComposeResourceBytes("font/NotoSansMono.ttf")
     if (vBytes == null) {
-        println("apidemo: NotoSansMono.ttf not bundled — body uses the default font")
+        println("apidemo: NotoSansMono.ttf not bundled - body uses the default font")
         null
     } else {
         IconFont.register(kMonoFamily, vBytes)
@@ -27,9 +20,19 @@ val monoFontFamilyName: String? by lazy {
     }
 }
 
-// The material3 Text / BasicTextField-shaped FontFamily wrapper. Wraps the
-// registered project family in a `NamedFont`-backed FontFamily so the m3 Text
-// signature (which takes `FontFamily?` proper) can be given the mono family.
-val monoFontFamily: FontFamily? by lazy {
+actual val monoFontFamily: FontFamily? by lazy {
     monoFontFamilyName?.let { namedFontFamily(it) }
 }
+
+/** Native already resolves FontFamily.Default to the bundled NotoSans, but the
+family is registered by name so both stacks go through the same lookup. */
+actual val defaultFontFamily: FontFamily? by lazy {
+    val vBytes = loadComposeResourceBytes("font/NotoSans.ttf")
+    if (vBytes == null) {
+        println("apidemo: NotoSans.ttf not bundled - using the platform default font")
+        null
+    } else {
+        IconFont.register(kDefaultFamily, vBytes)
+        namedFontFamily(kDefaultFamily)
+    }
+}

apidemo/src/nativeMain/kotlin/Model.kt

@@ -1,247 +0,0 @@
-package apidemo
-
-import kotlinx.serialization.Serializable
-
-// ==================
-// MARK: Pack model (serialized to / from .json)
-// ==================
-
-/* A "pack" is a savable collection of requests plus its environment variables
-   — the export/import unit. Variables are referenced as {{name}} in any URL,
-   query value, header or body and substituted just before the request is sent
-   (see resolveVars in Tools.kt). Packs may be empty; the rich starter set lives
-   in defaultSession(). */
-@Serializable
-data class Pack(
-    val name: String = "My Pack",
-    val requests: List<ApiRequest> = emptyList(),
-    val variables: List<KeyVal> = emptyList(),
-    val color: Int = 0,   // 1-based index into the pack-colour palette; 0 = none
-    val headers: List<KeyVal> = emptyList(),   // pack-level headers, inherited by requests
-    val params: List<KeyVal> = emptyList(),    // pack-level query params, inherited by requests
-    val cert: CertConfig? = null,              // pack-level client cert, inherited by requests
-    val id: String = "",                       // stable id (used by linked-copy packs)
-    val linkedTo: String? = null,              // id of the source pack when this is a linked copy
-    val isRoot: Boolean = false,               // the hidden session-root "pack" holding loose requests
-    val subPacks: List<Pack> = emptyList(),    // nested packs (a pack tree)
-)
-
-/* A client-certificate (mutual TLS) configuration. Lives on a request today and
-   — with the pack tree — on the session / packs too (inherited downward). Maps
-   to libcurl's CURLOPT_SSLCERT / SSLCERTTYPE / SSLKEY / SSLKEYTYPE / KEYPASSWD. */
-@Serializable
-data class CertConfig(
-    val certPath: String = "",
-    val certFormat: CertFormat = CertFormat.PEM,
-    val keyPath: String = "",
-    val keyFormat: CertFormat = CertFormat.PEM,
-    val certPassword: String = "",
-)
-
-/* The starter SESSION loaded on first launch (and on demand from the session
-   menu) — a guided tour of every feature against httpbin.org: the inheritance
-   ladder (session → pack → sub-pack → request, for variables / query params /
-   headers / client cert, innermost wins), loose root requests, a nested sub-pack,
-   per-request overrides, a client-cert pack, and a linked-copy pack. Each /get or
-   /anything endpoint echoes the args + headers it received, so the merged,
-   inherited result is visible in the response. Loaded as an unsaved session. */
-fun defaultSession(): Session = Session(
-    activePack = 0,
-    // ── Session level — the base of every inheritance ladder ──
-    globalEnv = listOf(
-        KeyVal("baseUrl", "https://httpbin.org"),
-        KeyVal("token", "session-token-abc"),
-        KeyVal("user", "session-user"),
-        KeyVal("password", "passwd"),
-        KeyVal("apiVer", "v1"),                                       // overridden by Methods (v2) then Nested (v3)
-    ),
-    globalHeaders = listOf(KeyVal("X-Client", "compose-apidemo")),    // every request sends it (echoed by /headers)
-    globalParams = listOf(KeyVal("trace", "session")),                // every request gets ?trace=session (echoed in /get args)
-    // No session-level cert: it would route every request through mTLS and fail
-    // without a real cert file. Client certs are shown on the "Secure (mTLS)" pack.
-    // ── Loose requests at the session root (in no pack — inherit session only) ──
-    root = Pack(isRoot = true, name = "", requests = listOf(
-        ApiRequest(name = "Ping (loose)", method = ReqMethod.GET, url = "{{baseUrl}}/get"),
-        ApiRequest(name = "Headers echo (loose)", method = ReqMethod.GET, url = "{{baseUrl}}/headers"),
-    )),
-    packs = listOf(
-        // ── Methods — pack header/param/var inherited by its requests, plus a
-        //    nested sub-pack and per-request overrides of each kind. ──
-        SavedPack(pack = Pack(name = "Methods", id = "pk-methods", color = 1,
-            headers = listOf(KeyVal("Accept", "application/json")),   // pack header, inherited by its requests
-            params = listOf(KeyVal("source", "methods")),             // pack query param, inherited (echoed in /get args)
-            variables = listOf(KeyVal("apiVer", "v2")),               // overrides the session's apiVer for this pack
-            requests = listOf(
-                ApiRequest(name = "GET — echoes inherited", method = ReqMethod.GET, url = "{{baseUrl}}/get",
-                    params = listOf(KeyVal("q", "compose"))),         // own q + inherited trace=session + source=methods
-                ApiRequest(name = "GET — overrides query param", method = ReqMethod.GET, url = "{{baseUrl}}/get",
-                    params = listOf(KeyVal("trace", "request"))),     // request's trace wins over the session's
-                ApiRequest(name = "POST — overrides header", method = ReqMethod.POST, url = "{{baseUrl}}/post",
-                    headers = listOf(KeyVal("Accept", "text/plain")), // request's Accept wins over the pack's
-                    bodyType = BodyType.TEXT, bodyFormat = BodyFormat.JSON, body = "{\n  \"user\": \"{{user}}\",\n  \"api\": \"{{apiVer}}\"\n}"),
-                ApiRequest(name = "POST — overrides {{user}} var", method = ReqMethod.POST, url = "{{baseUrl}}/anything",
-                    variables = listOf(KeyVal("user", "request-user")),   // request var beats session/pack — see body echo
-                    bodyType = BodyType.TEXT, bodyFormat = BodyFormat.JSON, body = "{ \"who\": \"{{user}}\" }"),
-                ApiRequest(name = "PUT — replace", method = ReqMethod.PUT, url = "{{baseUrl}}/put",
-                    bodyType = BodyType.TEXT, bodyFormat = BodyFormat.JSON, body = "{ \"id\": 1, \"name\": \"updated\" }"),
-                ApiRequest(name = "DELETE", method = ReqMethod.DELETE, url = "{{baseUrl}}/delete"),
-                ApiRequest(name = "Anything echo", method = ReqMethod.POST, url = "{{baseUrl}}/anything",
-                    bodyType = BodyType.TEXT, bodyFormat = BodyFormat.JSON, body = "{ \"hello\": \"world\" }"),
-            ),
-            // Nested sub-pack — inherits Session → Methods → here (apiVer becomes v3,
-            // plus its own X-Nested header; trace / source / Accept still flow down).
-            subPacks = listOf(
-                Pack(name = "Nested", color = 4,
-                    variables = listOf(KeyVal("apiVer", "v3")),
-                    headers = listOf(KeyVal("X-Nested", "true")),
-                    requests = listOf(
-                        ApiRequest(name = "GET — deep inheritance", method = ReqMethod.GET, url = "{{baseUrl}}/anything/{{apiVer}}"),
-                    )),
-            ))),
-        // ── Auth & status — uses the inherited {{token}} / {{user}} / {{password}} ──
-        SavedPack(pack = Pack(name = "Auth & status", color = 2, requests = listOf(
-            ApiRequest(name = "Bearer auth", method = ReqMethod.GET, url = "{{baseUrl}}/bearer",
-                headers = listOf(KeyVal("Authorization", "Bearer {{token}}"))),
-            ApiRequest(name = "Basic auth", method = ReqMethod.GET, url = "{{baseUrl}}/basic-auth/{{user}}/{{password}}"),
-            ApiRequest(name = "Status 200", method = ReqMethod.GET, url = "{{baseUrl}}/status/200"),
-            ApiRequest(name = "Status 500", method = ReqMethod.GET, url = "{{baseUrl}}/status/500"),
-            ApiRequest(name = "Redirect x3", method = ReqMethod.GET, url = "{{baseUrl}}/redirect/3"),
-            ApiRequest(name = "Delay 3s (try Cancel)", method = ReqMethod.GET, url = "{{baseUrl}}/delay/3"),
-        ))),
-        // ── Formats — response viewer (JSON / XML / HTML / image) ──
-        SavedPack(pack = Pack(name = "Formats", color = 3, requests = listOf(
-            ApiRequest(name = "JSON", method = ReqMethod.GET, url = "{{baseUrl}}/json"),
-            ApiRequest(name = "XML", method = ReqMethod.GET, url = "{{baseUrl}}/xml"),
-            ApiRequest(name = "HTML", method = ReqMethod.GET, url = "{{baseUrl}}/html"),
-            ApiRequest(name = "UTF-8 text", method = ReqMethod.GET, url = "{{baseUrl}}/encoding/utf8"),
-            ApiRequest(name = "PNG image", method = ReqMethod.GET, url = "{{baseUrl}}/image/png"),
-            ApiRequest(name = "SVG image", method = ReqMethod.GET, url = "{{baseUrl}}/image/svg"),
-        ))),
-        // ── Secure (mTLS) — a PACK-LEVEL client cert, inherited by its requests.
-        //    Open a request's Cert tab to see the inherited cert (source pill +
-        //    Override). Set real cert paths to actually send; the example paths
-        //    won't load. The second request overrides with its own cert. ──
-        SavedPack(pack = Pack(name = "Secure (mTLS)", color = 5,
-            cert = CertConfig(certPath = "/path/to/client.p12", certFormat = CertFormat.PKCS12, certPassword = "changeit"),
-            requests = listOf(
-                ApiRequest(name = "Inherits the pack cert", method = ReqMethod.GET, url = "{{baseUrl}}/get"),
-                ApiRequest(name = "Overrides with own cert", method = ReqMethod.GET, url = "{{baseUrl}}/get",
-                    certPath = "/path/to/other-client.pem", certFormat = CertFormat.PEM, keyPath = "/path/to/other-key.pem"),
-            ))),
-        // ── Linked copy of "Methods": a read-only mirror of its requests, but with
-        //    its own baseUrl var → the same calls run against the httpbingo sibling.
-        //    Showcases linked packs + per-pack variable override. ──
-        SavedPack(pack = Pack(name = "Methods · httpbingo", color = 6, requests = emptyList(),
-            variables = listOf(KeyVal("baseUrl", "https://httpbingo.org")), linkedTo = "pk-methods")),
-    ),
-)
-
-@Serializable
-data class ApiRequest(
-    val name: String = "New request",
-    val method: ReqMethod = ReqMethod.GET,
-    val url: String = "https://",
-    val params: List<KeyVal> = emptyList(),
-    val variables: List<KeyVal> = emptyList(),   // request-level vars ({{name}}); override inherited ones
-    val headers: List<KeyVal> = emptyList(),
-    val bodyType: BodyType = BodyType.NONE,
-    val body: String = "",                       // TEXT content, or the file path when bodyType == FILE
-    val bodyFormat: BodyFormat = BodyFormat.RAW, // for a TEXT body: syntax-highlight type + sent Content-Type
-    val form: List<KeyVal> = emptyList(),        // key/value fields when bodyType == FORM
-    // Client certificate (mutual TLS). When certPath is set, the request is sent
-    // through the libcurl path (CurlMtls.kt) with these mapped to CURLOPT_SSLCERT
-    // / SSLCERTTYPE / SSLKEY / SSLKEYTYPE / KEYPASSWD. A PKCS#12 file bundles its
-    // own key, so keyPath is left blank for it.
-    val certPath: String = "",
-    val certFormat: CertFormat = CertFormat.PEM,
-    val keyPath: String = "",
-    val keyFormat: CertFormat = CertFormat.PEM,
-    val certPassword: String = "",
-)
-
-/* Whether this request carries a client certificate (and so is sent via the
-   libcurl mTLS path rather than the default engine). */
-val ApiRequest.hasClientCert: Boolean
-    get() = certPath.isNotBlank()
-
-/* This request's cert fields as a CertConfig (certPath may be blank = none). */
-fun ApiRequest.certConfig(): CertConfig = CertConfig(certPath, certFormat, keyPath, keyFormat, certPassword)
-
-/* This request with its cert fields replaced by inCert's. */
-fun ApiRequest.withCert(inCert: CertConfig): ApiRequest =
-    copy(certPath = inCert.certPath, certFormat = inCert.certFormat,
-        keyPath = inCert.keyPath, keyFormat = inCert.keyFormat, certPassword = inCert.certPassword)
-
-/* True when this config actually selects a certificate. */
-val CertConfig.isSet: Boolean
-    get() = certPath.isNotBlank()
-
-/* Certificate / private-key encodings, mapped to libcurl's CURLOPT_SSLCERTTYPE
-   / CURLOPT_SSLKEYTYPE string values and to `curl --cert-type` / `--key-type`.
-   Runtime support depends on the TLS backend: OpenSSL (macOS/Linux) handles all
-   three; Schannel (Windows) effectively supports P12. */
-@Serializable
-enum class CertFormat(val curlName: String, val label: String) {
-    PEM("PEM", "PEM"),
-    DER("DER", "DER"),
-    PKCS12("P12", "PKCS#12"),
-}
-
-/* A toggleable key/value row, used for both query params and headers. */
-@Serializable
-data class KeyVal(val key: String = "", val value: String = "", val enabled: Boolean = true)
-
-@Serializable
-enum class ReqMethod { GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS }
-
-/* HTTP doesn't forbid a body on GET / HEAD / OPTIONS — RFC 7230 §3.3
-   leaves it as "SHOULD NOT" / server discretion. Many APIs use a body
-   on GET (Elasticsearch search, GraphQL queries) so we don't gate it
-   here; the UI just sets bodyType=NONE by default for those methods. */
-val ReqMethod.allowsBody: Boolean
-    get() = true
-
-@Serializable
-enum class BodyType { NONE, TEXT, FORM, FILE }
-
-/* Title-case label for the body-type picker. */
-val BodyType.label: String
-    get() = when (this) {
-        BodyType.NONE -> "None"
-        BodyType.TEXT -> "Text"
-        BodyType.FORM -> "Form"
-        BodyType.FILE -> "File"
-    }
-
-/* The Content-Type the request body implies (null when there's no body). For a
-   TEXT body it comes from the chosen format (Text→text/plain, JSON→application/
-   json, …); FORM / FILE are fixed. Sent unless the request already sets one. */
-fun ApiRequest.bodyContentType(): String? = when (bodyType) {
-    BodyType.NONE -> null
-    BodyType.TEXT -> bodyFormat.contentType
-    BodyType.FORM -> "application/x-www-form-urlencoded"
-    BodyType.FILE -> "application/octet-stream"
-}
-
-// ==================
-// MARK: Response (runtime only — not part of a pack)
-// ==================
-
-class ApiResponse(
-    val ok: Boolean,
-    val status: Int,
-    val statusText: String,
-    val timeMs: Long,
-    val sizeBytes: Long,
-    val headers: List<Pair<String, String>>,
-    val body: String,
-    val bytes: ByteArray = ByteArray(0),
-    val contentType: String? = null,
-    val requestHeaders: List<Pair<String, String>> = emptyList(),  // headers actually sent
-    val httpVersion: String = "HTTP/1.1",  // from Ktor's response.version, e.g. "HTTP/1.1" or "HTTP/2"
-    val error: String? = null,
-)
-
-/* True when the response carries an image payload (rendered, not shown as text). */
-val ApiResponse.isImage: Boolean
-    get() = contentType?.startsWith("image/", ignoreCase = true) == true

apidemo/src/nativeMain/kotlin/RequestTabStrip.kt

@@ -1,241 +0,0 @@
-@file:OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class)
-
-package apidemo
-
-import androidx.compose.foundation.*
-import androidx.compose.foundation.gestures.detectDragGestures
-import androidx.compose.foundation.layout.*
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.DropdownMenu
-import androidx.compose.material3.DropdownMenuItem
-import androidx.compose.material3.Text
-import androidx.compose.runtime.*
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.input.pointer.PointerButton
-import androidx.compose.ui.input.pointer.PointerEventType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.layout.onSizeChanged
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.zIndex
-import com.compose.sdl.icons.MaterialSymbols
-import com.compose.sdl.icons.material.symbols.MaterialSymbolsOutlined
-import com.compose.sdl.layout.x
-
-// ==================
-// MARK: Request tab strip (open requests; drag a tab to reorder)
-// ==================
-
-/* Strip of open requests above the editor. Each tab is clickable to select
-   and drag-reorderable. While dragging, the grabbed tab lifts (zIndex),
-   fades, and follows the cursor via a graphicsLayer translation — its
-   neighbours don't shuffle; the reorder commits on drop, to the slot whose
-   neighbours' centres the cursor passed. key(tab) keeps each tab's
-   LayoutNode stable so the drag session survives the reorder. */
-@Composable
-internal fun RequestTabStrip(
-    inTabs: List<StripTab>,
-    inActiveKey: Any?,
-    inOnSelect: (StripTab) -> Unit,
-    inOnClose: (StripTab) -> Unit,
-    inOnCloseOthers: (StripTab) -> Unit,
-    inOnCloseAll: () -> Unit,
-    inOnReorder: (Int, Int) -> Unit,
-) {
-    val c = LocalAppColors.current
-    val vScroll = rememberScrollState()                     // strip's horizontal scroll
-    val vLeft = remember { mutableStateMapOf<Any, Int>() }   // window-x of each tab's left edge, by tab key
-    val vWidth = remember { mutableStateMapOf<Any, Int>() }  // measured tab width, by tab key
-    var vDragKey by remember { mutableStateOf<Any?>(null) }
-    var vPressRelX by remember { mutableStateOf(0) }
-    var vDragDx by remember { mutableStateOf(0f) }
-    var vDragTarget by remember { mutableStateOf(-1) }
-
-    // One shared context menu, anchored to the tab that opened it (m3 DropdownMenu
-    // is parent-anchored, not cursor-anchored — the old x/y capture is gone).
-    var vMenu by remember { mutableStateOf(false) }
-    var vMenuTab by remember { mutableStateOf<StripTab?>(null) }
-
-    var vListOpen by remember { mutableStateOf(false) }   // overflow list
-
-    val vShowBar = vDragKey != null && vDragDx != 0f
-    val vOthers = if (vShowBar) inTabs.filter { it.tabKey != vDragKey } else emptyList()
-    val vBarBeforeKey = if (vShowBar) vOthers.getOrNull(vDragTarget)?.tabKey else null
-    val vBarAtEnd = vShowBar && vDragTarget >= vOthers.size
-
-    Row(
-        modifier = Modifier.fillMaxWidth().background(c.panel),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-      Row(
-        modifier = Modifier.weight(1f)
-            .horizontalScroll(vScroll).padding(horizontal = 6.dp, vertical = 5.dp),
-        horizontalArrangement = Arrangement.spacedBy(4.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        inTabs.forEach { vTab ->
-            val vKey = vTab.tabKey
-            if (vKey == vBarBeforeKey) DropBar()
-            key(vKey) {
-                val vSel = vKey == inActiveKey
-                val vDragged = vKey == vDragKey
-
-                var vMod = Modifier
-                    .onGloballyPositioned { vLeft[vKey] = it.x }
-                    .onSizeChanged { vWidth[vKey] = it.width }
-                // NOTE: `alpha` and `translationX` MUST be on the same graphicsLayer.
-                // `Modifier.alpha` expands to `graphicsLayer(alpha, clip = true)` — clip is
-                // applied in the ALPHA layer's local coord space (before any child layer's
-                // translation), so `.alpha().graphicsLayer(translationX = X)` clips the drag
-                // ghost inside its original bounds and the ghost disappears as it slides. One
-                // layer with both properties = clip stays false, alpha modulates via layerPaint.
-                if (vDragged) vMod = vMod.zIndex(1f).graphicsLayer(alpha = 0.65f, translationX = vDragDx, translationY = 0f)
-                vMod = vMod
-                    .clip(RoundedCornerShape(7.dp))
-                    .background(if (vSel) c.accent.copy(alpha = 0.20f) else c.field, RoundedCornerShape(7.dp))
-                    .border(1.dp, if (vSel || vDragged) c.accent else c.border, RoundedCornerShape(7.dp))
-                    .pointerInput(vKey) {
-                        // Accumulate the per-frame delta rather than reading change.position.
-                        // The tab wears a graphicsLayer(translationX = vDragDx) while dragging,
-                        // which transforms the modifier's local pointer frame — so position.x
-                        // would compensate for the translation each frame and the tab would
-                        // trail the mouse by roughly half its offset. dragAmount is the
-                        // root-frame delta and doesn't feed back through the layer transform.
-                        detectDragGestures(
-                            onDragStart = { offset ->
-                                vDragKey = vKey
-                                vPressRelX = offset.x.toInt()
-                                vDragDx = 0f
-                                vDragTarget = inTabs.indexOfFirst { it.tabKey == vKey }
-                            },
-                            onDrag = { _, dragAmount ->
-                                val vd = vDragKey ?: return@detectDragGestures
-                                vDragDx += dragAmount.x
-                                val vRelX = vPressRelX + vDragDx.toInt()
-                                val vCursorX = (vLeft[vd] ?: 0) + vRelX
-                                var vCount = 0
-                                inTabs.forEach { vT ->
-                                    if (vT.tabKey != vd) {
-                                        val vCenter = (vLeft[vT.tabKey] ?: 0) + (vWidth[vT.tabKey] ?: 0) / 2
-                                        if (vCursorX > vCenter) vCount++
-                                    }
-                                }
-                                vDragTarget = vCount
-                            },
-                            onDragEnd = {
-                                val vd = vDragKey
-                                if (vd != null) {
-                                    val vFrom = inTabs.indexOfFirst { it.tabKey == vd }
-                                    if (vFrom >= 0 && vDragTarget >= 0 && vDragTarget != vFrom) inOnReorder(vFrom, vDragTarget)
-                                }
-                                vDragKey = null; vDragDx = 0f; vDragTarget = -1
-                            },
-                            onDragCancel = { vDragKey = null; vDragDx = 0f; vDragTarget = -1 },
-                        )
-                    }
-                    // Middle-click closes the tab; right-click opens the tab menu. Compose
-                    // has no first-class match for either — inline pointerInput checks the
-                    // pressed PointerButton at each Press.
-                    .pointerInput(vTab) {
-                        awaitPointerEventScope {
-                            while (true) {
-                                val vEv = awaitPointerEvent()
-                                if (vEv.type != PointerEventType.Press) continue
-                                when (vEv.button) {
-                                    PointerButton.Tertiary -> {
-                                        vEv.changes.firstOrNull()?.consume()
-                                        inOnClose(vTab)
-                                    }
-                                    PointerButton.Secondary -> {
-                                        vEv.changes.firstOrNull()?.consume()
-                                        vMenuTab = vTab; vMenu = true
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    .clickable { inOnSelect(vTab) }
-                    .padding(start = 9.dp, top = 6.dp, bottom = 6.dp, end = 3.dp)
-
-                Row(
-                    modifier = vMod,
-                    horizontalArrangement = Arrangement.spacedBy(6.dp),
-                    verticalAlignment = Alignment.CenterVertically,
-                ) {
-                    val vRs = vTab.req
-                    if (vRs == null) {
-                        // Session / pack settings tab.
-                        MaterialSymbolsOutlined(MaterialSymbols.Tune, tint = if (vSel) c.accent else c.dim, size = 13.dp)
-                        Text(if (vTab.isSession) "Session" else (vTab.pack?.name ?: ""), color = if (vSel) c.text else c.dim, fontSize = 13.sp)
-                    } else {
-                        Box(modifier = Modifier.size(7.dp).background(methodColor(vRs.req.method), RoundedCornerShape(4.dp)))
-                        Text(vRs.req.name, color = if (vSel) c.text else c.dim, fontSize = 13.sp)
-                        if (vRs.loading) CircularProgressIndicator(modifier = Modifier.size(12.dp), color = c.accent, strokeWidth = 1.5.dp)
-                    }
-                    IconBtn(MaterialSymbols.Close, "Close", inSize = 13.dp) { inOnClose(vTab) }
-                }
-            }
-        }
-        if (vBarAtEnd) DropBar()
-
-        // Shared right-click menu, opened at the cursor over the clicked tab.
-        val vMTab = vMenuTab
-        if (vMenu && vMTab != null) {
-            DropdownMenu(
-                expanded = true,
-                onDismissRequest = { vMenu = false },
-                modifier = Modifier.widthIn(min = 188.dp),
-            ) {
-                DropdownMenuItem(text = { MenuRow(MaterialSymbols.Close, "Close tab") }, onClick = { vMenu = false; inOnClose(vMTab) })
-                DropdownMenuItem(text = { MenuRow(MaterialSymbols.Clear, "Close other tabs") }, onClick = { vMenu = false; inOnCloseOthers(vMTab) })
-                DropdownMenuItem(text = { MenuRow(MaterialSymbols.Clear, "Close all tabs") }, onClick = { vMenu = false; inOnCloseAll() })
-            }
-        }
-      }
-
-        // Overflow → chevron opens a scrollable list of every open tab.
-        if (vScroll.maxValue > 0) {
-            Box(modifier = Modifier.padding(end = 4.dp)) {
-                IconBtn(MaterialSymbols.ExpandMore, "All tabs") { vListOpen = true }
-                DropdownMenu(expanded = vListOpen, onDismissRequest = { vListOpen = false }, modifier = Modifier.widthIn(min = 240.dp)) {
-                    Column(modifier = Modifier.heightIn(max = 320.dp).verticalScroll(rememberScrollState())) {
-                        inTabs.forEach { vTab ->
-                            DropdownMenuItem(text = {
-                                Row(modifier = Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-                                    val vSel = vTab.tabKey == inActiveKey
-                                    val vRs = vTab.req
-                                    if (vRs == null) {
-                                        MaterialSymbolsOutlined(
-                                            MaterialSymbols.Tune,
-                                            tint = if (vSel) c.accent else c.dim,
-                                            size = 13.dp
-                                        )
-                                        Text(if (vTab.isSession) "Session" else "${vTab.pack?.name} · var", color = if (vSel) c.accent else c.text, fontSize = 13.sp, modifier = Modifier.weight(1f))
-                                    } else {
-                                        Box(modifier = Modifier.size(7.dp).background(methodColor(vRs.req.method), RoundedCornerShape(4.dp)))
-                                        Text(vRs.req.name, color = if (vSel) c.accent else c.text, fontSize = 13.sp, modifier = Modifier.weight(1f))
-                                        if (vRs.loading) CircularProgressIndicator(modifier = Modifier.size(12.dp), color = c.accent, strokeWidth = 1.5.dp)
-                                    }
-                                }
-                            }, onClick = { vListOpen = false; inOnSelect(vTab) })
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-/* Thin accent bar marking where a dragged tab will be inserted. Rendered in-flow
-   between tabs so the Row centres it vertically and reserves a little space. */
-@Composable
-internal fun DropBar() {
-    val c = LocalAppColors.current
-    Box(modifier = Modifier.width(3.dp).height(24.dp).clip(RoundedCornerShape(2.dp)).background(c.accent, RoundedCornerShape(2.dp)))
-}
-

apidemo/src/nativeMain/kotlin/SyntaxHighlight.kt

@@ -1,366 +0,0 @@
-package apidemo
-
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.buildAnnotatedString
-import kotlinx.serialization.Serializable
-
-// ==================
-// MARK: BodyFormat — viewer/highlighter selection
-// ==================
-
-/* Format of a body payload as shown in the viewer, and (for a TEXT request body)
-   the type the user picks on the right of the Body tab — it drives both syntax
-   highlighting and the sent Content-Type. RAW disables highlighting and falls back
-   to the selectable BasicTextField; other values pick a tokeniser. */
-@Serializable
-enum class BodyFormat { RAW, JSON, XML, YAML, HTML }
-
-/* Short label for the format / "type" picker (RAW = plain text, no highlighting). */
-val BodyFormat.label: String
-	get() = when (this) {
-		BodyFormat.RAW -> "RAW"
-		BodyFormat.JSON -> "JSON"
-		BodyFormat.XML -> "XML"
-		BodyFormat.YAML -> "YAML"
-		BodyFormat.HTML -> "HTML"
-	}
-
-/* The Content-Type a TEXT body of this format is sent with. */
-val BodyFormat.contentType: String
-	get() = when (this) {
-		BodyFormat.RAW -> "text/plain"
-		BodyFormat.JSON -> "application/json"
-		BodyFormat.XML -> "application/xml"
-		BodyFormat.YAML -> "application/yaml"
-		BodyFormat.HTML -> "text/html"
-	}
-
-/* Pick a format from a Content-Type header. JSON / XML / YAML / HTML
-   match their canonical types and common variants; anything else
-   (image types, text/plain, …) falls back to RAW. */
-fun autoFormatFor(inContentType: String?): BodyFormat {
-	val vCt = inContentType?.substringBefore(';')?.trim()?.lowercase() ?: return BodyFormat.RAW
-	return when {
-		vCt.endsWith("+json") || vCt == "application/json"          -> BodyFormat.JSON
-		vCt.endsWith("+xml")  || vCt == "application/xml" || vCt == "text/xml" -> BodyFormat.XML
-		vCt == "application/yaml" || vCt == "text/yaml" || vCt == "application/x-yaml" -> BodyFormat.YAML
-		vCt == "text/html"                                           -> BodyFormat.HTML
-		else                                                          -> BodyFormat.RAW
-	}
-}
-
-// ==================
-// MARK: Highlight palette
-// ==================
-
-/* Per-token colours. Two preset themes: a dark-on-dark and a dark-on-
-   light variant matching VS Code's defaults. Caller picks based on
-   surrounding theme; auto-pick available via SyntaxPalette.forDark(). */
-data class SyntaxPalette(
-	val key: Color,
-	val string: Color,
-	val number: Color,
-	val keyword: Color,
-	val tag: Color,
-	val comment: Color,
-	val punct: Color,
-) {
-	companion object {
-		/* Light-on-dark — VS Code Dark+. */
-		val Dark = SyntaxPalette(
-			key     = Color(0xFF9CDCFE),
-			string  = Color(0xFFCE9178),
-			number  = Color(0xFFB5CEA8),
-			keyword = Color(0xFFC586C0),
-			tag     = Color(0xFF569CD6),
-			comment = Color(0xFF6A9955),
-			punct   = Color(0xFFCCCCCC),
-		)
-		/* Dark-on-light — VS Code Light+. Higher contrast on white. */
-		val Light = SyntaxPalette(
-			key     = Color(0xFF0451A5),
-			string  = Color(0xFFA31515),
-			number  = Color(0xFF098658),
-			keyword = Color(0xFF0000FF),
-			tag     = Color(0xFF800000),
-			comment = Color(0xFF008000),
-			punct   = Color(0xFF333333),
-		)
-
-		/* Pick a palette by the host theme's background brightness. */
-		fun forDark(inIsDark: Boolean): SyntaxPalette = if (inIsDark) Dark else Light
-	}
-}
-
-// ==================
-// MARK: Entry point
-// ==================
-
-/* Render the given text with per-token colour spans for the requested
-   format. RAW returns an unstyled AnnotatedString. */
-fun highlight(
-	inText: String,
-	inFormat: BodyFormat,
-	inPalette: SyntaxPalette = SyntaxPalette.Dark,
-): AnnotatedString = when (inFormat) {
-	BodyFormat.RAW  -> AnnotatedString(inText)
-	BodyFormat.JSON -> highlightJson(inText, inPalette)
-	BodyFormat.XML, BodyFormat.HTML -> highlightXml(inText, inPalette)
-	BodyFormat.YAML -> highlightYaml(inText, inPalette)
-}
-
-// ==================
-// MARK: JSON tokeniser — single-pass, error-tolerant
-// ==================
-
-/* Tokeniser for JSON. Walks the string once and emits style spans for
-   strings, numbers, booleans, null, punctuation. Distinguishes "keys"
-   (strings followed by ':') from string values by peeking after each
-   string. Error-tolerant — malformed JSON still highlights as best
-   effort rather than throwing. */
-private fun highlightJson(inText: String, inP: SyntaxPalette): AnnotatedString = buildAnnotatedString {
-	val vN = inText.length
-	var vI = 0
-	while (vI < vN) {
-		val vC = inText[vI]
-		when {
-			vC == '"' -> {
-				// Find closing quote, honouring backslash-escaped chars so an
-				// escaped \" doesn't terminate the string early.
-				val vStart = vI
-				var vJ = vI + 1
-				while (vJ < vN) {
-					if (inText[vJ] == '\\' && vJ + 1 < vN) { vJ += 2; continue }
-					if (inText[vJ] == '"') { vJ++; break }
-					vJ++
-				}
-				// Peek for ':' (skipping whitespace) → it's a key, not a value.
-				var vK = vJ
-				while (vK < vN && inText[vK].isWhitespace()) vK++
-				val vIsKey = vK < vN && inText[vK] == ':'
-				val vColor = if (vIsKey) inP.key else inP.string
-				pushStyle(SpanStyle(color = vColor))
-				append(inText.substring(vStart, vJ))
-				pop()
-				vI = vJ
-			}
-			vC.isDigit() || (vC == '-' && vI + 1 < vN && inText[vI + 1].isDigit()) -> {
-				val vStart = vI
-				if (vC == '-') vI++
-				while (vI < vN && (inText[vI].isDigit() || inText[vI] in ".eE+-")) vI++
-				pushStyle(SpanStyle(color = inP.number))
-				append(inText.substring(vStart, vI))
-				pop()
-			}
-			vC.isLetter() -> {
-				val vStart = vI
-				while (vI < vN && inText[vI].isLetter()) vI++
-				val vWord = inText.substring(vStart, vI)
-				if (vWord == "true" || vWord == "false" || vWord == "null") {
-					pushStyle(SpanStyle(color = inP.keyword))
-					append(vWord)
-					pop()
-				} else {
-					append(vWord)
-				}
-			}
-			vC in "{}[],:" -> {
-				pushStyle(SpanStyle(color = inP.punct))
-				append(vC)
-				pop()
-				vI++
-			}
-			else -> { append(vC); vI++ }
-		}
-	}
-}
-
-// ==================
-// MARK: XML / HTML tokeniser
-// ==================
-
-/* Tokeniser for XML / HTML. Distinguishes tag names, attribute names,
-   attribute values (string), and comments. Inside tags, attr=value pairs
-   are recognised; outside tags text is left in the default colour. */
-private fun highlightXml(inText: String, inP: SyntaxPalette): AnnotatedString = buildAnnotatedString {
-	val vN = inText.length
-	var vI = 0
-	while (vI < vN) {
-		val vC = inText[vI]
-		when {
-			// Comment block: <!-- ... -->
-			vC == '<' && inText.startsWith("<!--", vI) -> {
-				val vEnd = inText.indexOf("-->", vI + 4).let { if (it < 0) vN else it + 3 }
-				pushStyle(SpanStyle(color = inP.comment))
-				append(inText.substring(vI, vEnd))
-				pop()
-				vI = vEnd
-			}
-			vC == '<' -> {
-				// Tag open: <[/]name attr=val attr2="val2">
-				val vGt = inText.indexOf('>', vI).let { if (it < 0) vN else it + 1 }
-				pushStyle(SpanStyle(color = inP.punct)); append('<'); pop()
-				var vJ = vI + 1
-				if (vJ < vN && inText[vJ] == '/') { pushStyle(SpanStyle(color = inP.punct)); append('/'); pop(); vJ++ }
-				// Tag name.
-				val vTagStart = vJ
-				while (vJ < vN && !inText[vJ].isWhitespace() && inText[vJ] != '>' && inText[vJ] != '/') vJ++
-				if (vJ > vTagStart) {
-					pushStyle(SpanStyle(color = inP.tag))
-					append(inText.substring(vTagStart, vJ))
-					pop()
-				}
-				// Attributes — name="value" pairs.
-				while (vJ < vGt - 1) {
-					val vC2 = inText[vJ]
-					when {
-						vC2.isWhitespace() -> { append(vC2); vJ++ }
-						vC2 == '/' -> { pushStyle(SpanStyle(color = inP.punct)); append('/'); pop(); vJ++ }
-						vC2 == '=' -> { pushStyle(SpanStyle(color = inP.punct)); append('='); pop(); vJ++ }
-						vC2 == '"' || vC2 == '\'' -> {
-							val vEnd = inText.indexOf(vC2, vJ + 1).let { if (it < 0) vGt - 1 else it + 1 }
-							pushStyle(SpanStyle(color = inP.string))
-							append(inText.substring(vJ, vEnd))
-							pop()
-							vJ = vEnd
-						}
-						else -> {
-							val vAttrStart = vJ
-							while (vJ < vGt - 1 && !inText[vJ].isWhitespace() && inText[vJ] != '=' && inText[vJ] != '>' && inText[vJ] != '/') vJ++
-							pushStyle(SpanStyle(color = inP.key))
-							append(inText.substring(vAttrStart, vJ))
-							pop()
-						}
-					}
-				}
-				if (vGt > vI && inText.getOrNull(vGt - 1) == '>') {
-					pushStyle(SpanStyle(color = inP.punct)); append('>'); pop()
-				}
-				vI = vGt
-			}
-			else -> { append(vC); vI++ }
-		}
-	}
-}
-
-// ==================
-// MARK: YAML tokeniser — line-based
-// ==================
-
-/* Tokeniser for YAML. Walks line by line because YAML's grammar is
-   indent-sensitive and most of the interesting colour decisions
-   (key vs value, list item vs scalar) depend on position within a
-   line. Comments (#), keys (text before ':'), quoted strings, numbers
-   and booleans are coloured; everything else stays default. */
-private fun highlightYaml(inText: String, inP: SyntaxPalette): AnnotatedString = buildAnnotatedString {
-	val vLines = inText.split('\n')
-	for ((vIdx, vLineRaw) in vLines.withIndex()) {
-		val vLine = vLineRaw
-		// Comment: rest of the line after a # (not inside a quoted string).
-		val vCommentAt = findUnquotedHash(vLine)
-		val vCodePart = if (vCommentAt >= 0) vLine.substring(0, vCommentAt) else vLine
-		val vCommentPart = if (vCommentAt >= 0) vLine.substring(vCommentAt) else ""
-
-		// Find a key: indent + (optional "- ") + key + ':' + (space|eol).
-		val vColon = indexOfKeyColon(vCodePart)
-		if (vColon > 0) {
-			val vPrefix = vCodePart.substring(0, vColon)
-			val vRest = vCodePart.substring(vColon + 1)
-			// Lead whitespace + optional list marker, then key.
-			var vK = 0
-			while (vK < vPrefix.length && vPrefix[vK].isWhitespace()) { append(vPrefix[vK]); vK++ }
-			if (vK + 1 < vPrefix.length && vPrefix[vK] == '-' && vPrefix[vK + 1].isWhitespace()) {
-				pushStyle(SpanStyle(color = inP.punct)); append('-'); pop()
-				append(vPrefix[vK + 1])
-				vK += 2
-			}
-			pushStyle(SpanStyle(color = inP.key))
-			append(vPrefix.substring(vK))
-			pop()
-			pushStyle(SpanStyle(color = inP.punct)); append(':'); pop()
-			appendYamlValue(vRest, inP)
-		} else {
-			appendYamlValue(vCodePart, inP)
-		}
-		if (vCommentPart.isNotEmpty()) {
-			pushStyle(SpanStyle(color = inP.comment))
-			append(vCommentPart)
-			pop()
-		}
-		if (vIdx < vLines.size - 1) append('\n')
-	}
-}
-
-/* Render the value portion of a YAML line — applies string / number /
-   keyword / list-marker colours where applicable. */
-private fun AnnotatedString.Builder.appendYamlValue(inSeg: String, inP: SyntaxPalette) {
-	val vTrimmed = inSeg.trimStart()
-	val vPad = inSeg.substring(0, inSeg.length - vTrimmed.length)
-	append(vPad)
-	when {
-		vTrimmed.isEmpty() -> { /* nothing */ }
-		vTrimmed.startsWith('-') && (vTrimmed.length == 1 || vTrimmed[1].isWhitespace()) -> {
-			pushStyle(SpanStyle(color = inP.punct)); append('-'); pop()
-			appendYamlValue(vTrimmed.substring(1), inP)
-		}
-		vTrimmed.startsWith('"') || vTrimmed.startsWith('\'') -> {
-			val vQ = vTrimmed[0]
-			val vEnd = vTrimmed.indexOf(vQ, 1).let { if (it < 0) vTrimmed.length else it + 1 }
-			pushStyle(SpanStyle(color = inP.string))
-			append(vTrimmed.substring(0, vEnd))
-			pop()
-			append(vTrimmed.substring(vEnd))
-		}
-		vTrimmed == "true" || vTrimmed == "false" || vTrimmed == "null" || vTrimmed == "~" -> {
-			pushStyle(SpanStyle(color = inP.keyword)); append(vTrimmed); pop()
-		}
-		vTrimmed.first().let { it.isDigit() || it == '-' && vTrimmed.length > 1 && vTrimmed[1].isDigit() } -> {
-			var vJ = 0
-			if (vTrimmed[0] == '-') vJ++
-			while (vJ < vTrimmed.length && (vTrimmed[vJ].isDigit() || vTrimmed[vJ] in ".eE+-")) vJ++
-			pushStyle(SpanStyle(color = inP.number))
-			append(vTrimmed.substring(0, vJ))
-			pop()
-			append(vTrimmed.substring(vJ))
-		}
-		else -> append(vTrimmed)
-	}
-}
-
-/* Find the index of the first '#' that isn't inside a quoted string,
-   or -1 if there is none. Used to split a YAML line into code + comment. */
-private fun findUnquotedHash(inLine: String): Int {
-	var vInSingle = false
-	var vInDouble = false
-	for (vI in inLine.indices) {
-		val vC = inLine[vI]
-		when {
-			vC == '"' && !vInSingle -> vInDouble = !vInDouble
-			vC == '\'' && !vInDouble -> vInSingle = !vInSingle
-			vC == '#' && !vInSingle && !vInDouble -> return vI
-		}
-	}
-	return -1
-}
-
-/* Locate the colon that separates a YAML key from its value at the
-   current indent level — the FIRST unquoted ':' that's followed by
-   either whitespace or end-of-line. Returns -1 if the line has no key. */
-private fun indexOfKeyColon(inLine: String): Int {
-	var vInSingle = false
-	var vInDouble = false
-	for (vI in inLine.indices) {
-		val vC = inLine[vI]
-		when {
-			vC == '"' && !vInSingle -> vInDouble = !vInDouble
-			vC == '\'' && !vInDouble -> vInSingle = !vInSingle
-			vC == ':' && !vInSingle && !vInDouble -> {
-				val vNext = if (vI + 1 < inLine.length) inLine[vI + 1] else ' '
-				if (vNext.isWhitespace() || vI + 1 == inLine.length) return vI
-			}
-		}
-	}
-	return -1
-}

apidemo/src/nativeMain/kotlin/Theme.kt

@@ -1,25 +0,0 @@
-package apidemo
-
-import androidx.compose.runtime.staticCompositionLocalOf
-import androidx.compose.ui.graphics.Color
-
-// ==================
-// MARK: Theme — switchable dark / light palette
-// ==================
-
-class AppColors(
-    val bg: Color, val panel: Color, val field: Color, val border: Color,
-    val accent: Color, val text: Color, val dim: Color, val onAccent: Color,
-)
-
-internal val DarkColors = AppColors(
-    bg = Color(0xFF15161A), panel = Color(0xFF23252C), field = Color(0xFF2D2F37),
-    border = Color(0xFF474C57), accent = Color(0xFF9F88FF), text = Color(0xFFECEEF2),
-    dim = Color(0xFFAEB4BD), onAccent = Color(0xFFFFFFFF),
-)
-internal val LightColors = AppColors(
-    bg = Color(0xFFF3F4F7), panel = Color(0xFFFFFFFF), field = Color(0xFFFFFFFF),
-    border = Color(0xFFCED3DB), accent = Color(0xFF6B4BE6), text = Color(0xFF1B1D22),
-    dim = Color(0xFF5C636E), onAccent = Color(0xFFFFFFFF),
-)
-internal val LocalAppColors = staticCompositionLocalOf { DarkColors }

apidemo/src/nativeMain/kotlin/compat/Compat.native.kt

@@ -0,0 +1,103 @@
+package apidemo.compat
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.platform.ClipEntry
+import com.compose.sdl.LocalComposeNativeWindow
+import com.compose.sdl.TextLayoutConfig
+import com.compose.sdl.appDataDir
+import com.compose.sdl.fileManagerName
+import com.compose.sdl.registerMemoryResource
+import com.compose.sdl.removeMemoryResource
+import com.compose.sdl.res.ResourceKind
+import com.compose.sdl.res.painterResource
+import com.compose.sdl.revealInFileManager
+import com.compose.sdl.showOpenFileDialog
+import com.compose.sdl.showSaveFileDialog
+import com.compose.sdl.text.namedFontFamily
+import androidx.compose.ui.text.Paragraph
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.createFontFamilyResolver
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.sp
+import io.ktor.client.*
+import io.ktor.client.engine.curl.*
+import okio.FileSystem
+
+// ==================
+// MARK: Native actuals - pure delegation to the port's SDL-backed APIs
+// ==================
+
+actual fun appDataDir(inOrg: String, inApp: String): String? =
+    appDataDir(inOrg, inApp)
+
+actual fun revealInFileManager(inPath: String, inOnResult: ((Boolean) -> Unit)?) =
+    revealInFileManager(inPath, inOnResult)
+
+actual fun fileManagerName(): String = fileManagerName()
+
+actual fun showSaveFileDialog(inDefaultName: String?, inOnResult: (String?) -> Unit) =
+    showSaveFileDialog(inDefaultName, inOnResult)
+
+actual fun showOpenFileDialog(inOnResult: (String?) -> Unit) =
+    showOpenFileDialog(inOnResult)
+
+actual fun clipEntryOfText(inText: String): ClipEntry = ClipEntry.withPlainText(inText)
+
+actual fun registerMemoryImage(inKey: String, inBytes: ByteArray) = registerMemoryResource(inKey, inBytes)
+
+actual fun removeMemoryImage(inKey: String) = removeMemoryResource(inKey)
+
+@Composable
+actual fun memoryImagePainter(inKey: String, inSvg: Boolean): Painter =
+    painterResource(inKey, if (inSvg) ResourceKind.Svg else ResourceKind.Raster)
+
+// Cached resolver for wrappedRowCount - the skiko engine resolves fonts by name
+// (projectFontName), so this is just the required non-null Paragraph argument.
+private val mRowCountFontResolver = createFontFamilyResolver()
+
+actual fun wrappedRowCount(inText: String, inFontPx: Int, inMaxWidthPx: Int, inFamilyName: String?): Int {
+    if (inText.isEmpty()) return 1
+    // inFontPx is already physical pixels, so measure at density 1 (fontSize.value
+    // * density = inFontPx) and wrap at inMaxWidthPx px by building a Paragraph.
+    // lineCount comes from skiko's paragraph layout.
+    val vStyle = TextStyle(
+        fontSize = inFontPx.sp,
+        fontFamily = inFamilyName?.let { namedFontFamily(it) },
+    )
+    return Paragraph(
+        text = inText,
+        style = vStyle,
+        constraints = Constraints(maxWidth = inMaxWidthPx.coerceAtLeast(0)),
+        density = Density(1f),
+        fontFamilyResolver = mRowCountFontResolver,
+        spanStyles = emptyList(),
+        placeholders = emptyList(),
+        maxLines = Int.MAX_VALUE,
+        ellipsis = false,
+    ).lineCount
+}
+
+actual var editorTabWidth: Int
+    get() = TextLayoutConfig.tabWidth
+    set(value) {
+        TextLayoutConfig.tabWidth = value
+    }
+
+internal actual val systemFileSystem: FileSystem = FileSystem.SYSTEM
+
+actual fun createApiHttpClient(): HttpClient =
+    HttpClient(Curl)
+
+@Composable
+actual fun InstallWindowHooks(inOnCloseRequest: () -> Boolean, inOnKeyShortcut: (KeyEvent) -> Boolean) {
+    val vWindow = LocalComposeNativeWindow.current
+    DisposableEffect(inOnCloseRequest, inOnKeyShortcut) {
+        vWindow.setOnCloseRequest(inOnCloseRequest)
+        vWindow.setOnKeyShortcut(inOnKeyShortcut)
+        onDispose { vWindow.setOnCloseRequest(null); vWindow.setOnKeyShortcut(null) }
+    }
+}

apidemo/src/nativeMain/kotlin/utils/Bmp.kt

@@ -0,0 +1,83 @@
+package utils
+
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.refTo
+import platform.posix.fclose
+import platform.posix.fopen
+import platform.posix.fwrite
+
+// ==================
+// MARK: BMP save
+// ==================
+// Copy of demo/src/nativeMain/kotlin/utils/Bmp.kt. Kept duplicated rather than
+// promoted into a library module: it is app-level tooling for the drift-check
+// screenshots, and :ui-graphics deliberately does not re-export skiko to apps,
+// so there is no natural shared home that would not widen the published API.
+// ==================
+
+@OptIn(ExperimentalForeignApi::class)
+internal fun writeFile(inPath: String, inBytes: ByteArray) {
+    val vFile = fopen(inPath, "wb") ?: run {
+        println("fopen failed for $inPath")
+        return
+    }
+    fwrite(inBytes.refTo(0), 1u, inBytes.size.toULong(), vFile)
+    fclose(vFile)
+}
+
+/** Minimal BMP writer: 24-bit BGR (drop alpha) with the classic 40-byte
+   BITMAPINFOHEADER. Universally readable, including `sips`. Rows are
+   bottom-up (positive height) and padded to 4 bytes. */
+internal fun encodeBmpBgra32(inWidth: Int, inHeight: Int, inBgra: ByteArray): ByteArray {
+    val kFileHeader = 14
+    val kInfoHeader = 40
+    val vRowBytes = inWidth * 3
+    val vRowPad = (4 - vRowBytes % 4) % 4
+    val vStride = vRowBytes + vRowPad
+    val vPixelBytes = vStride * inHeight
+    val vTotal = kFileHeader + kInfoHeader + vPixelBytes
+    val vOut = ByteArray(vTotal)
+
+    fun putU16LE(off: Int, v: Int) {
+        vOut[off]     = (v and 0xFF).toByte()
+        vOut[off + 1] = ((v ushr 8) and 0xFF).toByte()
+    }
+    fun putU32LE(off: Int, v: Int) {
+        vOut[off]     = (v and 0xFF).toByte()
+        vOut[off + 1] = ((v ushr 8) and 0xFF).toByte()
+        vOut[off + 2] = ((v ushr 16) and 0xFF).toByte()
+        vOut[off + 3] = ((v ushr 24) and 0xFF).toByte()
+    }
+
+    // BITMAPFILEHEADER
+    vOut[0] = 'B'.code.toByte(); vOut[1] = 'M'.code.toByte()
+    putU32LE(2, vTotal)
+    putU32LE(10, kFileHeader + kInfoHeader)
+
+    // BITMAPINFOHEADER
+    val info = kFileHeader
+    putU32LE(info + 0,  kInfoHeader)
+    putU32LE(info + 4,  inWidth)
+    putU32LE(info + 8,  inHeight)              // positive → bottom-up
+    putU16LE(info + 12, 1)
+    putU16LE(info + 14, 24)
+    putU32LE(info + 16, 0)                     // BI_RGB
+    putU32LE(info + 20, vPixelBytes)
+    putU32LE(info + 24, 2835)
+    putU32LE(info + 28, 2835)
+    putU32LE(info + 32, 0)
+    putU32LE(info + 36, 0)
+
+    // Source is top-down BGRA; convert to bottom-up 24-bit BGR.
+    val vPixelOffset = kFileHeader + kInfoHeader
+    for (y in 0 until inHeight) {
+        val vSrcRow = (inHeight - 1 - y) * inWidth * 4
+        val vDstRow = vPixelOffset + y * vStride
+        for (x in 0 until inWidth) {
+            vOut[vDstRow + x * 3 + 0] = inBgra[vSrcRow + x * 4 + 0]  // B
+            vOut[vDstRow + x * 3 + 1] = inBgra[vSrcRow + x * 4 + 1]  // G
+            vOut[vDstRow + x * 3 + 2] = inBgra[vSrcRow + x * 4 + 2]  // R
+        }
+    }
+    return vOut
+}

build.gradle.kts

@@ -1,43 +1,88 @@
-// Root build — declare the Kotlin/Compose plugins once (apply false) so every
-// subproject shares a single plugin classloader. Applying them independently
-// per-subproject can load Kotlin Gradle plugin build services under isolated
-// classloaders, which fails with "X cannot be cast to X" once several modules
-// apply the multiplatform plugin. Each subproject still applies the ones it needs.
+import kotlinx.validation.ExperimentalBCVApi
+
 plugins {
     alias(libs.plugins.kotlin.multiplatform) apply false
+    alias(libs.plugins.kotlin.jvm) apply false
     alias(libs.plugins.kotlin.plugin.compose) apply false
     alias(libs.plugins.kotlin.plugin.serialization) apply false
     alias(libs.plugins.compose.multiplatform) apply false
-    // Public-ABI dumps (api/<module>.klib.api). Used by scripts/compose-fidelity-check.py
-    // to diff our androidx.compose.* surface against the official Compose klib ABI.
     alias(libs.plugins.binary.compatibility.validator)
 }
 
-// Generate klib ABI dumps; the apps and icon-font modules carry no public API
-// surface worth tracking, so skip them.
 apiValidation {
+    @OptIn(ExperimentalBCVApi::class)
     klib { enabled = true }
-    ignoredProjects.addAll(listOf("demo", "apidemo"))
+    // demo/apidemo: apps, no published API. sdl-core: naked SDL cinterop - its
+    // "API" is the generated sdl3.* bindings (per-OS, can't infer macos), not our
+    // surface. material-symbols: auto-generated icon codepoint maps + its jvm
+    // dump trips BCV's ASM on newer JDKs (class file major 69). Track the
+    // hand-authored Compose surface, not generated/binding code.
+    ignoredProjects.addAll(listOf("demo", "apidemo", "sdl-core", "material-symbols"))
 }
 
-// Project coordinates. `group` is baked into every module's Kotlin/Native klib
-// metadata as its module ID (e.g. `com.bitsycore.compose.sdl:ui`) — keep it
-// stable, or a stale IC cache surfaces as "Unknown dependent library …" (see
-// the pitfall note in CLAUDE.md).
-//
 // Version is driven by PUBLISH_VERSION (set from the git tag in the publish
 // workflow, `v1.2.3` → `1.2.3`). Local dev / demo runs default to SNAPSHOT.
 val vPublishVersion = (System.getenv("PUBLISH_VERSION") ?: "0.0.0-SNAPSHOT").removePrefix("v")
+
+// Published groups mirror the org.jetbrains.compose.<area> originals under the
+// com.bitsycore fork name, so each module is the obvious 1:1 fork of its upstream
+// coord (e.g. org.jetbrains.compose.ui:ui → com.bitsycore.compose.ui:ui). Modules
+// with no upstream area (project-only: :sdl-core, :material-symbols) fall through
+// to the default com.bitsycore.compose.sdl group; :desktop-native-window is the
+// headline app-shell artifact, published under com.bitsycore.compose.
+val kDefaultGroup = "com.bitsycore.compose.sdl"
+val kAreaGroups = mapOf(
+    ":compose:ui:ui" to "com.bitsycore.compose.ui",
+    ":compose:ui:ui-graphics" to "com.bitsycore.compose.ui",
+    ":compose:ui:ui-text" to "com.bitsycore.compose.ui",
+    ":compose:ui:ui-unit" to "com.bitsycore.compose.ui",
+    ":compose:ui:ui-geometry" to "com.bitsycore.compose.ui",
+    ":compose:ui:ui-util" to "com.bitsycore.compose.ui",
+    ":compose:ui:ui-backhandler" to "com.bitsycore.compose.ui",
+    ":compose:ui:ui-tooling-preview" to "com.bitsycore.compose.ui",
+    ":compose:foundation:foundation" to "com.bitsycore.compose.foundation",
+    ":compose:foundation:foundation-layout" to "com.bitsycore.compose.foundation",
+    ":compose:animation:animation" to "com.bitsycore.compose.animation",
+    ":compose:animation:animation-core" to "com.bitsycore.compose.animation",
+    ":compose:animation:animation-graphics" to "com.bitsycore.compose.animation",
+    ":compose:material3:material3" to "com.bitsycore.compose.material3",
+    ":compose:material:material-ripple" to "com.bitsycore.compose.material",
+    ":components:resources:components-resources" to "com.bitsycore.compose.components",
+    ":navigation3:navigation3-ui" to "com.bitsycore.navigation3",
+    ":koin:koin-core-viewmodel" to "com.bitsycore.koin",
+    ":koin:koin-compose" to "com.bitsycore.koin",
+    ":koin:koin-compose-viewmodel" to "com.bitsycore.koin",
+    ":koin:koin-compose-navigation3" to "com.bitsycore.koin",
+    ":coil:coil-core" to "com.bitsycore.coil3",
+    ":coil:coil" to "com.bitsycore.coil3",
+    ":coil:coil-compose-core" to "com.bitsycore.coil3",
+    ":coil:coil-compose" to "com.bitsycore.coil3",
+    ":coil:coil-svg" to "com.bitsycore.coil3",
+    ":coil:coil-network-core" to "com.bitsycore.coil3",
+    ":coil:coil-network-ktor3" to "com.bitsycore.coil3",
+    ":pulse:pulse" to "com.bitsycore.pulse",
+    ":pulse:pulse-viewmodel" to "com.bitsycore.pulse",
+    ":pulse:pulse-savedstate" to "com.bitsycore.pulse",
+    ":pulse:pulse-compose" to "com.bitsycore.pulse",
+    ":compose:desktop:native:desktop-native-window" to "com.bitsycore.compose",
+)
+fun groupFor(path: String): String = kAreaGroups[path] ?: kDefaultGroup
+
+// The published artifactId is always the leaf project name - settings.gradle.kts
+// keeps the leaf equal to the artifactId even where the directory differs.
+fun artifactIdFor(path: String): String = path.substringAfterLast(':')
+
 allprojects {
-    group = "com.bitsycore.compose.sdl"
+    group = groupFor(path)
     version = vPublishVersion
 }
 
 // ==================
 // MARK: Publish to GitHub Packages
 // ==================
+
 // Every library module (everything except the two demo apps) auto-registers a
-// MavenPublication via the kotlin-multiplatform plugin — one per target + one
+// MavenPublication via the kotlin-multiplatform plugin - one per target + one
 // for the shared kotlinMultiplatform metadata. The CI publish workflow runs on
 // three hosts (macOS / Linux / Windows) and each invokes only the publication
 // tasks Gradle actually generated for its own targets, so the group of hosts
@@ -46,37 +91,72 @@ allprojects {
 
 val kAppModules = setOf(":demo", ":apidemo")
 val kPublishedLibs = setOf(
-    ":ui", ":ui-util", ":ui-geometry", ":ui-unit", ":ui-backhandler",
-    ":animation-core", ":animation", ":animation-graphics",
-    ":foundation", ":foundation-layout",
-    ":material3", ":material-ripple",
-    ":window", ":material-symbols",
-    ":navigation3-ui", ":components-resources",
+    ":sdl:sdl-core",
+    ":compose:ui:ui", ":compose:ui:ui-util", ":compose:ui:ui-geometry",
+    ":compose:ui:ui-graphics", ":compose:ui:ui-text",
+    ":compose:ui:ui-unit", ":compose:ui:ui-backhandler", ":compose:ui:ui-tooling-preview",
+    ":compose:animation:animation-core", ":compose:animation:animation",
+    ":compose:animation:animation-graphics",
+    ":compose:foundation:foundation", ":compose:foundation:foundation-layout",
+    ":compose:material3:material3", ":compose:material:material-ripple",
+    ":compose:desktop:native:desktop-native-window", ":utils:material-symbols",
+    ":navigation3:navigation3-ui", ":components:resources:components-resources",
+    ":koin:koin-core-viewmodel", ":koin:koin-compose",
+    ":koin:koin-compose-viewmodel", ":koin:koin-compose-navigation3",
+    ":coil:coil-core", ":coil:coil", ":coil:coil-compose-core", ":coil:coil-compose",
+    ":coil:coil-svg", ":coil:coil-network-core", ":coil:coil-network-ktor3",
+    ":pulse:pulse", ":pulse:pulse-viewmodel", ":pulse:pulse-savedstate", ":pulse:pulse-compose",
 )
 
 // -PuseGithubPackages=true swaps every `project(":<lib>")` reference the demo
 // apps make for the published Maven coordinate. Library modules keep resolving
-// each other as `project(...)` — the substitution only fires at the
+// each other as `project(...)` - the substitution only fires at the
 // app→library boundary, so the swap validates end-to-end consumption of the
 // published klibs without touching the source of `implementation(project(...))`.
 // Version defaults to 0.1.0 (matches the git tag) but can be pinned via -PconsumeVersion=….
 val kUseGhPackages = (findProperty("useGithubPackages") as? String)?.toBoolean() == true
 val kConsumeVersion = (findProperty("consumeVersion") as? String) ?: "0.1.0"
 
+// JVM-PARITY VERSION PIN (app modules): force the org.jetbrains.compose groups
+// on every jvm configuration to the catalog pin matching COMPOSE_CORE_REF.
+// Gradle orders "+dev" BELOW the plain version, so whenever the pin is a dev
+// build the umbrella plugin's published artifacts would win conflict resolution
+// and silently break byte-exact parity with the vendored sources.
+val kComposeJvmForced = mapOf(
+    "org.jetbrains.compose.runtime" to libs.versions.compose.get(),
+    "org.jetbrains.compose.ui" to libs.versions.compose.get(),
+    "org.jetbrains.compose.foundation" to libs.versions.compose.get(),
+    "org.jetbrains.compose.animation" to libs.versions.compose.get(),
+    "org.jetbrains.compose.material" to libs.versions.compose.get(),
+    "org.jetbrains.compose.material3" to libs.versions.composeMaterial3.get(),
+)
+
 subprojects {
     if (kUseGhPackages && path in kAppModules) {
         configurations.configureEach {
             resolutionStrategy.dependencySubstitution {
                 kPublishedLibs.forEach { modulePath ->
-                    val vArtifactId = modulePath.removePrefix(":")
+                    val vArtifactId = artifactIdFor(modulePath)
                     substitute(project(modulePath))
-                        .using(module("com.bitsycore.compose.sdl:$vArtifactId:$kConsumeVersion"))
+                        .using(module("${groupFor(modulePath)}:$vArtifactId:$kConsumeVersion"))
                         .because("-PuseGithubPackages=true")
                 }
             }
         }
     }
-    if (path in kAppModules) return@subprojects
+    if (path in kAppModules) {
+        configurations.configureEach {
+            if (name.startsWith("jvm")) {
+                resolutionStrategy.eachDependency {
+                    kComposeJvmForced[requested.group]?.let { useVersion(it) }
+                }
+            }
+        }
+        return@subprojects
+    }
+    // Nesting the paths under compose/ / sdl/ / utils/ … materialises container
+    // projects (:compose, :compose:ui, …) that hold no code - skip them.
+    if (path !in kPublishedLibs) return@subprojects
     plugins.apply("maven-publish")
     afterEvaluate {
         extensions.configure<PublishingExtension> {
@@ -90,11 +170,19 @@ subprojects {
                         password = System.getenv("GITHUB_TOKEN")
                     }
                 }
+                maven {
+                    name = "Bitsycore"
+                    url = uri("https://maven.bitsycore.com/releases")
+                    credentials {
+                        username = System.getenv("BITSYCORE_MAVEN_USER")
+                        password = System.getenv("BITSYCORE_MAVEN_TOKEN")
+                    }
+                }
             }
             publications.withType<MavenPublication>().configureEach {
                 pom {
                     name.set("${rootProject.name} ${project.name}")
-                    description.set("Compose Multiplatform on SDL3 (Kotlin/Native, no JVM) — ${project.name}")
+                    description.set("Compose Multiplatform on SDL3 (Kotlin/Native, no JVM) - ${project.name}")
                     url.set("https://github.com/${System.getenv("GITHUB_REPOSITORY") ?: "bitsycore/ComposeDesktopNative"}")
                     licenses {
                         license {
@@ -108,12 +196,71 @@ subprojects {
     }
 }
 
+// FULL-COMMONIZATION BRIDGE (repo-wide): a module may declare the OFFICIAL
+// Maven Compose artifacts in its commonMain so metadata + jvm resolve them
+// (e.g. :material-symbols' common API); every NATIVE target configuration
+// swaps those modules for the port's project equivalents - the Maven
+// artifacts ship no mingwX64/linux klibs. org.jetbrains.compose.runtime is
+// deliberately NOT here: the port uses the official runtime klibs everywhere.
+val vNativeTargetTokens = listOf("mingwX64", "linuxX64", "linuxArm64", "macosArm64")
+allprojects {
+    configurations.configureEach {
+        if (vNativeTargetTokens.any { name.contains(it, ignoreCase = true) }) {
+            resolutionStrategy.dependencySubstitution {
+                substitute(module("org.jetbrains.compose.ui:ui")).using(project(":compose:ui:ui"))
+                // ui-graphics / ui-text are their own modules (split out of :ui,
+                // upstream layout). Declare each DIRECTLY so the app commonMain sees
+                // them under the granular-metadata visibility rule.
+                substitute(module("org.jetbrains.compose.ui:ui-graphics")).using(project(":compose:ui:ui-graphics"))
+                substitute(module("org.jetbrains.compose.ui:ui-text")).using(project(":compose:ui:ui-text"))
+                substitute(module("org.jetbrains.compose.ui:ui-unit")).using(project(":compose:ui:ui-unit"))
+                substitute(module("org.jetbrains.compose.ui:ui-geometry")).using(project(":compose:ui:ui-geometry"))
+                substitute(module("org.jetbrains.compose.ui:ui-util")).using(project(":compose:ui:ui-util"))
+                substitute(module("org.jetbrains.compose.ui:ui-tooling-preview")).using(project(":compose:ui:ui-tooling-preview"))
+                substitute(module("org.jetbrains.compose.foundation:foundation")).using(project(":compose:foundation:foundation"))
+                substitute(module("org.jetbrains.compose.foundation:foundation-layout")).using(project(":compose:foundation:foundation-layout"))
+                substitute(module("org.jetbrains.compose.animation:animation")).using(project(":compose:animation:animation"))
+                substitute(module("org.jetbrains.compose.animation:animation-core")).using(project(":compose:animation:animation-core"))
+                substitute(module("org.jetbrains.compose.material3:material3")).using(project(":compose:material3:material3"))
+                // navigation3-ui: the JB Maven artifact has no K/N desktop
+                // klibs - the port vendors it as :navigation3-ui.
+                substitute(module("org.jetbrains.androidx.navigation3:navigation3-ui")).using(project(":navigation3:navigation3-ui"))
+                // components-resources: the official resources runtime ships no
+                // mingwX64/linux klibs - the port vendors it as :components-resources.
+                substitute(module("org.jetbrains.compose.components:components-resources")).using(project(":components:resources:components-resources"))
+                // Koin: koin-core itself publishes mingwX64 + linux and is used
+                // from Maven; these four stop at apple+android upstream.
+                substitute(module("io.insert-koin:koin-core-viewmodel")).using(project(":koin:koin-core-viewmodel"))
+                substitute(module("io.insert-koin:koin-compose")).using(project(":koin:koin-compose"))
+                substitute(module("io.insert-koin:koin-compose-viewmodel")).using(project(":koin:koin-compose-viewmodel"))
+                substitute(module("io.insert-koin:koin-compose-navigation3")).using(project(":koin:koin-compose-navigation3"))
+                // Coil 3: no mingwX64 upstream anywhere, and no linux for the
+                // compose layer either.
+                substitute(module("io.coil-kt.coil3:coil-core")).using(project(":coil:coil-core"))
+                substitute(module("io.coil-kt.coil3:coil")).using(project(":coil:coil"))
+                substitute(module("io.coil-kt.coil3:coil-compose-core")).using(project(":coil:coil-compose-core"))
+                substitute(module("io.coil-kt.coil3:coil-compose")).using(project(":coil:coil-compose"))
+                substitute(module("io.coil-kt.coil3:coil-svg")).using(project(":coil:coil-svg"))
+                substitute(module("io.coil-kt.coil3:coil-network-core")).using(project(":coil:coil-network-core"))
+                substitute(module("io.coil-kt.coil3:coil-network-ktor3")).using(project(":coil:coil-network-ktor3"))
+                // Pulse MVI: upstream publishes com.bitsycore.lib:* with no desktop
+                // native targets. The port republishes under com.bitsycore.pulse so the
+                // two coordinates never collide, and substitutes the official one here.
+                substitute(module("com.bitsycore.lib:pulse")).using(project(":pulse:pulse"))
+                substitute(module("com.bitsycore.lib:pulse-viewmodel")).using(project(":pulse:pulse-viewmodel"))
+                substitute(module("com.bitsycore.lib:pulse-savedstate")).using(project(":pulse:pulse-savedstate"))
+                substitute(module("com.bitsycore.lib:pulse-compose")).using(project(":pulse:pulse-compose"))
+            }
+        }
+    }
+}
+
 // Whether the current host can build the mingwX64 target. Kotlin/Native can
-// only cross-compile mingwX64 cinterops from a Windows host — the sdl3_ttf /
-// sdl3_image cinterops need Windows SDL3 headers under libs/ (produced by
-// scripts/build-sdl/build-*.sh, which only runs on Windows). Declaring `mingwX64()` on
-// a non-Windows host is safe for pure-Kotlin modules but blows up the moment
-// a `depends = sdl3` cinterop tries to include SDL3_ttf/SDL_ttf.h.
+// only cross-compile the mingwX64 sdl3 cinterop from a Windows host - it needs
+// the Windows SDL3 headers under libs/ (produced by scripts/build-sdl/build-all.py
+// run on a Windows host). Declaring `mingwX64()` on a non-Windows host is safe
+// for pure-Kotlin modules but blows up the moment the sdl3 cinterop tries to
+// include SDL3's headers.
 // Override with `-PforceMingw=true` if you actually have the headers wired.
 val vHostSupportsMingw = System.getProperty("os.name").startsWith("Windows") ||
     (findProperty("forceMingw") as? String)?.toBoolean() == true

buildSrc/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+	`kotlin-dsl`
+}
+
+repositories {
+	mavenCentral()
+}

buildSrc/src/main/kotlin/com/bitsycore/compose/sdl/build/ComposeFontBundling.kt

@@ -0,0 +1,349 @@
+package com.bitsycore.compose.sdl.build
+
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.file.Directory
+import org.gradle.api.file.RegularFile
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.AbstractCopyTask
+import org.gradle.api.tasks.Exec
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.bundling.Zip
+import org.gradle.kotlin.dsl.extra
+import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.withType
+import org.gradle.language.jvm.tasks.ProcessResources
+import java.net.URI
+
+// ==================
+// MARK: Configuration
+// ==================
+
+/**
+ * Per-app knobs for [registerComposeFontBundling]. EVERYTHING is opt-in - with no
+ * flag set the call registers no tasks and stages nothing.
+ */
+class ComposeFontBundlingConfig {
+	/**
+	 * Bundle font/NotoSans.ttf, the default UI font the text renderers load at startup.
+	 * -PbundleDefaultFont=false still skips it (system-font fallback).
+	 */
+	var bundleNotoSans: Boolean = false
+
+	/**
+	 * Always bundle font/NotoSansMono.ttf - for apps that load the mono font through
+	 * their own seam (apidemo's body font, Fonts.kt), invisible to auto-detection.
+	 */
+	var bundleNotoSansMono: Boolean = false
+
+	/**
+	 * Bundle font/NotoSansMono.ttf only when `FontFamily.Monospace` appears in the
+	 * app's Kotlin sources (it backs the generic monospace family at runtime).
+	 */
+	var autoDetectNotoSansMono: Boolean = false
+
+	/**
+	 * Bundle one Material Symbols font per style whose call sites appear in the app's
+	 * Kotlin sources (MaterialSymbolsOutlined / Rounded / Sharp).
+	 */
+	var bundleMaterialSymbols: Boolean = false
+
+	/**
+	 * Subset each bundled Material Symbols font to the glyphs the sources reference
+	 * (scripts/subset-material-symbols.py picks the codepoints; the subset task uses
+	 * hb-subset when present, else fontTools via Python - auto-installed - and only
+	 * bundles the full font if neither is available). Needs [bundleMaterialSymbols];
+	 * still gated by -PsubsetIcons.
+	 */
+	var enableIconSubsetting: Boolean = false
+}
+
+// A style's font is bundled only when its call sites appear in the sources.
+private val kAllStyles = listOf(
+	"Outlined" to Regex("\\bMaterialSymbolsOutlined\\b"),
+	"Rounded" to Regex("\\bMaterialSymbolsRounded\\b"),
+	"Sharp" to Regex("\\bMaterialSymbolsSharp\\b"),
+)
+
+// FontFamily.Monospace call sites → NotoSansMono is worth bundling.
+private val kMonospaceRegex = Regex("\\bFontFamily\\.Monospace\\b")
+
+// ==================
+// MARK: Entry point
+// ==================
+
+/**
+ * Wires the app font pipeline shared by :demo and :apidemo. Everything is OPT-IN via
+ * [ComposeFontBundlingConfig] - a bare call is a no-op.
+ *
+ * - Registers downloadNotoFonts (Noto Sans + Noto Sans Mono variable fonts →
+ *   build/fonts/) when a Noto font is bundled.
+ * - Adds the opted-in font/ entries to every data.kres Zip task - the bridge plugin's
+ *   package<Variant>ComposeResources<Target> tasks or an app's own copy* tasks
+ *   (matching{} is lazy: the plugin's tasks appear in its afterEvaluate). Material
+ *   Symbols fonts are hb-subset to the used glyphs when subsetting is enabled.
+ * - Stages the same fonts (always full, never subset) onto the JVM classpath via
+ *   jvmProcessResources: the :material-symbols JVM actual loads font/<Style>.ttf, and
+ *   the parity harness's JVM leg renders with the same NotoSans as the native leg
+ *   (P0.3, RENDERER.md §8).
+ */
+fun Project.registerComposeFontBundling(configure: ComposeFontBundlingConfig.() -> Unit) {
+	val vConfig = ComposeFontBundlingConfig().apply(configure)
+
+	// ============
+	//  What to bundle
+	// ============
+	val vBundleSans = vConfig.bundleNotoSans &&
+			providers.gradleProperty("bundleDefaultFont").map(String::toBoolean).getOrElse(true)
+	val vBundleMono = vConfig.bundleNotoSansMono ||
+			(vConfig.autoDetectNotoSansMono && sourcesMatch(kMonospaceRegex))
+	val vUsedStyles = if (vConfig.bundleMaterialSymbols) detectUsedStyles() else emptyList()
+	if (!vBundleSans && !vBundleMono && vUsedStyles.isEmpty()) return
+
+	val vSubsetIcons = vConfig.enableIconSubsetting && vUsedStyles.isNotEmpty() &&
+			providers.gradleProperty("subsetIcons").map(String::toBoolean).getOrElse(false)
+	// One subset task per used style, shared by all variant×target archives.
+	val vSubsetTasksByStyle = if (vSubsetIcons) registerIconSubsetPipeline(vUsedStyles) else emptyMap()
+
+	// ============
+	//  Noto downloads
+	// ============
+	val vNotoSansFile = layout.buildDirectory.file("fonts/NotoSans.ttf")
+	val vNotoMonoFile = layout.buildDirectory.file("fonts/NotoSansMono.ttf")
+	val vNotoFiles = buildList {
+		if (vBundleSans) add(vNotoSansFile)
+		if (vBundleMono) add(vNotoMonoFile)
+	}
+	val vDownloadNotoFonts = if (vNotoFiles.isEmpty()) null else tasks.register("downloadNotoFonts") {
+		description = "Download the Google Noto variable fonts (Sans + SansMono) to build/fonts/."
+		val vDownloads = listOf(
+			"https://raw.githubusercontent.com/google/fonts/main/ofl/notosans/NotoSans%5Bwdth%2Cwght%5D.ttf"
+					to vNotoSansFile.get().asFile,
+			"https://raw.githubusercontent.com/google/fonts/main/ofl/notosansmono/NotoSansMono%5Bwdth%2Cwght%5D.ttf"
+					to vNotoMonoFile.get().asFile,
+		)
+		outputs.files(vDownloads.map { it.second })
+		doLast {
+			for ((vUrl, vOut) in vDownloads) {
+				if (vOut.exists() && vOut.length() > 0) continue
+				vOut.parentFile.mkdirs()
+				println("Downloading $vUrl")
+				URI(vUrl).toURL().openStream().use { vIn -> vOut.outputStream().use { vIn.copyTo(it) } }
+			}
+		}
+	}
+
+	// ============
+	//  data.kres font/ entries (native) + JVM classpath analog
+	// ============
+	tasks.withType<Zip>().matching {
+		(it.name.startsWith("package") || it.name.startsWith("copy")) && it.name.contains("ComposeResources")
+	}.configureEach {
+		addFontEntries(this, vNotoFiles, vDownloadNotoFonts, vUsedStyles, vSubsetTasksByStyle)
+	}
+	tasks.withType<ProcessResources>().matching { it.name == "jvmProcessResources" }.configureEach {
+		// Full fonts on JVM - Skiko applies the variable axes itself (Typeface.makeClone).
+		addFontEntries(this, vNotoFiles, vDownloadNotoFonts, vUsedStyles, emptyMap())
+	}
+}
+
+// ==================
+// MARK: Source scanning
+// ==================
+
+/**
+ * True when any Kotlin file under src/ matches inRegex.
+ */
+private fun Project.sourcesMatch(inRegex: Regex): Boolean {
+	val vSrcRoot = layout.projectDirectory.dir("src").asFile
+	return vSrcRoot.exists() && vSrcRoot.walk().any {
+		it.isFile && it.extension == "kt" && inRegex.containsMatchIn(it.readText())
+	}
+}
+
+/**
+ * The Material Symbols styles whose call sites appear in the app's Kotlin sources.
+ */
+private fun Project.detectUsedStyles(): List<String> {
+	val vSrcRoot = layout.projectDirectory.dir("src").asFile
+	if (!vSrcRoot.exists()) return emptyList()
+	val vUsed = mutableSetOf<String>()
+	vSrcRoot.walk().filter { it.isFile && it.extension == "kt" }.forEach { vFile ->
+		val vText = vFile.readText()
+		for ((vStyle, vRegex) in kAllStyles) {
+			if (vStyle !in vUsed && vRegex.containsMatchIn(vText)) vUsed.add(vStyle)
+		}
+	}
+	return vUsed.toList()
+}
+
+// ==================
+// MARK: Font staging
+// ==================
+
+/**
+ * Adds the font/ entries (Notos + used Material Symbols styles) to inTask - a data.kres
+ * Zip or jvmProcessResources. inSubsetTasksByStyle maps styles to hb-subset tasks whose
+ * output replaces the full font; pass an empty map to stage the full fonts.
+ */
+private fun Project.addFontEntries(
+	inTask: AbstractCopyTask,
+	inNotoFiles: List<Provider<RegularFile>>,
+	inDownloadNotoFonts: TaskProvider<*>?,
+	inUsedStyles: List<String>,
+	inSubsetTasksByStyle: Map<String, TaskProvider<*>>,
+) {
+	for (vNotoFile in inNotoFiles) {
+		inTask.from(vNotoFile) { into("font") }
+		inDownloadNotoFonts?.let { inTask.dependsOn(it) }
+	}
+	val vSymbolsProject = rootProject.project(":utils:material-symbols")
+	for (vStyle in inUsedStyles) {
+		@Suppress("UNCHECKED_CAST")
+		val vFontFile = vSymbolsProject.extra["iconFontFile$vStyle"] as Provider<RegularFile>
+		val vDownloadTask = vSymbolsProject.extra["iconFontDownloadTask$vStyle"] as TaskProvider<*>
+		val vSubsetTask = inSubsetTasksByStyle[vStyle]
+		if (vSubsetTask != null) {
+			// Subset output keeps the original filename : runtime registration unchanged.
+			val vOriginalName = vFontFile.get().asFile.name
+			inTask.from(vSubsetTask.get().outputs.files) {
+				into("font")
+				rename { vOriginalName }
+			}
+			inTask.dependsOn(vSubsetTask)
+		} else {
+			inTask.from(vFontFile) { into("font") }
+		}
+		inTask.dependsOn(vDownloadTask)
+	}
+}
+
+// ==================
+// MARK: Icon subsetting
+// ==================
+
+/**
+ * Registers the icon-subset pipeline: findMaterialSymbolsUsage scans src/ for
+ * MaterialSymbols.<Name> usages → usage-codepoint.txt, then one subsetMaterialSymbols<Style>
+ * task per used style hb-subsets that style's font to the referenced glyphs.
+ */
+private fun Project.registerIconSubsetPipeline(inUsedStyles: List<String>): Map<String, TaskProvider<*>> {
+	val vIconsBuildDir = layout.buildDirectory.dir("icons")
+	val vFindUsage = tasks.register<Exec>("findMaterialSymbolsUsage") {
+		description = "Scan src/ for MaterialSymbols.<Name> usages → usage-codepoint.txt."
+		val vScript = rootProject.layout.projectDirectory.file("scripts/subset-material-symbols.py").asFile
+		val vConstants = rootProject.project(":utils:material-symbols").layout.projectDirectory
+			.file("src/commonMain/kotlin/com/compose/sdl/icons/MaterialSymbols.kt").asFile
+		val vUsageFile = vIconsBuildDir.get().file("usage-codepoint.txt").asFile
+		inputs.files(fileTree("src") { include("**/*.kt") })
+		inputs.file(vConstants)
+		outputs.file(vUsageFile)
+		commandLine(
+			"python3", vScript.absolutePath,
+			"--src", layout.projectDirectory.dir("src").asFile.absolutePath,
+			"--constants", vConstants.absolutePath,
+			"--out", vUsageFile.absolutePath,
+		)
+	}
+	return inUsedStyles.associateWith { vStyle -> registerSubsetTask(vStyle, vIconsBuildDir, vFindUsage) }
+}
+
+/**
+ * Subset inStyle's downloaded TTF to the codepoints in usage-codepoint.txt, into this
+ * app's build/icons/. Prefers hb-subset (harfbuzz); falls back to fontTools via Python
+ * (variable-font-aware, auto-installed via pip) when hb-subset is absent; bundles the
+ * full font only if neither subsetter is available.
+ */
+private fun Project.registerSubsetTask(
+	inStyle: String,
+	inIconsBuildDir: Provider<Directory>,
+	inFindUsage: TaskProvider<*>,
+): TaskProvider<*> {
+	val vSymbolsProject = rootProject.project(":utils:material-symbols")
+	return tasks.register("subsetMaterialSymbols$inStyle") {
+		description = "hb-subset the $inStyle Material Symbols font to icons actually used."
+		@Suppress("UNCHECKED_CAST")
+		val vInputProvider = vSymbolsProject.extra["iconFontFile$inStyle"] as Provider<RegularFile>
+		val vDownloadTask = vSymbolsProject.extra["iconFontDownloadTask$inStyle"] as TaskProvider<*>
+		val vOut = inIconsBuildDir.get().file("MaterialSymbols$inStyle.subset.ttf").asFile
+		val vUsage = inIconsBuildDir.get().file("usage-codepoint.txt").asFile
+		inputs.file(vInputProvider)
+		inputs.file(vUsage)
+		outputs.file(vOut)
+		dependsOn(inFindUsage)
+		dependsOn(vDownloadTask)
+		doLast {
+			val vCodepoints = vUsage.readLines()
+				.filter { it.isNotBlank() && !it.startsWith("#") && it.contains("=") }
+				.map { it.substringAfter("=").trim().removePrefix("0x").removePrefix("0X") }
+			if (vCodepoints.isEmpty()) throw GradleException(
+				"usage-codepoint.txt has no entries : refusing to subset to an empty font."
+			)
+			val vUnicodes = vCodepoints.joinToString(",") { "U+$it" }
+			vOut.parentFile.mkdirs()
+			val vInputFile = vInputProvider.get().asFile
+			val vBefore = vInputFile.length()
+			// project.exec isn't usable inside doLast on Gradle 9, so shell out via
+			// ProcessBuilder. Returns (exitedZero, combinedOutput); a missing binary
+			// (IOException) yields (false, message) so callers can fall through.
+			fun runCmd(vararg inCmd: String): Pair<Boolean, String> =
+				try {
+					val vProc = ProcessBuilder(*inCmd).redirectErrorStream(true).start()
+					val vText = vProc.inputStream.bufferedReader().readText()
+					(vProc.waitFor() == 0) to vText
+				} catch (e: java.io.IOException) {
+					false to (e.message ?: "not found")
+				}
+
+			fun logShrink(inTool: String) {
+				val vAfter = vOut.length()
+				val vPct = if (vBefore == 0L) 0 else (100 - 100 * vAfter / vBefore).coerceAtLeast(0)
+				logger.lifecycle(
+					"[subset $inStyle] ${vBefore / 1024}KB → ${vAfter / 1024}KB (-$vPct%) · " +
+							"${vCodepoints.size} glyphs kept [$inTool]"
+				)
+			}
+
+			// 1. hb-subset (harfbuzz) - fastest path when it is on PATH.
+			if (runCmd("hb-subset", vInputFile.absolutePath, "-o", vOut.absolutePath, "--unicodes=$vUnicodes").first
+				&& vOut.length() > 0L
+			) {
+				logShrink("hb-subset"); return@doLast
+			}
+
+			// 2. fontTools (pyftsubset) via Python - the portable fallback. Python is
+			//    already a build prerequisite (SDL build + vendor sync) and fontTools is
+			//    variable-font-aware, so the FILL/wght/GRAD/opsz axes survive. It is
+			//    auto-installed if missing, so no manual harfbuzz install is ever required.
+			val vPython = listOf("python3", "python", "py").firstOrNull { runCmd(it, "--version").first }
+			if (vPython != null) {
+				if (!runCmd(vPython, "-c", "import fontTools").first) {
+					logger.lifecycle("[subset $inStyle] fontTools not present - installing it via pip…")
+					// --user (no root) → --break-system-packages (PEP 668) → plain.
+					listOf(listOf("--user"), listOf("--break-system-packages"), emptyList<String>())
+						.firstOrNull { vExtra ->
+							runCmd(
+								vPython, "-m", "pip", "install", "-q", "--disable-pip-version-check",
+								*vExtra.toTypedArray(), "fonttools"
+							).first
+						}
+				}
+				val (vFtOk, vFtOut) = runCmd(
+					vPython, "-m", "fontTools.subset", vInputFile.absolutePath,
+					"--unicodes=$vUnicodes", "--output-file=${vOut.absolutePath}"
+				)
+				if (vFtOk && vOut.length() > 0L) { logShrink("fontTools"); return@doLast }
+				logger.warn("[subset $inStyle] fontTools subset failed :\n$vFtOut")
+			}
+
+			// 3. Last resort : the full font - correct, just larger.
+			vInputFile.copyTo(vOut, overwrite = true)
+			logger.warn(
+				"[subset $inStyle] no working subsetter found (hb-subset or python3+fontTools) : " +
+						"bundling the full font (${vBefore / 1024}KB). Install harfbuzz " +
+						"(brew install harfbuzz / apt install harfbuzz-utils / " +
+						"pacman -S mingw-w64-x86_64-harfbuzz) or put python3 on PATH."
+			)
+		}
+	}
+}

coil/coil-compose-core/api/coil-compose-core.klib.api

@@ -0,0 +1,240 @@
+// Klib ABI Dump
+// Targets: [linuxArm64, linuxX64, macosArm64, mingwX64]
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: true
+// - Show declarations: true
+
+// Library unique name: <com.bitsycore.coil3:coil-compose-core>
+abstract fun interface coil3.compose/AsyncImagePreviewHandler { // coil3.compose/AsyncImagePreviewHandler|null[0]
+    abstract suspend fun handle(coil3/ImageLoader, coil3.request/ImageRequest): coil3.compose/AsyncImagePainter.State // coil3.compose/AsyncImagePreviewHandler.handle|handle(coil3.ImageLoader;coil3.request.ImageRequest){}[0]
+
+    final object Companion { // coil3.compose/AsyncImagePreviewHandler.Companion|null[0]
+        final val Default // coil3.compose/AsyncImagePreviewHandler.Companion.Default|{}Default[0]
+            final fun <get-Default>(): coil3.compose/AsyncImagePreviewHandler // coil3.compose/AsyncImagePreviewHandler.Companion.Default.<get-Default>|<get-Default>(){}[0]
+    }
+}
+
+abstract interface coil3.compose/AsyncImageModelEqualityDelegate { // coil3.compose/AsyncImageModelEqualityDelegate|null[0]
+    abstract fun equals(kotlin/Any?, kotlin/Any?): kotlin/Boolean // coil3.compose/AsyncImageModelEqualityDelegate.equals|equals(kotlin.Any?;kotlin.Any?){}[0]
+    abstract fun hashCode(kotlin/Any?): kotlin/Int // coil3.compose/AsyncImageModelEqualityDelegate.hashCode|hashCode(kotlin.Any?){}[0]
+
+    final object Companion { // coil3.compose/AsyncImageModelEqualityDelegate.Companion|null[0]
+        final val AllProperties // coil3.compose/AsyncImageModelEqualityDelegate.Companion.AllProperties|{}AllProperties[0]
+            final fun <get-AllProperties>(): coil3.compose/AsyncImageModelEqualityDelegate // coil3.compose/AsyncImageModelEqualityDelegate.Companion.AllProperties.<get-AllProperties>|<get-AllProperties>(){}[0]
+        final val Default // coil3.compose/AsyncImageModelEqualityDelegate.Companion.Default|{}Default[0]
+            final fun <get-Default>(): coil3.compose/AsyncImageModelEqualityDelegate // coil3.compose/AsyncImageModelEqualityDelegate.Companion.Default.<get-Default>|<get-Default>(){}[0]
+    }
+}
+
+abstract interface coil3.compose/DrawScopeSizeResolver : coil3.size/SizeResolver { // coil3.compose/DrawScopeSizeResolver|null[0]
+    abstract fun connect(kotlinx.coroutines.flow/Flow<androidx.compose.ui.geometry/Size>) // coil3.compose/DrawScopeSizeResolver.connect|connect(kotlinx.coroutines.flow.Flow<androidx.compose.ui.geometry.Size>){}[0]
+}
+
+abstract interface coil3.compose/SubcomposeAsyncImageScope : androidx.compose.foundation.layout/BoxScope { // coil3.compose/SubcomposeAsyncImageScope|null[0]
+    abstract val alignment // coil3.compose/SubcomposeAsyncImageScope.alignment|{}alignment[0]
+        abstract fun <get-alignment>(): androidx.compose.ui/Alignment // coil3.compose/SubcomposeAsyncImageScope.alignment.<get-alignment>|<get-alignment>(){}[0]
+    abstract val alpha // coil3.compose/SubcomposeAsyncImageScope.alpha|{}alpha[0]
+        abstract fun <get-alpha>(): kotlin/Float // coil3.compose/SubcomposeAsyncImageScope.alpha.<get-alpha>|<get-alpha>(){}[0]
+    abstract val clipToBounds // coil3.compose/SubcomposeAsyncImageScope.clipToBounds|{}clipToBounds[0]
+        abstract fun <get-clipToBounds>(): kotlin/Boolean // coil3.compose/SubcomposeAsyncImageScope.clipToBounds.<get-clipToBounds>|<get-clipToBounds>(){}[0]
+    abstract val colorFilter // coil3.compose/SubcomposeAsyncImageScope.colorFilter|{}colorFilter[0]
+        abstract fun <get-colorFilter>(): androidx.compose.ui.graphics/ColorFilter? // coil3.compose/SubcomposeAsyncImageScope.colorFilter.<get-colorFilter>|<get-colorFilter>(){}[0]
+    abstract val contentDescription // coil3.compose/SubcomposeAsyncImageScope.contentDescription|{}contentDescription[0]
+        abstract fun <get-contentDescription>(): kotlin/String? // coil3.compose/SubcomposeAsyncImageScope.contentDescription.<get-contentDescription>|<get-contentDescription>(){}[0]
+    abstract val contentScale // coil3.compose/SubcomposeAsyncImageScope.contentScale|{}contentScale[0]
+        abstract fun <get-contentScale>(): androidx.compose.ui.layout/ContentScale // coil3.compose/SubcomposeAsyncImageScope.contentScale.<get-contentScale>|<get-contentScale>(){}[0]
+    abstract val painter // coil3.compose/SubcomposeAsyncImageScope.painter|{}painter[0]
+        abstract fun <get-painter>(): coil3.compose/AsyncImagePainter // coil3.compose/SubcomposeAsyncImageScope.painter.<get-painter>|<get-painter>(){}[0]
+}
+
+final class coil3.compose/AsyncImagePainter : androidx.compose.runtime/RememberObserver, androidx.compose.ui.graphics.painter/Painter { // coil3.compose/AsyncImagePainter|null[0]
+    final val input // coil3.compose/AsyncImagePainter.input|{}input[0]
+        final fun <get-input>(): kotlinx.coroutines.flow/StateFlow<coil3.compose/AsyncImagePainter.Input> // coil3.compose/AsyncImagePainter.input.<get-input>|<get-input>(){}[0]
+    final val intrinsicSize // coil3.compose/AsyncImagePainter.intrinsicSize|{}intrinsicSize[0]
+        final fun <get-intrinsicSize>(): androidx.compose.ui.geometry/Size // coil3.compose/AsyncImagePainter.intrinsicSize.<get-intrinsicSize>|<get-intrinsicSize>(){}[0]
+    final val state // coil3.compose/AsyncImagePainter.state|{}state[0]
+        final fun <get-state>(): kotlinx.coroutines.flow/StateFlow<coil3.compose/AsyncImagePainter.State> // coil3.compose/AsyncImagePainter.state.<get-state>|<get-state>(){}[0]
+
+    final fun onAbandoned() // coil3.compose/AsyncImagePainter.onAbandoned|onAbandoned(){}[0]
+    final fun onForgotten() // coil3.compose/AsyncImagePainter.onForgotten|onForgotten(){}[0]
+    final fun onRemembered() // coil3.compose/AsyncImagePainter.onRemembered|onRemembered(){}[0]
+    final fun restart() // coil3.compose/AsyncImagePainter.restart|restart(){}[0]
+
+    sealed interface State { // coil3.compose/AsyncImagePainter.State|null[0]
+        abstract val painter // coil3.compose/AsyncImagePainter.State.painter|{}painter[0]
+            abstract fun <get-painter>(): androidx.compose.ui.graphics.painter/Painter? // coil3.compose/AsyncImagePainter.State.painter.<get-painter>|<get-painter>(){}[0]
+
+        final class Error : coil3.compose/AsyncImagePainter.State { // coil3.compose/AsyncImagePainter.State.Error|null[0]
+            constructor <init>(androidx.compose.ui.graphics.painter/Painter?, coil3.request/ErrorResult) // coil3.compose/AsyncImagePainter.State.Error.<init>|<init>(androidx.compose.ui.graphics.painter.Painter?;coil3.request.ErrorResult){}[0]
+
+            final val painter // coil3.compose/AsyncImagePainter.State.Error.painter|{}painter[0]
+                final fun <get-painter>(): androidx.compose.ui.graphics.painter/Painter? // coil3.compose/AsyncImagePainter.State.Error.painter.<get-painter>|<get-painter>(){}[0]
+            final val result // coil3.compose/AsyncImagePainter.State.Error.result|{}result[0]
+                final fun <get-result>(): coil3.request/ErrorResult // coil3.compose/AsyncImagePainter.State.Error.result.<get-result>|<get-result>(){}[0]
+
+            final fun component1(): androidx.compose.ui.graphics.painter/Painter? // coil3.compose/AsyncImagePainter.State.Error.component1|component1(){}[0]
+            final fun component2(): coil3.request/ErrorResult // coil3.compose/AsyncImagePainter.State.Error.component2|component2(){}[0]
+            final fun copy(androidx.compose.ui.graphics.painter/Painter? = ..., coil3.request/ErrorResult = ...): coil3.compose/AsyncImagePainter.State.Error // coil3.compose/AsyncImagePainter.State.Error.copy|copy(androidx.compose.ui.graphics.painter.Painter?;coil3.request.ErrorResult){}[0]
+            final fun equals(kotlin/Any?): kotlin/Boolean // coil3.compose/AsyncImagePainter.State.Error.equals|equals(kotlin.Any?){}[0]
+            final fun hashCode(): kotlin/Int // coil3.compose/AsyncImagePainter.State.Error.hashCode|hashCode(){}[0]
+            final fun toString(): kotlin/String // coil3.compose/AsyncImagePainter.State.Error.toString|toString(){}[0]
+        }
+
+        final class Loading : coil3.compose/AsyncImagePainter.State { // coil3.compose/AsyncImagePainter.State.Loading|null[0]
+            constructor <init>(androidx.compose.ui.graphics.painter/Painter?) // coil3.compose/AsyncImagePainter.State.Loading.<init>|<init>(androidx.compose.ui.graphics.painter.Painter?){}[0]
+
+            final val painter // coil3.compose/AsyncImagePainter.State.Loading.painter|{}painter[0]
+                final fun <get-painter>(): androidx.compose.ui.graphics.painter/Painter? // coil3.compose/AsyncImagePainter.State.Loading.painter.<get-painter>|<get-painter>(){}[0]
+
+            final fun component1(): androidx.compose.ui.graphics.painter/Painter? // coil3.compose/AsyncImagePainter.State.Loading.component1|component1(){}[0]
+            final fun copy(androidx.compose.ui.graphics.painter/Painter? = ...): coil3.compose/AsyncImagePainter.State.Loading // coil3.compose/AsyncImagePainter.State.Loading.copy|copy(androidx.compose.ui.graphics.painter.Painter?){}[0]
+            final fun equals(kotlin/Any?): kotlin/Boolean // coil3.compose/AsyncImagePainter.State.Loading.equals|equals(kotlin.Any?){}[0]
+            final fun hashCode(): kotlin/Int // coil3.compose/AsyncImagePainter.State.Loading.hashCode|hashCode(){}[0]
+            final fun toString(): kotlin/String // coil3.compose/AsyncImagePainter.State.Loading.toString|toString(){}[0]
+        }
+
+        final class Success : coil3.compose/AsyncImagePainter.State { // coil3.compose/AsyncImagePainter.State.Success|null[0]
+            constructor <init>(androidx.compose.ui.graphics.painter/Painter, coil3.request/SuccessResult) // coil3.compose/AsyncImagePainter.State.Success.<init>|<init>(androidx.compose.ui.graphics.painter.Painter;coil3.request.SuccessResult){}[0]
+
+            final val painter // coil3.compose/AsyncImagePainter.State.Success.painter|{}painter[0]
+                final fun <get-painter>(): androidx.compose.ui.graphics.painter/Painter // coil3.compose/AsyncImagePainter.State.Success.painter.<get-painter>|<get-painter>(){}[0]
+            final val result // coil3.compose/AsyncImagePainter.State.Success.result|{}result[0]
+                final fun <get-result>(): coil3.request/SuccessResult // coil3.compose/AsyncImagePainter.State.Success.result.<get-result>|<get-result>(){}[0]
+
+            final fun component1(): androidx.compose.ui.graphics.painter/Painter // coil3.compose/AsyncImagePainter.State.Success.component1|component1(){}[0]
+            final fun component2(): coil3.request/SuccessResult // coil3.compose/AsyncImagePainter.State.Success.component2|component2(){}[0]
+            final fun copy(androidx.compose.ui.graphics.painter/Painter = ..., coil3.request/SuccessResult = ...): coil3.compose/AsyncImagePainter.State.Success // coil3.compose/AsyncImagePainter.State.Success.copy|copy(androidx.compose.ui.graphics.painter.Painter;coil3.request.SuccessResult){}[0]
+            final fun equals(kotlin/Any?): kotlin/Boolean // coil3.compose/AsyncImagePainter.State.Success.equals|equals(kotlin.Any?){}[0]
+            final fun hashCode(): kotlin/Int // coil3.compose/AsyncImagePainter.State.Success.hashCode|hashCode(){}[0]
+            final fun toString(): kotlin/String // coil3.compose/AsyncImagePainter.State.Success.toString|toString(){}[0]
+        }
+
+        final object Empty : coil3.compose/AsyncImagePainter.State { // coil3.compose/AsyncImagePainter.State.Empty|null[0]
+            final val painter // coil3.compose/AsyncImagePainter.State.Empty.painter|{}painter[0]
+                final fun <get-painter>(): androidx.compose.ui.graphics.painter/Painter? // coil3.compose/AsyncImagePainter.State.Empty.painter.<get-painter>|<get-painter>(){}[0]
+
+            final fun equals(kotlin/Any?): kotlin/Boolean // coil3.compose/AsyncImagePainter.State.Empty.equals|equals(kotlin.Any?){}[0]
+            final fun hashCode(): kotlin/Int // coil3.compose/AsyncImagePainter.State.Empty.hashCode|hashCode(){}[0]
+            final fun toString(): kotlin/String // coil3.compose/AsyncImagePainter.State.Empty.toString|toString(){}[0]
+        }
+    }
+
+    final class Input { // coil3.compose/AsyncImagePainter.Input|null[0]
+        constructor <init>(coil3/ImageLoader, coil3.request/ImageRequest, coil3.compose/AsyncImageModelEqualityDelegate) // coil3.compose/AsyncImagePainter.Input.<init>|<init>(coil3.ImageLoader;coil3.request.ImageRequest;coil3.compose.AsyncImageModelEqualityDelegate){}[0]
+
+        final val imageLoader // coil3.compose/AsyncImagePainter.Input.imageLoader|{}imageLoader[0]
+            final fun <get-imageLoader>(): coil3/ImageLoader // coil3.compose/AsyncImagePainter.Input.imageLoader.<get-imageLoader>|<get-imageLoader>(){}[0]
+        final val modelEqualityDelegate // coil3.compose/AsyncImagePainter.Input.modelEqualityDelegate|{}modelEqualityDelegate[0]
+            final fun <get-modelEqualityDelegate>(): coil3.compose/AsyncImageModelEqualityDelegate // coil3.compose/AsyncImagePainter.Input.modelEqualityDelegate.<get-modelEqualityDelegate>|<get-modelEqualityDelegate>(){}[0]
+        final val request // coil3.compose/AsyncImagePainter.Input.request|{}request[0]
+            final fun <get-request>(): coil3.request/ImageRequest // coil3.compose/AsyncImagePainter.Input.request.<get-request>|<get-request>(){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // coil3.compose/AsyncImagePainter.Input.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // coil3.compose/AsyncImagePainter.Input.hashCode|hashCode(){}[0]
+    }
+
+    final object Companion { // coil3.compose/AsyncImagePainter.Companion|null[0]
+        final val DefaultTransform // coil3.compose/AsyncImagePainter.Companion.DefaultTransform|{}DefaultTransform[0]
+            final fun <get-DefaultTransform>(): kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State> // coil3.compose/AsyncImagePainter.Companion.DefaultTransform.<get-DefaultTransform>|<get-DefaultTransform>(){}[0]
+    }
+}
+
+final class coil3.compose/ConstraintsSizeResolver : androidx.compose.ui.layout/LayoutModifier, coil3.size/SizeResolver { // coil3.compose/ConstraintsSizeResolver|null[0]
+    constructor <init>() // coil3.compose/ConstraintsSizeResolver.<init>|<init>(){}[0]
+
+    final fun (androidx.compose.ui.layout/MeasureScope).measure(androidx.compose.ui.layout/Measurable, androidx.compose.ui.unit/Constraints): androidx.compose.ui.layout/MeasureResult // coil3.compose/ConstraintsSizeResolver.measure|measure@androidx.compose.ui.layout.MeasureScope(androidx.compose.ui.layout.Measurable;androidx.compose.ui.unit.Constraints){}[0]
+    final fun setConstraints(androidx.compose.ui.unit/Constraints) // coil3.compose/ConstraintsSizeResolver.setConstraints|setConstraints(androidx.compose.ui.unit.Constraints){}[0]
+    final suspend fun size(): coil3.size/Size // coil3.compose/ConstraintsSizeResolver.size|size(){}[0]
+}
+
+final class coil3.compose/CrossfadePainter : androidx.compose.ui.graphics.painter/Painter { // coil3.compose/CrossfadePainter|null[0]
+    constructor <init>(androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.layout/ContentScale = ..., kotlin.time/Duration = ..., kotlin.time/TimeSource = ..., kotlin/Boolean = ..., kotlin/Boolean = ...) // coil3.compose/CrossfadePainter.<init>|<init>(androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.layout.ContentScale;kotlin.time.Duration;kotlin.time.TimeSource;kotlin.Boolean;kotlin.Boolean){}[0]
+    constructor <init>(androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.layout/ContentScale = ..., kotlin.time/Duration = ..., kotlin.time/TimeSource = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ...) // coil3.compose/CrossfadePainter.<init>|<init>(androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.layout.ContentScale;kotlin.time.Duration;kotlin.time.TimeSource;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean){}[0]
+
+    final val contentScale // coil3.compose/CrossfadePainter.contentScale|{}contentScale[0]
+        final fun <get-contentScale>(): androidx.compose.ui.layout/ContentScale // coil3.compose/CrossfadePainter.contentScale.<get-contentScale>|<get-contentScale>(){}[0]
+    final val duration // coil3.compose/CrossfadePainter.duration|{}duration[0]
+        final fun <get-duration>(): kotlin.time/Duration // coil3.compose/CrossfadePainter.duration.<get-duration>|<get-duration>(){}[0]
+    final val end // coil3.compose/CrossfadePainter.end|{}end[0]
+        final fun <get-end>(): androidx.compose.ui.graphics.painter/Painter? // coil3.compose/CrossfadePainter.end.<get-end>|<get-end>(){}[0]
+    final val fadeStart // coil3.compose/CrossfadePainter.fadeStart|{}fadeStart[0]
+        final fun <get-fadeStart>(): kotlin/Boolean // coil3.compose/CrossfadePainter.fadeStart.<get-fadeStart>|<get-fadeStart>(){}[0]
+    final val intrinsicSize // coil3.compose/CrossfadePainter.intrinsicSize|{}intrinsicSize[0]
+        final fun <get-intrinsicSize>(): androidx.compose.ui.geometry/Size // coil3.compose/CrossfadePainter.intrinsicSize.<get-intrinsicSize>|<get-intrinsicSize>(){}[0]
+    final val preferEndFirstIntrinsicSize // coil3.compose/CrossfadePainter.preferEndFirstIntrinsicSize|{}preferEndFirstIntrinsicSize[0]
+        final fun <get-preferEndFirstIntrinsicSize>(): kotlin/Boolean // coil3.compose/CrossfadePainter.preferEndFirstIntrinsicSize.<get-preferEndFirstIntrinsicSize>|<get-preferEndFirstIntrinsicSize>(){}[0]
+    final val preferExactIntrinsicSize // coil3.compose/CrossfadePainter.preferExactIntrinsicSize|{}preferExactIntrinsicSize[0]
+        final fun <get-preferExactIntrinsicSize>(): kotlin/Boolean // coil3.compose/CrossfadePainter.preferExactIntrinsicSize.<get-preferExactIntrinsicSize>|<get-preferExactIntrinsicSize>(){}[0]
+    final val timeSource // coil3.compose/CrossfadePainter.timeSource|{}timeSource[0]
+        final fun <get-timeSource>(): kotlin.time/TimeSource // coil3.compose/CrossfadePainter.timeSource.<get-timeSource>|<get-timeSource>(){}[0]
+
+    final var start // coil3.compose/CrossfadePainter.start|{}start[0]
+        final fun <get-start>(): androidx.compose.ui.graphics.painter/Painter? // coil3.compose/CrossfadePainter.start.<get-start>|<get-start>(){}[0]
+}
+
+final class coil3.compose/ImagePainter : androidx.compose.ui.graphics.painter/Painter { // coil3.compose/ImagePainter|null[0]
+    constructor <init>(coil3/Image) // coil3.compose/ImagePainter.<init>|<init>(coil3.Image){}[0]
+
+    final val image // coil3.compose/ImagePainter.image|{}image[0]
+        final fun <get-image>(): coil3/Image // coil3.compose/ImagePainter.image.<get-image>|<get-image>(){}[0]
+    final val intrinsicSize // coil3.compose/ImagePainter.intrinsicSize|{}intrinsicSize[0]
+        final fun <get-intrinsicSize>(): androidx.compose.ui.geometry/Size // coil3.compose/ImagePainter.intrinsicSize.<get-intrinsicSize>|<get-intrinsicSize>(){}[0]
+}
+
+final val coil3.compose/LocalAsyncImageModelEqualityDelegate // coil3.compose/LocalAsyncImageModelEqualityDelegate|{}LocalAsyncImageModelEqualityDelegate[0]
+    final fun <get-LocalAsyncImageModelEqualityDelegate>(): androidx.compose.runtime/ProvidableCompositionLocal<coil3.compose/AsyncImageModelEqualityDelegate> // coil3.compose/LocalAsyncImageModelEqualityDelegate.<get-LocalAsyncImageModelEqualityDelegate>|<get-LocalAsyncImageModelEqualityDelegate>(){}[0]
+final val coil3.compose/LocalAsyncImagePreviewHandler // coil3.compose/LocalAsyncImagePreviewHandler|{}LocalAsyncImagePreviewHandler[0]
+    final fun <get-LocalAsyncImagePreviewHandler>(): androidx.compose.runtime/ProvidableCompositionLocal<coil3.compose/AsyncImagePreviewHandler> // coil3.compose/LocalAsyncImagePreviewHandler.<get-LocalAsyncImagePreviewHandler>|<get-LocalAsyncImagePreviewHandler>(){}[0]
+final val coil3.compose/LocalPlatformContext // coil3.compose/LocalPlatformContext|{}LocalPlatformContext[0]
+    final fun <get-LocalPlatformContext>(): androidx.compose.runtime/ProvidableCompositionLocal<coil3/PlatformContext> // coil3.compose/LocalPlatformContext.<get-LocalPlatformContext>|<get-LocalPlatformContext>(){}[0]
+final val coil3.compose/coil3_compose_AsyncImagePainter$stableprop // coil3.compose/coil3_compose_AsyncImagePainter$stableprop|#static{}coil3_compose_AsyncImagePainter$stableprop[0]
+final val coil3.compose/coil3_compose_AsyncImagePainter_Input$stableprop // coil3.compose/coil3_compose_AsyncImagePainter_Input$stableprop|#static{}coil3_compose_AsyncImagePainter_Input$stableprop[0]
+final val coil3.compose/coil3_compose_AsyncImagePainter_State_Empty$stableprop // coil3.compose/coil3_compose_AsyncImagePainter_State_Empty$stableprop|#static{}coil3_compose_AsyncImagePainter_State_Empty$stableprop[0]
+final val coil3.compose/coil3_compose_AsyncImagePainter_State_Error$stableprop // coil3.compose/coil3_compose_AsyncImagePainter_State_Error$stableprop|#static{}coil3_compose_AsyncImagePainter_State_Error$stableprop[0]
+final val coil3.compose/coil3_compose_AsyncImagePainter_State_Loading$stableprop // coil3.compose/coil3_compose_AsyncImagePainter_State_Loading$stableprop|#static{}coil3_compose_AsyncImagePainter_State_Loading$stableprop[0]
+final val coil3.compose/coil3_compose_AsyncImagePainter_State_Success$stableprop // coil3.compose/coil3_compose_AsyncImagePainter_State_Success$stableprop|#static{}coil3_compose_AsyncImagePainter_State_Success$stableprop[0]
+final val coil3.compose/coil3_compose_ConstraintsSizeResolver$stableprop // coil3.compose/coil3_compose_ConstraintsSizeResolver$stableprop|#static{}coil3_compose_ConstraintsSizeResolver$stableprop[0]
+final val coil3.compose/coil3_compose_CrossfadePainter$stableprop // coil3.compose/coil3_compose_CrossfadePainter$stableprop|#static{}coil3_compose_CrossfadePainter$stableprop[0]
+final val coil3.compose/coil3_compose_ImagePainter$stableprop // coil3.compose/coil3_compose_ImagePainter$stableprop|#static{}coil3_compose_ImagePainter$stableprop[0]
+final val coil3.compose/preferEndFirstIntrinsicSize // coil3.compose/preferEndFirstIntrinsicSize|@coil3.Extras.Key.Companion{}preferEndFirstIntrinsicSize[0]
+    final fun (coil3/Extras.Key.Companion).<get-preferEndFirstIntrinsicSize>(): coil3/Extras.Key<kotlin/Boolean> // coil3.compose/preferEndFirstIntrinsicSize.<get-preferEndFirstIntrinsicSize>|<get-preferEndFirstIntrinsicSize>@coil3.Extras.Key.Companion(){}[0]
+final val coil3.compose/preferEndFirstIntrinsicSize // coil3.compose/preferEndFirstIntrinsicSize|@coil3.request.ImageRequest{}preferEndFirstIntrinsicSize[0]
+    final fun (coil3.request/ImageRequest).<get-preferEndFirstIntrinsicSize>(): kotlin/Boolean // coil3.compose/preferEndFirstIntrinsicSize.<get-preferEndFirstIntrinsicSize>|<get-preferEndFirstIntrinsicSize>@coil3.request.ImageRequest(){}[0]
+final val coil3.compose/useExistingImageAsPlaceholder // coil3.compose/useExistingImageAsPlaceholder|@coil3.Extras.Key.Companion{}useExistingImageAsPlaceholder[0]
+    final fun (coil3/Extras.Key.Companion).<get-useExistingImageAsPlaceholder>(): coil3/Extras.Key<kotlin/Boolean> // coil3.compose/useExistingImageAsPlaceholder.<get-useExistingImageAsPlaceholder>|<get-useExistingImageAsPlaceholder>@coil3.Extras.Key.Companion(){}[0]
+final val coil3.compose/useExistingImageAsPlaceholder // coil3.compose/useExistingImageAsPlaceholder|@coil3.request.ImageRequest{}useExistingImageAsPlaceholder[0]
+    final fun (coil3.request/ImageRequest).<get-useExistingImageAsPlaceholder>(): kotlin/Boolean // coil3.compose/useExistingImageAsPlaceholder.<get-useExistingImageAsPlaceholder>|<get-useExistingImageAsPlaceholder>@coil3.request.ImageRequest(){}[0]
+
+final fun (coil3.compose/SubcomposeAsyncImageScope).coil3.compose/SubcomposeAsyncImageContent(androidx.compose.ui/Modifier?, androidx.compose.ui.graphics.painter/Painter?, kotlin/String?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImageContent|SubcomposeAsyncImageContent@coil3.compose.SubcomposeAsyncImageScope(androidx.compose.ui.Modifier?;androidx.compose.ui.graphics.painter.Painter?;kotlin.String?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun (coil3.request/ImageRequest.Builder).coil3.compose/preferEndFirstIntrinsicSize(kotlin/Boolean): coil3.request/ImageRequest.Builder // coil3.compose/preferEndFirstIntrinsicSize|preferEndFirstIntrinsicSize@coil3.request.ImageRequest.Builder(kotlin.Boolean){}[0]
+final fun (coil3.request/ImageRequest.Builder).coil3.compose/useExistingImageAsPlaceholder(kotlin/Boolean): coil3.request/ImageRequest.Builder // coil3.compose/useExistingImageAsPlaceholder|useExistingImageAsPlaceholder@coil3.request.ImageRequest.Builder(kotlin.Boolean){}[0]
+final fun (coil3/Image).coil3.compose/asPainter(coil3/PlatformContext, androidx.compose.ui.graphics/FilterQuality = ...): androidx.compose.ui.graphics.painter/Painter // coil3.compose/asPainter|asPainter@coil3.Image(coil3.PlatformContext;androidx.compose.ui.graphics.FilterQuality){}[0]
+final fun (coil3/ImageLoader.Builder).coil3.compose/preferEndFirstIntrinsicSize(kotlin/Boolean): coil3/ImageLoader.Builder // coil3.compose/preferEndFirstIntrinsicSize|preferEndFirstIntrinsicSize@coil3.ImageLoader.Builder(kotlin.Boolean){}[0]
+final fun (coil3/ImageLoader.Builder).coil3.compose/useExistingImageAsPlaceholder(kotlin/Boolean): coil3/ImageLoader.Builder // coil3.compose/useExistingImageAsPlaceholder|useExistingImageAsPlaceholder@coil3.ImageLoader.Builder(kotlin.Boolean){}[0]
+final fun coil3.compose/AsyncImage(kotlin/Any?, kotlin/String?, coil3/ImageLoader, androidx.compose.ui/Modifier?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/AsyncImage|AsyncImage(kotlin.Any?;kotlin.String?;coil3.ImageLoader;androidx.compose.ui.Modifier?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/AsyncImage(kotlin/Any?, kotlin/String?, coil3/ImageLoader, androidx.compose.ui/Modifier?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/AsyncImage|AsyncImage(kotlin.Any?;kotlin.String?;coil3.ImageLoader;androidx.compose.ui.Modifier?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/AsyncImage(kotlin/Any?, kotlin/String?, coil3/ImageLoader, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/AsyncImage|AsyncImage(kotlin.Any?;kotlin.String?;coil3.ImageLoader;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/AsyncImage(kotlin/Any?, kotlin/String?, coil3/ImageLoader, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/AsyncImage|AsyncImage(kotlin.Any?;kotlin.String?;coil3.ImageLoader;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/DrawScopeSizeResolver(): coil3.compose/DrawScopeSizeResolver // coil3.compose/DrawScopeSizeResolver|DrawScopeSizeResolver(){}[0]
+final fun coil3.compose/SubcomposeAsyncImage(kotlin/Any?, kotlin/String?, coil3/ImageLoader, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, kotlin/Boolean, kotlin/Function3<coil3.compose/SubcomposeAsyncImageScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImage|SubcomposeAsyncImage(kotlin.Any?;kotlin.String?;coil3.ImageLoader;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;kotlin.Boolean;kotlin.Function3<coil3.compose.SubcomposeAsyncImageScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/SubcomposeAsyncImage(kotlin/Any?, kotlin/String?, coil3/ImageLoader, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, kotlin/Boolean, kotlin/Function3<coil3.compose/SubcomposeAsyncImageScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImage|SubcomposeAsyncImage(kotlin.Any?;kotlin.String?;coil3.ImageLoader;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;kotlin.Boolean;kotlin.Function3<coil3.compose.SubcomposeAsyncImageScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/SubcomposeAsyncImage(kotlin/Any?, kotlin/String?, coil3/ImageLoader, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Loading, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Success, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Error, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImage|SubcomposeAsyncImage(kotlin.Any?;kotlin.String?;coil3.ImageLoader;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Loading,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Success,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Error,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/SubcomposeAsyncImage(kotlin/Any?, kotlin/String?, coil3/ImageLoader, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Loading, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Success, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Error, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImage|SubcomposeAsyncImage(kotlin.Any?;kotlin.String?;coil3.ImageLoader;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Loading,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Success,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Error,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/coil3_compose_AsyncImagePainter$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_AsyncImagePainter$stableprop_getter|coil3_compose_AsyncImagePainter$stableprop_getter(){}[0]
+final fun coil3.compose/coil3_compose_AsyncImagePainter_Input$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_AsyncImagePainter_Input$stableprop_getter|coil3_compose_AsyncImagePainter_Input$stableprop_getter(){}[0]
+final fun coil3.compose/coil3_compose_AsyncImagePainter_State_Empty$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_AsyncImagePainter_State_Empty$stableprop_getter|coil3_compose_AsyncImagePainter_State_Empty$stableprop_getter(){}[0]
+final fun coil3.compose/coil3_compose_AsyncImagePainter_State_Error$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_AsyncImagePainter_State_Error$stableprop_getter|coil3_compose_AsyncImagePainter_State_Error$stableprop_getter(){}[0]
+final fun coil3.compose/coil3_compose_AsyncImagePainter_State_Loading$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_AsyncImagePainter_State_Loading$stableprop_getter|coil3_compose_AsyncImagePainter_State_Loading$stableprop_getter(){}[0]
+final fun coil3.compose/coil3_compose_AsyncImagePainter_State_Success$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_AsyncImagePainter_State_Success$stableprop_getter|coil3_compose_AsyncImagePainter_State_Success$stableprop_getter(){}[0]
+final fun coil3.compose/coil3_compose_ConstraintsSizeResolver$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_ConstraintsSizeResolver$stableprop_getter|coil3_compose_ConstraintsSizeResolver$stableprop_getter(){}[0]
+final fun coil3.compose/coil3_compose_CrossfadePainter$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_CrossfadePainter$stableprop_getter|coil3_compose_CrossfadePainter$stableprop_getter(){}[0]
+final fun coil3.compose/coil3_compose_ImagePainter$stableprop_getter(): kotlin/Int // coil3.compose/coil3_compose_ImagePainter$stableprop_getter|coil3_compose_ImagePainter$stableprop_getter(){}[0]
+final fun coil3.compose/rememberAsyncImagePainter(kotlin/Any?, coil3/ImageLoader, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui.layout/ContentScale?, androidx.compose.ui.graphics/FilterQuality, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): coil3.compose/AsyncImagePainter // coil3.compose/rememberAsyncImagePainter|rememberAsyncImagePainter(kotlin.Any?;coil3.ImageLoader;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.layout.ContentScale?;androidx.compose.ui.graphics.FilterQuality;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/rememberAsyncImagePainter(kotlin/Any?, coil3/ImageLoader, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui.layout/ContentScale?, androidx.compose.ui.graphics/FilterQuality?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): coil3.compose/AsyncImagePainter // coil3.compose/rememberAsyncImagePainter|rememberAsyncImagePainter(kotlin.Any?;coil3.ImageLoader;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.layout.ContentScale?;androidx.compose.ui.graphics.FilterQuality?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/rememberAsyncImagePainter(kotlin/Any?, coil3/ImageLoader, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui.layout/ContentScale?, androidx.compose.ui.graphics/FilterQuality, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): coil3.compose/AsyncImagePainter // coil3.compose/rememberAsyncImagePainter|rememberAsyncImagePainter(kotlin.Any?;coil3.ImageLoader;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.layout.ContentScale?;androidx.compose.ui.graphics.FilterQuality;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/rememberAsyncImagePainter(kotlin/Any?, coil3/ImageLoader, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui.layout/ContentScale?, androidx.compose.ui.graphics/FilterQuality?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): coil3.compose/AsyncImagePainter // coil3.compose/rememberAsyncImagePainter|rememberAsyncImagePainter(kotlin.Any?;coil3.ImageLoader;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.layout.ContentScale?;androidx.compose.ui.graphics.FilterQuality?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/rememberConstraintsSizeResolver(androidx.compose.runtime/Composer?, kotlin/Int): coil3.compose/ConstraintsSizeResolver // coil3.compose/rememberConstraintsSizeResolver|rememberConstraintsSizeResolver(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun coil3.compose/rememberDrawScopeSizeResolver(androidx.compose.runtime/Composer?, kotlin/Int): coil3.compose/DrawScopeSizeResolver // coil3.compose/rememberDrawScopeSizeResolver|rememberDrawScopeSizeResolver(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final inline fun coil3.compose/AsyncImagePreviewHandler(crossinline kotlin.coroutines/SuspendFunction1<coil3.request/ImageRequest, coil3/Image>): coil3.compose/AsyncImagePreviewHandler // coil3.compose/AsyncImagePreviewHandler|AsyncImagePreviewHandler(kotlin.coroutines.SuspendFunction1<coil3.request.ImageRequest,coil3.Image>){}[0]
+final inline fun coil3.compose/AsyncImagePreviewHandler(crossinline kotlin.coroutines/SuspendFunction1<coil3.request/ImageRequest, coil3/Image?>): coil3.compose/AsyncImagePreviewHandler // coil3.compose/AsyncImagePreviewHandler|AsyncImagePreviewHandler(kotlin.coroutines.SuspendFunction1<coil3.request.ImageRequest,coil3.Image?>){}[0]

coil/coil-compose-core/build.gradle.kts

@@ -0,0 +1,69 @@
+// :coil:coil-compose-core - AsyncImage / rememberAsyncImagePainter internals, vendored
+// VERBATIM from coil-kt/coil. Upstream publishes NO desktop-native klibs for the
+// compose layer at all (neither mingwX64 nor linux), so this whole module exists to
+// give the port its targets. Compose coords substitute to the port's project modules
+// on every native configuration (root build's commonization bridge).
+plugins {
+	alias(libs.plugins.kotlin.multiplatform)
+	alias(libs.plugins.kotlin.plugin.compose)
+}
+
+val vHostSupportsMingw = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+kotlin {
+	linuxArm64(); linuxX64(); macosArm64(); if (vHostSupportsMingw) mingwX64()
+	applyDefaultHierarchyTemplate()
+	sourceSets {
+		commonMain {
+			dependencies {
+				api(project(":coil:coil-core"))
+				// Declared DIRECTLY, not leaned on transitively: these coords are
+				// SUBSTITUTED to the port's project modules on native configurations,
+				// and KGP's granular-metadata visibility rule then drops the substituted
+				// module's transitives from the commonMain metadata classpath (CLAUDE.md
+				// "Common pitfalls"). Every artifact the vendored common code touches
+				// needs its own declaration + its own bridge rule.
+				api("org.jetbrains.compose.runtime:runtime:${libs.versions.composeRuntime.get()}")
+				api("org.jetbrains.compose.ui:ui:${libs.versions.compose.get()}")
+				api("org.jetbrains.compose.ui:ui-graphics:${libs.versions.compose.get()}")
+				api("org.jetbrains.compose.ui:ui-text:${libs.versions.compose.get()}")
+				api("org.jetbrains.compose.ui:ui-unit:${libs.versions.compose.get()}")
+				api("org.jetbrains.compose.ui:ui-geometry:${libs.versions.compose.get()}")
+				api("org.jetbrains.compose.ui:ui-util:${libs.versions.compose.get()}")
+				api("org.jetbrains.compose.foundation:foundation:${libs.versions.compose.get()}")
+				api("org.jetbrains.compose.foundation:foundation-layout:${libs.versions.compose.get()}")
+			}
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+		// Upstream's nonAndroid compose layer reaches straight into org.jetbrains.skia
+		// (Canvas / Bitmap.asComposeImageBitmap), so it needs skiko on its own compile
+		// classpath - official for macOS/Linux, the bitsycore FORK for mingwX64, on two
+		// PARALLEL branches. See coil/coil-core/build.gradle.kts.
+		fun nonAndroidBranch(inName: String, inSkiko: Any) = create("${inName}NonAndroidMain") {
+			dependsOn(commonMain.get())
+			kotlin.srcDir("src/vendor/nonAndroid/kotlin")
+			dependencies { implementation(inSkiko) }
+		}
+
+		val vOfficial = nonAndroidBranch("coilComposeOfficial", libs.skiko)
+		get("macosArm64Main").dependsOn(vOfficial)
+		get("linuxX64Main").dependsOn(vOfficial)
+		get("linuxArm64Main").dependsOn(vOfficial)
+
+		if (vHostSupportsMingw) {
+			val vFork = nonAndroidBranch(
+				"coilComposeFork",
+				"com.bitsycore.skiko:skiko:${providers.gradleProperty("skikoMingwVersion").getOrElse(libs.versions.skikoMingw.get())}",
+			)
+			get("mingwX64Main").dependsOn(vFork)
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=coil3.annotation.InternalCoilApi",
+			"-opt-in=coil3.annotation.ExperimentalCoilApi",
+			"-opt-in=coil3.annotation.DelicateCoilApi",
+		)
+	}
+}

coil/coil-compose-core/compose-fork.txt

@@ -0,0 +1,44 @@
+# :coil:coil-compose-core - AsyncImage / rememberAsyncImagePainter internals.
+# Upstream publishes NEITHER mingwX64 NOR linux for the compose layer.
+# Upstream source sets collapse onto this port: it has NO android, jvm or js
+# target, so nonAndroidMain / nonJvmCommonMain / nonJsCommonMain / nativeMain all
+# apply to EVERY target here. They land in TWO trees, not one: the non* sets keep
+# their own level (src/vendor/nonAndroid) ABOVE src/vendor/native, because some of
+# them declare `expect`s whose `actual`s live in upstream nativeMain - collapsing
+# both into one source set makes expect and actual siblings, which is an error. appleMain is macosArm64
+# only and nonAppleMain is linux + mingw, so those two keep their own trees (the
+# build file wires a `nonAppleMain` intermediate; appleMain comes from the default
+# hierarchy template).
+SET_REPO=https://github.com/coil-kt/coil@<COIL_REF>
+
+SET_FOLDER=coil-compose-core/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/coil3/compose/AsyncImage.kt -> src/vendor/common/kotlin/coil3/compose/AsyncImage.kt
+#     | commonMain/kotlin/coil3/compose/AsyncImagePainter.kt -> src/vendor/common/kotlin/coil3/compose/AsyncImagePainter.kt
+#     | commonMain/kotlin/coil3/compose/ConstraintsSizeResolver.kt -> src/vendor/common/kotlin/coil3/compose/ConstraintsSizeResolver.kt
+#     | commonMain/kotlin/coil3/compose/CrossfadePainter.kt -> src/vendor/common/kotlin/coil3/compose/CrossfadePainter.kt
+#     | commonMain/kotlin/coil3/compose/DrawScopeSizeResolver.kt -> src/vendor/common/kotlin/coil3/compose/DrawScopeSizeResolver.kt
+#     | commonMain/kotlin/coil3/compose/ImagePainter.kt -> src/vendor/common/kotlin/coil3/compose/ImagePainter.kt
+#     | commonMain/kotlin/coil3/compose/LocalAsyncImageModelEqualityDelegate.kt -> src/vendor/common/kotlin/coil3/compose/LocalAsyncImageModelEqualityDelegate.kt
+#     | commonMain/kotlin/coil3/compose/LocalAsyncImagePreviewHandler.kt -> src/vendor/common/kotlin/coil3/compose/LocalAsyncImagePreviewHandler.kt
+#     | commonMain/kotlin/coil3/compose/LocalPlatformContext.kt -> src/vendor/common/kotlin/coil3/compose/LocalPlatformContext.kt
+#     | commonMain/kotlin/coil3/compose/SubcomposeAsyncImage.kt -> src/vendor/common/kotlin/coil3/compose/SubcomposeAsyncImage.kt
+#     | commonMain/kotlin/coil3/compose/imageRequests.kt -> src/vendor/common/kotlin/coil3/compose/imageRequests.kt
+#     | commonMain/kotlin/coil3/compose/internal/ContentPainterModifier.kt -> src/vendor/common/kotlin/coil3/compose/internal/ContentPainterModifier.kt
+#     | commonMain/kotlin/coil3/compose/internal/DeferredDispatch.kt -> src/vendor/common/kotlin/coil3/compose/internal/DeferredDispatch.kt
+#     | commonMain/kotlin/coil3/compose/internal/ForwardingCoroutineContext.kt -> src/vendor/common/kotlin/coil3/compose/internal/ForwardingCoroutineContext.kt
+#     | commonMain/kotlin/coil3/compose/internal/utils.kt -> src/vendor/common/kotlin/coil3/compose/internal/utils.kt
+nonAndroidMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonAndroidMain/kotlin/coil3/compose/AsyncImagePainter.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/compose/AsyncImagePainter.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/compose/ImagePainter.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/compose/ImagePainter.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/compose/LocalPlatformContext.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/compose/LocalPlatformContext.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/compose/internal/utils.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/compose/internal/utils.nonAndroid.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   androidMain (4)
+#     | androidMain/kotlin/coil3/compose/AsyncImagePainter.android.kt -> src/vendor/android/kotlin/coil3/compose/AsyncImagePainter.android.kt
+#     | androidMain/kotlin/coil3/compose/ImagePainter.android.kt -> src/vendor/android/kotlin/coil3/compose/ImagePainter.android.kt
+#     | androidMain/kotlin/coil3/compose/LocalPlatformContext.android.kt -> src/vendor/android/kotlin/coil3/compose/LocalPlatformContext.android.kt
+#     | androidMain/kotlin/coil3/compose/internal/utils.android.kt -> src/vendor/android/kotlin/coil3/compose/internal/utils.android.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>

coil/coil-compose/api/coil-compose.klib.api

@@ -0,0 +1,21 @@
+// Klib ABI Dump
+// Targets: [linuxArm64, linuxX64, macosArm64, mingwX64]
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: true
+// - Show declarations: true
+
+// Library unique name: <com.bitsycore.coil3:coil-compose>
+final fun coil3.compose/AsyncImage(kotlin/Any?, kotlin/String?, androidx.compose.ui/Modifier?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/AsyncImage|AsyncImage(kotlin.Any?;kotlin.String?;androidx.compose.ui.Modifier?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/AsyncImage(kotlin/Any?, kotlin/String?, androidx.compose.ui/Modifier?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/AsyncImage|AsyncImage(kotlin.Any?;kotlin.String?;androidx.compose.ui.Modifier?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/AsyncImage(kotlin/Any?, kotlin/String?, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/AsyncImage|AsyncImage(kotlin.Any?;kotlin.String?;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/AsyncImage(kotlin/Any?, kotlin/String?, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/AsyncImage|AsyncImage(kotlin.Any?;kotlin.String?;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/SubcomposeAsyncImage(kotlin/Any?, kotlin/String?, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, kotlin/Boolean, kotlin/Function3<coil3.compose/SubcomposeAsyncImageScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImage|SubcomposeAsyncImage(kotlin.Any?;kotlin.String?;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;kotlin.Boolean;kotlin.Function3<coil3.compose.SubcomposeAsyncImageScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/SubcomposeAsyncImage(kotlin/Any?, kotlin/String?, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, kotlin/Boolean, kotlin/Function3<coil3.compose/SubcomposeAsyncImageScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImage|SubcomposeAsyncImage(kotlin.Any?;kotlin.String?;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;kotlin.Boolean;kotlin.Function3<coil3.compose.SubcomposeAsyncImageScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/SubcomposeAsyncImage(kotlin/Any?, kotlin/String?, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Loading, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Success, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Error, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImage|SubcomposeAsyncImage(kotlin.Any?;kotlin.String?;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Loading,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Success,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Error,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/SubcomposeAsyncImage(kotlin/Any?, kotlin/String?, androidx.compose.ui/Modifier?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Loading, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Success, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<coil3.compose/SubcomposeAsyncImageScope, coil3.compose/AsyncImagePainter.State.Error, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // coil3.compose/SubcomposeAsyncImage|SubcomposeAsyncImage(kotlin.Any?;kotlin.String?;androidx.compose.ui.Modifier?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Loading,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Success,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<coil3.compose.SubcomposeAsyncImageScope,coil3.compose.AsyncImagePainter.State.Error,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/rememberAsyncImagePainter(kotlin/Any?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui.layout/ContentScale?, androidx.compose.ui.graphics/FilterQuality, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): coil3.compose/AsyncImagePainter // coil3.compose/rememberAsyncImagePainter|rememberAsyncImagePainter(kotlin.Any?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.layout.ContentScale?;androidx.compose.ui.graphics.FilterQuality;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/rememberAsyncImagePainter(kotlin/Any?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, androidx.compose.ui.graphics.painter/Painter?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Loading, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Success, kotlin/Unit>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State.Error, kotlin/Unit>?, androidx.compose.ui.layout/ContentScale?, androidx.compose.ui.graphics/FilterQuality?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): coil3.compose/AsyncImagePainter // coil3.compose/rememberAsyncImagePainter|rememberAsyncImagePainter(kotlin.Any?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;androidx.compose.ui.graphics.painter.Painter?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Loading,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Success,kotlin.Unit>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State.Error,kotlin.Unit>?;androidx.compose.ui.layout.ContentScale?;androidx.compose.ui.graphics.FilterQuality?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/rememberAsyncImagePainter(kotlin/Any?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui.layout/ContentScale?, androidx.compose.ui.graphics/FilterQuality, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): coil3.compose/AsyncImagePainter // coil3.compose/rememberAsyncImagePainter|rememberAsyncImagePainter(kotlin.Any?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.layout.ContentScale?;androidx.compose.ui.graphics.FilterQuality;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/rememberAsyncImagePainter(kotlin/Any?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, coil3.compose/AsyncImagePainter.State>?, kotlin/Function1<coil3.compose/AsyncImagePainter.State, kotlin/Unit>?, androidx.compose.ui.layout/ContentScale?, androidx.compose.ui.graphics/FilterQuality?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): coil3.compose/AsyncImagePainter // coil3.compose/rememberAsyncImagePainter|rememberAsyncImagePainter(kotlin.Any?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,coil3.compose.AsyncImagePainter.State>?;kotlin.Function1<coil3.compose.AsyncImagePainter.State,kotlin.Unit>?;androidx.compose.ui.layout.ContentScale?;androidx.compose.ui.graphics.FilterQuality?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun coil3.compose/setSingletonImageLoaderFactory(kotlin/Function1<coil3/PlatformContext, coil3/ImageLoader>, androidx.compose.runtime/Composer?, kotlin/Int) // coil3.compose/setSingletonImageLoaderFactory|setSingletonImageLoaderFactory(kotlin.Function1<coil3.PlatformContext,coil3.ImageLoader>;androidx.compose.runtime.Composer?;kotlin.Int){}[0]

coil/coil-compose/build.gradle.kts

@@ -0,0 +1,31 @@
+// :coil:coil-compose - the public compose entry points (AsyncImage, SubcomposeAsyncImage),
+// vendored VERBATIM from coil-kt/coil. commonMain only. Upstream publishes no
+// desktop-native klibs for the compose layer.
+plugins {
+	alias(libs.plugins.kotlin.multiplatform)
+	alias(libs.plugins.kotlin.plugin.compose)
+}
+
+val vHostSupportsMingw = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+kotlin {
+	linuxArm64(); linuxX64(); macosArm64(); if (vHostSupportsMingw) mingwX64()
+	applyDefaultHierarchyTemplate()
+	sourceSets {
+		commonMain {
+			dependencies {
+				api(project(":coil:coil"))
+				api(project(":coil:coil-compose-core"))
+			}
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=coil3.annotation.InternalCoilApi",
+			"-opt-in=coil3.annotation.ExperimentalCoilApi",
+			"-opt-in=coil3.annotation.DelicateCoilApi",
+		)
+	}
+}

coil/coil-compose/compose-fork.txt

@@ -0,0 +1,15 @@
+# :coil:coil-compose - the public compose entry points. commonMain only.
+# Upstream publishes NEITHER mingwX64 NOR linux for the compose layer.
+SET_REPO=https://github.com/coil-kt/coil@<COIL_REF>
+
+SET_FOLDER=coil-compose/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/coil3/compose/SingletonAsyncImage.kt -> src/vendor/common/kotlin/coil3/compose/SingletonAsyncImage.kt
+#     | commonMain/kotlin/coil3/compose/SingletonAsyncImagePainter.kt -> src/vendor/common/kotlin/coil3/compose/SingletonAsyncImagePainter.kt
+#     | commonMain/kotlin/coil3/compose/SingletonSubcomposeAsyncImage.kt -> src/vendor/common/kotlin/coil3/compose/SingletonSubcomposeAsyncImage.kt
+#     | commonMain/kotlin/coil3/compose/singletonImageLoaders.kt -> src/vendor/common/kotlin/coil3/compose/singletonImageLoaders.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   (none - every source set under SET_FOLDER is vendored)
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>

coil/coil-core/build.gradle.kts

@@ -0,0 +1,90 @@
+// :coil:coil-core - coil3.* core, vendored VERBATIM from coil-kt/coil into src/vendor.
+//
+// Upstream publishes linux + apple klibs but NOT mingwX64, and the code is
+// target-agnostic, so the port mostly just re-declares the targets.
+//
+// SOURCE-SET COLLAPSE: this module has no android, jvm or js target, so upstream's
+// nonAndroidMain / nonJvmCommonMain / nonJsCommonMain / nativeMain all apply to every
+// target here and are vendored into ONE tree (src/vendor/native). Only the
+// apple-vs-rest split survives: appleMain is macosArm64, nonAppleMain is linux+mingw.
+//
+// SKIA: upstream's non-android decoder is skiko-based (SkiaImageDecoder), which is
+// this port's renderer already. macOS/Linux take the official skiko; mingwX64 takes
+// the bitsycore FORK, the same swap :compose:ui:ui-graphics makes.
+//
+// Provenance = compose-fork.txt + scripts/compose-fork/compose.properties. Never
+// hand-edit src/vendor - change the manifest + re-run
+// `python scripts/compose-fork/sync.py coil/coil-core`.
+plugins {
+	alias(libs.plugins.kotlin.multiplatform)
+}
+
+val vHostSupportsMingw = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+kotlin {
+	linuxArm64(); linuxX64(); macosArm64(); if (vHostSupportsMingw) mingwX64()
+	applyDefaultHierarchyTemplate()
+	sourceSets {
+		commonMain {
+			dependencies {
+				api(libs.kotlinx.coroutines.core)
+				api(libs.okio)
+			}
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+		// SKIKO BRANCHES. Upstream's nonAndroid files use org.jetbrains.skia.*, so the
+		// intermediate source set that holds them needs skiko on its own compile
+		// classpath (the shared-metadata compilation is a real compile). macOS/Linux
+		// take the OFFICIAL skiko; mingwX64 takes the bitsycore FORK - and the two
+		// cannot share an intermediate, so mingw gets a PARALLEL branch over the same
+		// srcDirs. Same shape as :compose:ui:ui-graphics.
+		//
+		// Each branch is two levels deep because upstream's nonAndroid sets declare
+		// `expect`s whose `actual`s live in nativeMain - siblings in one set is an error.
+		fun skikoBranch(inName: String, inSkiko: Any): org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet {
+			val vNonAndroid = create("${inName}NonAndroidMain") {
+				dependsOn(commonMain.get())
+				kotlin.srcDir("src/vendor/nonAndroid/kotlin")
+				dependencies { implementation(inSkiko) }
+			}
+			return create("${inName}NativeMain") {
+				dependsOn(vNonAndroid)
+				kotlin.srcDir("src/vendor/native/kotlin")
+			}
+		}
+
+		val vOfficial = skikoBranch("coilOfficial", libs.skiko)
+		val vAppleMain = create("coilAppleMain") {
+			dependsOn(vOfficial)
+			kotlin.srcDir("src/vendor/apple/kotlin")
+		}
+		val vLinuxMain = create("coilLinuxMain") {
+			dependsOn(vOfficial)
+			kotlin.srcDir("src/vendor/nonApple/kotlin")
+		}
+		get("macosArm64Main").dependsOn(vAppleMain)
+		get("linuxX64Main").dependsOn(vLinuxMain)
+		get("linuxArm64Main").dependsOn(vLinuxMain)
+
+		if (vHostSupportsMingw) {
+			val vFork = skikoBranch(
+				"coilFork",
+				"com.bitsycore.skiko:skiko:${providers.gradleProperty("skikoMingwVersion").getOrElse(libs.versions.skikoMingw.get())}",
+			)
+			val vMingwMain = create("coilMingwMain") {
+				dependsOn(vFork)
+				kotlin.srcDir("src/vendor/nonApple/kotlin")
+			}
+			get("mingwX64Main").dependsOn(vMingwMain)
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=kotlinx.cinterop.ExperimentalForeignApi",
+			"-opt-in=coil3.annotation.InternalCoilApi",
+			"-opt-in=coil3.annotation.ExperimentalCoilApi",
+			"-opt-in=coil3.annotation.DelicateCoilApi",
+		)
+	}
+}

coil/coil-core/compose-fork.txt

@@ -0,0 +1,206 @@
+# :coil:coil-core - coil3.* core, vendored verbatim from coil-kt/coil.
+# Upstream publishes linux + apple but NOT mingwX64, so the port re-declares the
+# targets and rebuilds the same sources. Decoding is Skia-based upstream
+# (SkiaImageDecoder), which is exactly this port's renderer - on mingwX64 the
+# skiko dependency is the bitsycore FORK, as in :compose:ui:ui-graphics.
+# Upstream source sets collapse onto this port: it has NO android, jvm or js
+# target, so nonAndroidMain / nonJvmCommonMain / nonJsCommonMain / nativeMain all
+# apply to EVERY target here. They land in TWO trees, not one: the non* sets keep
+# their own level (src/vendor/nonAndroid) ABOVE src/vendor/native, because some of
+# them declare `expect`s whose `actual`s live in upstream nativeMain - collapsing
+# both into one source set makes expect and actual siblings, which is an error. appleMain is macosArm64
+# only and nonAppleMain is linux + mingw, so those two keep their own trees (the
+# build file wires a `nonAppleMain` intermediate; appleMain comes from the default
+# hierarchy template).
+SET_REPO=https://github.com/coil-kt/coil@<COIL_REF>
+
+SET_FOLDER=coil-core/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/coil3/ColorImage.kt -> src/vendor/common/kotlin/coil3/ColorImage.kt
+#     | commonMain/kotlin/coil3/ComponentRegistry.kt -> src/vendor/common/kotlin/coil3/ComponentRegistry.kt
+#     | commonMain/kotlin/coil3/EventListener.kt -> src/vendor/common/kotlin/coil3/EventListener.kt
+#     | commonMain/kotlin/coil3/Extras.kt -> src/vendor/common/kotlin/coil3/Extras.kt
+#     | commonMain/kotlin/coil3/Image.kt -> src/vendor/common/kotlin/coil3/Image.kt
+#     | commonMain/kotlin/coil3/ImageLoader.kt -> src/vendor/common/kotlin/coil3/ImageLoader.kt
+#     | commonMain/kotlin/coil3/PlatformContext.kt -> src/vendor/common/kotlin/coil3/PlatformContext.kt
+#     | commonMain/kotlin/coil3/RealImageLoader.kt -> src/vendor/common/kotlin/coil3/RealImageLoader.kt
+#     | commonMain/kotlin/coil3/Uri.kt -> src/vendor/common/kotlin/coil3/Uri.kt
+#     | commonMain/kotlin/coil3/annotation/annotations.kt -> src/vendor/common/kotlin/coil3/annotation/annotations.kt
+#     | commonMain/kotlin/coil3/decode/BlackholeDecoder.kt -> src/vendor/common/kotlin/coil3/decode/BlackholeDecoder.kt
+#     | commonMain/kotlin/coil3/decode/DataSource.kt -> src/vendor/common/kotlin/coil3/decode/DataSource.kt
+#     | commonMain/kotlin/coil3/decode/DecodeResult.kt -> src/vendor/common/kotlin/coil3/decode/DecodeResult.kt
+#     | commonMain/kotlin/coil3/decode/DecodeUtils.kt -> src/vendor/common/kotlin/coil3/decode/DecodeUtils.kt
+#     | commonMain/kotlin/coil3/decode/Decoder.kt -> src/vendor/common/kotlin/coil3/decode/Decoder.kt
+#     | commonMain/kotlin/coil3/decode/ImageSource.kt -> src/vendor/common/kotlin/coil3/decode/ImageSource.kt
+#     | commonMain/kotlin/coil3/disk/DiskCache.kt -> src/vendor/common/kotlin/coil3/disk/DiskCache.kt
+#     | commonMain/kotlin/coil3/disk/DiskLruCache.kt -> src/vendor/common/kotlin/coil3/disk/DiskLruCache.kt
+#     | commonMain/kotlin/coil3/disk/FaultHidingSink.kt -> src/vendor/common/kotlin/coil3/disk/FaultHidingSink.kt
+#     | commonMain/kotlin/coil3/disk/RealDiskCache.kt -> src/vendor/common/kotlin/coil3/disk/RealDiskCache.kt
+#     | commonMain/kotlin/coil3/disk/utils.kt -> src/vendor/common/kotlin/coil3/disk/utils.kt
+#     | commonMain/kotlin/coil3/fetch/BitmapFetcher.kt -> src/vendor/common/kotlin/coil3/fetch/BitmapFetcher.kt
+#     | commonMain/kotlin/coil3/fetch/ByteArrayFetcher.kt -> src/vendor/common/kotlin/coil3/fetch/ByteArrayFetcher.kt
+#     | commonMain/kotlin/coil3/fetch/DataUriFetcher.kt -> src/vendor/common/kotlin/coil3/fetch/DataUriFetcher.kt
+#     | commonMain/kotlin/coil3/fetch/FetchResult.kt -> src/vendor/common/kotlin/coil3/fetch/FetchResult.kt
+#     | commonMain/kotlin/coil3/fetch/Fetcher.kt -> src/vendor/common/kotlin/coil3/fetch/Fetcher.kt
+#     | commonMain/kotlin/coil3/fetch/FileUriFetcher.kt -> src/vendor/common/kotlin/coil3/fetch/FileUriFetcher.kt
+#     | commonMain/kotlin/coil3/imageLoaders.kt -> src/vendor/common/kotlin/coil3/imageLoaders.kt
+#     | commonMain/kotlin/coil3/intercept/EngineInterceptor.kt -> src/vendor/common/kotlin/coil3/intercept/EngineInterceptor.kt
+#     | commonMain/kotlin/coil3/intercept/Interceptor.kt -> src/vendor/common/kotlin/coil3/intercept/Interceptor.kt
+#     | commonMain/kotlin/coil3/intercept/RealInterceptorChain.kt -> src/vendor/common/kotlin/coil3/intercept/RealInterceptorChain.kt
+#     | commonMain/kotlin/coil3/key/FileUriKeyer.kt -> src/vendor/common/kotlin/coil3/key/FileUriKeyer.kt
+#     | commonMain/kotlin/coil3/key/Keyer.kt -> src/vendor/common/kotlin/coil3/key/Keyer.kt
+#     | commonMain/kotlin/coil3/key/UriKeyer.kt -> src/vendor/common/kotlin/coil3/key/UriKeyer.kt
+#     | commonMain/kotlin/coil3/map/Mapper.kt -> src/vendor/common/kotlin/coil3/map/Mapper.kt
+#     | commonMain/kotlin/coil3/map/PathMapper.kt -> src/vendor/common/kotlin/coil3/map/PathMapper.kt
+#     | commonMain/kotlin/coil3/map/StringMapper.kt -> src/vendor/common/kotlin/coil3/map/StringMapper.kt
+#     | commonMain/kotlin/coil3/memory/MemoryCache.kt -> src/vendor/common/kotlin/coil3/memory/MemoryCache.kt
+#     | commonMain/kotlin/coil3/memory/MemoryCacheService.kt -> src/vendor/common/kotlin/coil3/memory/MemoryCacheService.kt
+#     | commonMain/kotlin/coil3/memory/RealMemoryCache.kt -> src/vendor/common/kotlin/coil3/memory/RealMemoryCache.kt
+#     | commonMain/kotlin/coil3/memory/StrongMemoryCache.kt -> src/vendor/common/kotlin/coil3/memory/StrongMemoryCache.kt
+#     | commonMain/kotlin/coil3/memory/WeakMemoryCache.kt -> src/vendor/common/kotlin/coil3/memory/WeakMemoryCache.kt
+#     | commonMain/kotlin/coil3/request/CachePolicy.kt -> src/vendor/common/kotlin/coil3/request/CachePolicy.kt
+#     | commonMain/kotlin/coil3/request/Disposable.kt -> src/vendor/common/kotlin/coil3/request/Disposable.kt
+#     | commonMain/kotlin/coil3/request/ImageRequest.kt -> src/vendor/common/kotlin/coil3/request/ImageRequest.kt
+#     | commonMain/kotlin/coil3/request/ImageResult.kt -> src/vendor/common/kotlin/coil3/request/ImageResult.kt
+#     | commonMain/kotlin/coil3/request/NullRequestData.kt -> src/vendor/common/kotlin/coil3/request/NullRequestData.kt
+#     | commonMain/kotlin/coil3/request/NullRequestDataException.kt -> src/vendor/common/kotlin/coil3/request/NullRequestDataException.kt
+#     | commonMain/kotlin/coil3/request/Options.kt -> src/vendor/common/kotlin/coil3/request/Options.kt
+#     | commonMain/kotlin/coil3/request/RequestDelegate.kt -> src/vendor/common/kotlin/coil3/request/RequestDelegate.kt
+#     | commonMain/kotlin/coil3/request/RequestService.kt -> src/vendor/common/kotlin/coil3/request/RequestService.kt
+#     | commonMain/kotlin/coil3/request/imageRequests.kt -> src/vendor/common/kotlin/coil3/request/imageRequests.kt
+#     | commonMain/kotlin/coil3/size/Dimension.kt -> src/vendor/common/kotlin/coil3/size/Dimension.kt
+#     | commonMain/kotlin/coil3/size/Precision.kt -> src/vendor/common/kotlin/coil3/size/Precision.kt
+#     | commonMain/kotlin/coil3/size/RealSizeResolver.kt -> src/vendor/common/kotlin/coil3/size/RealSizeResolver.kt
+#     | commonMain/kotlin/coil3/size/Scale.kt -> src/vendor/common/kotlin/coil3/size/Scale.kt
+#     | commonMain/kotlin/coil3/size/Size.kt -> src/vendor/common/kotlin/coil3/size/Size.kt
+#     | commonMain/kotlin/coil3/size/SizeResolver.kt -> src/vendor/common/kotlin/coil3/size/SizeResolver.kt
+#     | commonMain/kotlin/coil3/target/Target.kt -> src/vendor/common/kotlin/coil3/target/Target.kt
+#     | commonMain/kotlin/coil3/transform/Transformation.kt -> src/vendor/common/kotlin/coil3/transform/Transformation.kt
+#     | commonMain/kotlin/coil3/util/LruCache.kt -> src/vendor/common/kotlin/coil3/util/LruCache.kt
+#     | commonMain/kotlin/coil3/util/ServiceLoaderComponentRegistry.kt -> src/vendor/common/kotlin/coil3/util/ServiceLoaderComponentRegistry.kt
+#     | commonMain/kotlin/coil3/util/SystemCallbacks.kt -> src/vendor/common/kotlin/coil3/util/SystemCallbacks.kt
+#     | commonMain/kotlin/coil3/util/collections.kt -> src/vendor/common/kotlin/coil3/util/collections.kt
+#     | commonMain/kotlin/coil3/util/contexts.kt -> src/vendor/common/kotlin/coil3/util/contexts.kt
+#     | commonMain/kotlin/coil3/util/coroutines.kt -> src/vendor/common/kotlin/coil3/util/coroutines.kt
+#     | commonMain/kotlin/coil3/util/fileSystems.kt -> src/vendor/common/kotlin/coil3/util/fileSystems.kt
+#     | commonMain/kotlin/coil3/util/logging.kt -> src/vendor/common/kotlin/coil3/util/logging.kt
+#     | commonMain/kotlin/coil3/util/mimeTypes.kt -> src/vendor/common/kotlin/coil3/util/mimeTypes.kt
+#     | commonMain/kotlin/coil3/util/utils.kt -> src/vendor/common/kotlin/coil3/util/utils.kt
+nonAndroidMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonAndroidMain/kotlin/coil3/ColorImage.kt -> src/vendor/nonAndroid/kotlin/coil3/ColorImage.kt
+#     | nonAndroidMain/kotlin/coil3/EventListener.kt -> src/vendor/nonAndroid/kotlin/coil3/EventListener.kt
+#     | nonAndroidMain/kotlin/coil3/Image.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/Image.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/PlatformContext.kt -> src/vendor/nonAndroid/kotlin/coil3/PlatformContext.kt
+#     | nonAndroidMain/kotlin/coil3/RealImageLoader.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/RealImageLoader.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/decode/SkiaImageDecoder.kt -> src/vendor/nonAndroid/kotlin/coil3/decode/SkiaImageDecoder.kt
+#     | nonAndroidMain/kotlin/coil3/intercept/EngineInterceptor.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/intercept/EngineInterceptor.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/request/RequestService.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/request/RequestService.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/request/imageRequests.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/request/imageRequests.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/util/SystemCallbacks.kt -> src/vendor/nonAndroid/kotlin/coil3/util/SystemCallbacks.kt
+#     | nonAndroidMain/kotlin/coil3/util/contexts.kt -> src/vendor/nonAndroid/kotlin/coil3/util/contexts.kt
+#     | nonAndroidMain/kotlin/coil3/util/mimeTypes.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/util/mimeTypes.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/util/utils.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/util/utils.nonAndroid.kt
+nonJvmCommonMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonJvmCommonMain/kotlin/coil3/RealImageLoader.nonJvmCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/RealImageLoader.nonJvmCommon.kt
+#     | nonJvmCommonMain/kotlin/coil3/util/ServiceLoaderComponentRegistry.kt -> src/vendor/nonAndroid/kotlin/coil3/util/ServiceLoaderComponentRegistry.kt
+#     | nonJvmCommonMain/kotlin/coil3/util/collections.nonJvmCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/util/collections.nonJvmCommon.kt
+#     | nonJvmCommonMain/kotlin/coil3/util/contexts.nonJvmCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/util/contexts.nonJvmCommon.kt
+#     | nonJvmCommonMain/kotlin/coil3/util/fileSystems.nonJvmCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/util/fileSystems.nonJvmCommon.kt
+nonJsCommonMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonJsCommonMain/kotlin/coil3/disk/utils.kt -> src/vendor/nonAndroid/kotlin/coil3/disk/utils.kt
+#     | nonJsCommonMain/kotlin/coil3/imageLoaders.nonJsCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/imageLoaders.nonJsCommon.kt
+#     | nonJsCommonMain/kotlin/coil3/util/coroutines.nonJsCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/util/coroutines.nonJsCommon.kt
+#     | nonJsCommonMain/kotlin/coil3/util/fileSystems.nonJsCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/util/fileSystems.nonJsCommon.kt
+nativeMain/kotlin/ -> src/vendor/native/kotlin/
+#     | nativeMain/kotlin/coil3/decode/SkiaImageDecoder.native.kt -> src/vendor/native/kotlin/coil3/decode/SkiaImageDecoder.native.kt
+#     | nativeMain/kotlin/coil3/util/utils.native.kt -> src/vendor/native/kotlin/coil3/util/utils.native.kt
+appleMain/kotlin/ -> src/vendor/apple/kotlin/
+#     | appleMain/kotlin/coil3/RealImageLoader.apple.kt -> src/vendor/apple/kotlin/coil3/RealImageLoader.apple.kt
+#     | appleMain/kotlin/coil3/map/NSURLMapper.kt -> src/vendor/apple/kotlin/coil3/map/NSURLMapper.kt
+nonAppleMain/kotlin/ -> src/vendor/nonApple/kotlin/
+#     | nonAppleMain/kotlin/coil3/RealImageLoader.nonApple.kt -> src/vendor/nonApple/kotlin/coil3/RealImageLoader.nonApple.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   androidMain (49)
+#     | androidMain/kotlin/coil3/ColorImage.kt -> src/vendor/android/kotlin/coil3/ColorImage.kt
+#     | androidMain/kotlin/coil3/EventListener.kt -> src/vendor/android/kotlin/coil3/EventListener.kt
+#     | androidMain/kotlin/coil3/Image.android.kt -> src/vendor/android/kotlin/coil3/Image.android.kt
+#     | androidMain/kotlin/coil3/PlatformContext.kt -> src/vendor/android/kotlin/coil3/PlatformContext.kt
+#     | androidMain/kotlin/coil3/RealImageLoader.android.kt -> src/vendor/android/kotlin/coil3/RealImageLoader.android.kt
+#     | androidMain/kotlin/coil3/Uri.android.kt -> src/vendor/android/kotlin/coil3/Uri.android.kt
+#     | androidMain/kotlin/coil3/decode/BitmapFactoryDecoder.kt -> src/vendor/android/kotlin/coil3/decode/BitmapFactoryDecoder.kt
+#     | androidMain/kotlin/coil3/decode/ExifOrientationStrategy.kt -> src/vendor/android/kotlin/coil3/decode/ExifOrientationStrategy.kt
+#     | androidMain/kotlin/coil3/decode/ExifUtils.kt -> src/vendor/android/kotlin/coil3/decode/ExifUtils.kt
+#     | androidMain/kotlin/coil3/decode/ImageSource.kt -> src/vendor/android/kotlin/coil3/decode/ImageSource.kt
+#     | androidMain/kotlin/coil3/decode/StaticImageDecoder.kt -> src/vendor/android/kotlin/coil3/decode/StaticImageDecoder.kt
+#     | androidMain/kotlin/coil3/fetch/AssetUriFetcher.kt -> src/vendor/android/kotlin/coil3/fetch/AssetUriFetcher.kt
+#     | androidMain/kotlin/coil3/fetch/ContentUriFetcher.kt -> src/vendor/android/kotlin/coil3/fetch/ContentUriFetcher.kt
+#     | androidMain/kotlin/coil3/fetch/DrawableFetcher.kt -> src/vendor/android/kotlin/coil3/fetch/DrawableFetcher.kt
+#     | androidMain/kotlin/coil3/fetch/ResourceUriFetcher.kt -> src/vendor/android/kotlin/coil3/fetch/ResourceUriFetcher.kt
+#     | androidMain/kotlin/coil3/imageLoaders.android.kt -> src/vendor/android/kotlin/coil3/imageLoaders.android.kt
+#     | androidMain/kotlin/coil3/intercept/EngineInterceptor.android.kt -> src/vendor/android/kotlin/coil3/intercept/EngineInterceptor.android.kt
+#     | androidMain/kotlin/coil3/key/AndroidResourceUriKeyer.kt -> src/vendor/android/kotlin/coil3/key/AndroidResourceUriKeyer.kt
+#     | androidMain/kotlin/coil3/map/AndroidUriMapper.kt -> src/vendor/android/kotlin/coil3/map/AndroidUriMapper.kt
+#     | androidMain/kotlin/coil3/map/ResourceIntMapper.kt -> src/vendor/android/kotlin/coil3/map/ResourceIntMapper.kt
+#     | androidMain/kotlin/coil3/request/RequestDelegate.android.kt -> src/vendor/android/kotlin/coil3/request/RequestDelegate.android.kt
+#     | androidMain/kotlin/coil3/request/RequestService.android.kt -> src/vendor/android/kotlin/coil3/request/RequestService.android.kt
+#     | androidMain/kotlin/coil3/request/ViewTargetDisposable.kt -> src/vendor/android/kotlin/coil3/request/ViewTargetDisposable.kt
+#     | androidMain/kotlin/coil3/request/ViewTargetRequestManager.kt -> src/vendor/android/kotlin/coil3/request/ViewTargetRequestManager.kt
+#     | androidMain/kotlin/coil3/request/imageRequests.android.kt -> src/vendor/android/kotlin/coil3/request/imageRequests.android.kt
+#     | androidMain/kotlin/coil3/size/RealViewSizeResolver.kt -> src/vendor/android/kotlin/coil3/size/RealViewSizeResolver.kt
+#     | androidMain/kotlin/coil3/size/ScaleDrawable.kt -> src/vendor/android/kotlin/coil3/size/ScaleDrawable.kt
+#     | androidMain/kotlin/coil3/size/ViewSizeResolver.kt -> src/vendor/android/kotlin/coil3/size/ViewSizeResolver.kt
+#     | androidMain/kotlin/coil3/target/GenericViewTarget.kt -> src/vendor/android/kotlin/coil3/target/GenericViewTarget.kt
+#     | androidMain/kotlin/coil3/target/ImageViewTarget.kt -> src/vendor/android/kotlin/coil3/target/ImageViewTarget.kt
+#     | androidMain/kotlin/coil3/target/ViewTarget.kt -> src/vendor/android/kotlin/coil3/target/ViewTarget.kt
+#     | androidMain/kotlin/coil3/transform/CircleCropTransformation.kt -> src/vendor/android/kotlin/coil3/transform/CircleCropTransformation.kt
+#     | androidMain/kotlin/coil3/transform/RoundedCornersTransformation.kt -> src/vendor/android/kotlin/coil3/transform/RoundedCornersTransformation.kt
+#     | androidMain/kotlin/coil3/transform/transformations.kt -> src/vendor/android/kotlin/coil3/transform/transformations.kt
+#     | androidMain/kotlin/coil3/transition/CrossfadeDrawable.kt -> src/vendor/android/kotlin/coil3/transition/CrossfadeDrawable.kt
+#     | androidMain/kotlin/coil3/transition/CrossfadeTransition.kt -> src/vendor/android/kotlin/coil3/transition/CrossfadeTransition.kt
+#     | androidMain/kotlin/coil3/transition/NoneTransition.kt -> src/vendor/android/kotlin/coil3/transition/NoneTransition.kt
+#     | androidMain/kotlin/coil3/transition/Transition.kt -> src/vendor/android/kotlin/coil3/transition/Transition.kt
+#     | androidMain/kotlin/coil3/transition/TransitionTarget.kt -> src/vendor/android/kotlin/coil3/transition/TransitionTarget.kt
+#     | androidMain/kotlin/coil3/util/CoilUtils.kt -> src/vendor/android/kotlin/coil3/util/CoilUtils.kt
+#     | androidMain/kotlin/coil3/util/DrawableUtils.kt -> src/vendor/android/kotlin/coil3/util/DrawableUtils.kt
+#     | androidMain/kotlin/coil3/util/SystemCallbacks.kt -> src/vendor/android/kotlin/coil3/util/SystemCallbacks.kt
+#     | androidMain/kotlin/coil3/util/bitmaps.kt -> src/vendor/android/kotlin/coil3/util/bitmaps.kt
+#     | androidMain/kotlin/coil3/util/contexts.kt -> src/vendor/android/kotlin/coil3/util/contexts.kt
+#     | androidMain/kotlin/coil3/util/fileSystems.android.kt -> src/vendor/android/kotlin/coil3/util/fileSystems.android.kt
+#     | androidMain/kotlin/coil3/util/hardwareBitmaps.kt -> src/vendor/android/kotlin/coil3/util/hardwareBitmaps.kt
+#     | androidMain/kotlin/coil3/util/lifecycles.kt -> src/vendor/android/kotlin/coil3/util/lifecycles.kt
+#     | androidMain/kotlin/coil3/util/mimeTypes.android.kt -> src/vendor/android/kotlin/coil3/util/mimeTypes.android.kt
+#     | androidMain/kotlin/coil3/util/utils.android.kt -> src/vendor/android/kotlin/coil3/util/utils.android.kt
+#   jsCommonMain (7)
+#     | jsCommonMain/kotlin/coil3/decode/SkiaImageDecoder.jsCommon.kt -> src/vendor/jsCommon/kotlin/coil3/decode/SkiaImageDecoder.jsCommon.kt
+#     | jsCommonMain/kotlin/coil3/decode/WebWorker.kt -> src/vendor/jsCommon/kotlin/coil3/decode/WebWorker.kt
+#     | jsCommonMain/kotlin/coil3/disk/utils.kt -> src/vendor/jsCommon/kotlin/coil3/disk/utils.kt
+#     | jsCommonMain/kotlin/coil3/fetch/BlobUriFetcher.kt -> src/vendor/jsCommon/kotlin/coil3/fetch/BlobUriFetcher.kt
+#     | jsCommonMain/kotlin/coil3/fetch/internal/BlobUriFetcherServiceLoaderTarget.kt -> src/vendor/jsCommon/kotlin/coil3/fetch/internal/BlobUriFetcherServiceLoaderTarget.kt
+#     | jsCommonMain/kotlin/coil3/util/coroutines.kt -> src/vendor/jsCommon/kotlin/coil3/util/coroutines.kt
+#     | jsCommonMain/kotlin/coil3/util/fileSystems.kt -> src/vendor/jsCommon/kotlin/coil3/util/fileSystems.kt
+#   jsMain (3)
+#     | jsMain/kotlin/coil3/fetch/BlobUriFetcher.js.kt -> src/vendor/js/kotlin/coil3/fetch/BlobUriFetcher.js.kt
+#     | jsMain/kotlin/coil3/fetch/internal/BlobUriFetcherServiceLoaderTarget.js.kt -> src/vendor/js/kotlin/coil3/fetch/internal/BlobUriFetcherServiceLoaderTarget.js.kt
+#     | jsMain/kotlin/coil3/util/utils.js.kt -> src/vendor/js/kotlin/coil3/util/utils.js.kt
+#   jvmCommonMain (10)
+#     | jvmCommonMain/kotlin/coil3/RealImageLoader.jvmCommon.kt -> src/vendor/jvmCommon/kotlin/coil3/RealImageLoader.jvmCommon.kt
+#     | jvmCommonMain/kotlin/coil3/decode/ImageSource.kt -> src/vendor/jvmCommon/kotlin/coil3/decode/ImageSource.kt
+#     | jvmCommonMain/kotlin/coil3/disk/diskCache.kt -> src/vendor/jvmCommon/kotlin/coil3/disk/diskCache.kt
+#     | jvmCommonMain/kotlin/coil3/fetch/ByteBufferFetcher.kt -> src/vendor/jvmCommon/kotlin/coil3/fetch/ByteBufferFetcher.kt
+#     | jvmCommonMain/kotlin/coil3/fetch/JarFileFetcher.kt -> src/vendor/jvmCommon/kotlin/coil3/fetch/JarFileFetcher.kt
+#     | jvmCommonMain/kotlin/coil3/imageLoaders.hidden.kt -> src/vendor/jvmCommon/kotlin/coil3/imageLoaders.hidden.kt
+#     | jvmCommonMain/kotlin/coil3/map/FileMapper.kt -> src/vendor/jvmCommon/kotlin/coil3/map/FileMapper.kt
+#     | jvmCommonMain/kotlin/coil3/util/ServiceLoaderComponentRegistry.kt -> src/vendor/jvmCommon/kotlin/coil3/util/ServiceLoaderComponentRegistry.kt
+#     | jvmCommonMain/kotlin/coil3/util/collections.jvmCommon.kt -> src/vendor/jvmCommon/kotlin/coil3/util/collections.jvmCommon.kt
+#     | jvmCommonMain/kotlin/coil3/util/utils.jvmCommon.kt -> src/vendor/jvmCommon/kotlin/coil3/util/utils.jvmCommon.kt
+#   jvmMain (3)
+#     | jvmMain/kotlin/coil3/decode/SkiaImageDecoder.jvm.kt -> src/vendor/jvm/kotlin/coil3/decode/SkiaImageDecoder.jvm.kt
+#     | jvmMain/kotlin/coil3/util/contexts.jvm.kt -> src/vendor/jvm/kotlin/coil3/util/contexts.jvm.kt
+#     | jvmMain/kotlin/coil3/util/fileSystems.jvm.kt -> src/vendor/jvm/kotlin/coil3/util/fileSystems.jvm.kt
+#   wasmJsMain (3)
+#     | wasmJsMain/kotlin/coil3/fetch/BlobUriFetcher.wasmJs.kt -> src/vendor/wasmJs/kotlin/coil3/fetch/BlobUriFetcher.wasmJs.kt
+#     | wasmJsMain/kotlin/coil3/fetch/internal/BlobUriFetcherServiceLoaderTarget.wasmJs.kt -> src/vendor/wasmJs/kotlin/coil3/fetch/internal/BlobUriFetcherServiceLoaderTarget.wasmJs.kt
+#     | wasmJsMain/kotlin/coil3/util/utils.wasmJs.kt -> src/vendor/wasmJs/kotlin/coil3/util/utils.wasmJs.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>

coil/coil-network-core/api/coil-network-core.klib.api

@@ -0,0 +1,197 @@
+// Klib ABI Dump
+// Targets: [linuxArm64, linuxX64, macosArm64, mingwX64]
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: true
+// - Show declarations: true
+
+// Library unique name: <com.bitsycore.coil3:coil-network-core>
+abstract fun interface coil3.network/ConnectivityChecker { // coil3.network/ConnectivityChecker|null[0]
+    abstract fun isOnline(): kotlin/Boolean // coil3.network/ConnectivityChecker.isOnline|isOnline(){}[0]
+
+    final object Companion { // coil3.network/ConnectivityChecker.Companion|null[0]
+        final val ONLINE // coil3.network/ConnectivityChecker.Companion.ONLINE|{}ONLINE[0]
+            final fun <get-ONLINE>(): coil3.network/ConnectivityChecker // coil3.network/ConnectivityChecker.Companion.ONLINE.<get-ONLINE>|<get-ONLINE>(){}[0]
+    }
+}
+
+abstract interface coil3.network/CacheStrategy { // coil3.network/CacheStrategy|null[0]
+    abstract suspend fun read(coil3.network/NetworkResponse, coil3.network/NetworkRequest, coil3.request/Options): coil3.network/CacheStrategy.ReadResult // coil3.network/CacheStrategy.read|read(coil3.network.NetworkResponse;coil3.network.NetworkRequest;coil3.request.Options){}[0]
+    abstract suspend fun write(coil3.network/NetworkResponse?, coil3.network/NetworkRequest, coil3.network/NetworkResponse, coil3.request/Options): coil3.network/CacheStrategy.WriteResult // coil3.network/CacheStrategy.write|write(coil3.network.NetworkResponse?;coil3.network.NetworkRequest;coil3.network.NetworkResponse;coil3.request.Options){}[0]
+
+    final class ReadResult { // coil3.network/CacheStrategy.ReadResult|null[0]
+        constructor <init>(coil3.network/NetworkRequest) // coil3.network/CacheStrategy.ReadResult.<init>|<init>(coil3.network.NetworkRequest){}[0]
+        constructor <init>(coil3.network/NetworkResponse) // coil3.network/CacheStrategy.ReadResult.<init>|<init>(coil3.network.NetworkResponse){}[0]
+
+        final val request // coil3.network/CacheStrategy.ReadResult.request|{}request[0]
+            final fun <get-request>(): coil3.network/NetworkRequest? // coil3.network/CacheStrategy.ReadResult.request.<get-request>|<get-request>(){}[0]
+        final val response // coil3.network/CacheStrategy.ReadResult.response|{}response[0]
+            final fun <get-response>(): coil3.network/NetworkResponse? // coil3.network/CacheStrategy.ReadResult.response.<get-response>|<get-response>(){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // coil3.network/CacheStrategy.ReadResult.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // coil3.network/CacheStrategy.ReadResult.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // coil3.network/CacheStrategy.ReadResult.toString|toString(){}[0]
+    }
+
+    final class WriteResult { // coil3.network/CacheStrategy.WriteResult|null[0]
+        constructor <init>(coil3.network/NetworkResponse) // coil3.network/CacheStrategy.WriteResult.<init>|<init>(coil3.network.NetworkResponse){}[0]
+
+        final val response // coil3.network/CacheStrategy.WriteResult.response|{}response[0]
+            final fun <get-response>(): coil3.network/NetworkResponse? // coil3.network/CacheStrategy.WriteResult.response.<get-response>|<get-response>(){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // coil3.network/CacheStrategy.WriteResult.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // coil3.network/CacheStrategy.WriteResult.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // coil3.network/CacheStrategy.WriteResult.toString|toString(){}[0]
+
+        final object Companion { // coil3.network/CacheStrategy.WriteResult.Companion|null[0]
+            final val DISABLED // coil3.network/CacheStrategy.WriteResult.Companion.DISABLED|{}DISABLED[0]
+                final fun <get-DISABLED>(): coil3.network/CacheStrategy.WriteResult // coil3.network/CacheStrategy.WriteResult.Companion.DISABLED.<get-DISABLED>|<get-DISABLED>(){}[0]
+        }
+    }
+
+    final object Companion { // coil3.network/CacheStrategy.Companion|null[0]
+        final val DEFAULT // coil3.network/CacheStrategy.Companion.DEFAULT|{}DEFAULT[0]
+            final fun <get-DEFAULT>(): coil3.network/CacheStrategy // coil3.network/CacheStrategy.Companion.DEFAULT.<get-DEFAULT>|<get-DEFAULT>(){}[0]
+    }
+}
+
+abstract interface coil3.network/ConcurrentRequestStrategy { // coil3.network/ConcurrentRequestStrategy|null[0]
+    abstract suspend fun apply(kotlin/String, kotlin.coroutines/SuspendFunction0<coil3.fetch/FetchResult>): coil3.fetch/FetchResult // coil3.network/ConcurrentRequestStrategy.apply|apply(kotlin.String;kotlin.coroutines.SuspendFunction0<coil3.fetch.FetchResult>){}[0]
+
+    final object Companion { // coil3.network/ConcurrentRequestStrategy.Companion|null[0]
+        final val UNCOORDINATED // coil3.network/ConcurrentRequestStrategy.Companion.UNCOORDINATED|{}UNCOORDINATED[0]
+            final fun <get-UNCOORDINATED>(): coil3.network/ConcurrentRequestStrategy // coil3.network/ConcurrentRequestStrategy.Companion.UNCOORDINATED.<get-UNCOORDINATED>|<get-UNCOORDINATED>(){}[0]
+    }
+}
+
+abstract interface coil3.network/NetworkClient { // coil3.network/NetworkClient|null[0]
+    abstract suspend fun <#A1: kotlin/Any?> executeRequest(coil3.network/NetworkRequest, kotlin.coroutines/SuspendFunction1<coil3.network/NetworkResponse, #A1>): #A1 // coil3.network/NetworkClient.executeRequest|executeRequest(coil3.network.NetworkRequest;kotlin.coroutines.SuspendFunction1<coil3.network.NetworkResponse,0:0>){0§<kotlin.Any?>}[0]
+}
+
+abstract interface coil3.network/NetworkRequestBody { // coil3.network/NetworkRequestBody|null[0]
+    abstract suspend fun writeTo(okio/BufferedSink) // coil3.network/NetworkRequestBody.writeTo|writeTo(okio.BufferedSink){}[0]
+}
+
+abstract interface coil3.network/NetworkResponseBody : kotlin/AutoCloseable { // coil3.network/NetworkResponseBody|null[0]
+    abstract suspend fun writeTo(okio/BufferedSink) // coil3.network/NetworkResponseBody.writeTo|writeTo(okio.BufferedSink){}[0]
+    abstract suspend fun writeTo(okio/FileSystem, okio/Path) // coil3.network/NetworkResponseBody.writeTo|writeTo(okio.FileSystem;okio.Path){}[0]
+}
+
+final class coil3.network/DeDupeConcurrentRequestStrategy : coil3.network/ConcurrentRequestStrategy { // coil3.network/DeDupeConcurrentRequestStrategy|null[0]
+    constructor <init>() // coil3.network/DeDupeConcurrentRequestStrategy.<init>|<init>(){}[0]
+
+    final suspend fun apply(kotlin/String, kotlin.coroutines/SuspendFunction0<coil3.fetch/FetchResult>): coil3.fetch/FetchResult // coil3.network/DeDupeConcurrentRequestStrategy.apply|apply(kotlin.String;kotlin.coroutines.SuspendFunction0<coil3.fetch.FetchResult>){}[0]
+}
+
+final class coil3.network/HttpException : kotlin/RuntimeException { // coil3.network/HttpException|null[0]
+    constructor <init>(coil3.network/NetworkResponse) // coil3.network/HttpException.<init>|<init>(coil3.network.NetworkResponse){}[0]
+
+    final val response // coil3.network/HttpException.response|{}response[0]
+        final fun <get-response>(): coil3.network/NetworkResponse // coil3.network/HttpException.response.<get-response>|<get-response>(){}[0]
+}
+
+final class coil3.network/NetworkFetcher : coil3.fetch/Fetcher { // coil3.network/NetworkFetcher|null[0]
+    constructor <init>(kotlin/String, coil3.request/Options, kotlin/Lazy<coil3.network/NetworkClient>, kotlin/Lazy<coil3.disk/DiskCache?>, kotlin/Lazy<coil3.network/CacheStrategy>, coil3.network/ConnectivityChecker) // coil3.network/NetworkFetcher.<init>|<init>(kotlin.String;coil3.request.Options;kotlin.Lazy<coil3.network.NetworkClient>;kotlin.Lazy<coil3.disk.DiskCache?>;kotlin.Lazy<coil3.network.CacheStrategy>;coil3.network.ConnectivityChecker){}[0]
+    constructor <init>(kotlin/String, coil3.request/Options, kotlin/Lazy<coil3.network/NetworkClient>, kotlin/Lazy<coil3.disk/DiskCache?>, kotlin/Lazy<coil3.network/CacheStrategy>, kotlin/Lazy<coil3.network/ConnectivityChecker>, kotlin/Lazy<coil3.network/ConcurrentRequestStrategy>) // coil3.network/NetworkFetcher.<init>|<init>(kotlin.String;coil3.request.Options;kotlin.Lazy<coil3.network.NetworkClient>;kotlin.Lazy<coil3.disk.DiskCache?>;kotlin.Lazy<coil3.network.CacheStrategy>;kotlin.Lazy<coil3.network.ConnectivityChecker>;kotlin.Lazy<coil3.network.ConcurrentRequestStrategy>){}[0]
+
+    final fun getMimeType(kotlin/String, kotlin/String?): kotlin/String? // coil3.network/NetworkFetcher.getMimeType|getMimeType(kotlin.String;kotlin.String?){}[0]
+    final suspend fun fetch(): coil3.fetch/FetchResult // coil3.network/NetworkFetcher.fetch|fetch(){}[0]
+
+    final class Factory : coil3.fetch/Fetcher.Factory<coil3/Uri> { // coil3.network/NetworkFetcher.Factory|null[0]
+        constructor <init>(kotlin/Function0<coil3.network/NetworkClient>, kotlin/Function0<coil3.network/CacheStrategy> = ..., kotlin/Function1<coil3/PlatformContext, coil3.network/ConnectivityChecker> = ...) // coil3.network/NetworkFetcher.Factory.<init>|<init>(kotlin.Function0<coil3.network.NetworkClient>;kotlin.Function0<coil3.network.CacheStrategy>;kotlin.Function1<coil3.PlatformContext,coil3.network.ConnectivityChecker>){}[0]
+        constructor <init>(kotlin/Function0<coil3.network/NetworkClient>, kotlin/Function0<coil3.network/CacheStrategy> = ..., kotlin/Function1<coil3/PlatformContext, coil3.network/ConnectivityChecker> = ..., kotlin/Function0<coil3.network/ConcurrentRequestStrategy> = ...) // coil3.network/NetworkFetcher.Factory.<init>|<init>(kotlin.Function0<coil3.network.NetworkClient>;kotlin.Function0<coil3.network.CacheStrategy>;kotlin.Function1<coil3.PlatformContext,coil3.network.ConnectivityChecker>;kotlin.Function0<coil3.network.ConcurrentRequestStrategy>){}[0]
+
+        final fun create(coil3/Uri, coil3.request/Options, coil3/ImageLoader): coil3.fetch/Fetcher? // coil3.network/NetworkFetcher.Factory.create|create(coil3.Uri;coil3.request.Options;coil3.ImageLoader){}[0]
+    }
+}
+
+final class coil3.network/NetworkHeaders { // coil3.network/NetworkHeaders|null[0]
+    final fun asMap(): kotlin.collections/Map<kotlin/String, kotlin.collections/List<kotlin/String>> // coil3.network/NetworkHeaders.asMap|asMap(){}[0]
+    final fun get(kotlin/String): kotlin/String? // coil3.network/NetworkHeaders.get|get(kotlin.String){}[0]
+    final fun getAll(kotlin/String): kotlin.collections/List<kotlin/String> // coil3.network/NetworkHeaders.getAll|getAll(kotlin.String){}[0]
+    final fun newBuilder(): coil3.network/NetworkHeaders.Builder // coil3.network/NetworkHeaders.newBuilder|newBuilder(){}[0]
+
+    final class Builder { // coil3.network/NetworkHeaders.Builder|null[0]
+        constructor <init>() // coil3.network/NetworkHeaders.Builder.<init>|<init>(){}[0]
+        constructor <init>(coil3.network/NetworkHeaders) // coil3.network/NetworkHeaders.Builder.<init>|<init>(coil3.network.NetworkHeaders){}[0]
+
+        final fun add(kotlin/String, kotlin/String): coil3.network/NetworkHeaders.Builder // coil3.network/NetworkHeaders.Builder.add|add(kotlin.String;kotlin.String){}[0]
+        final fun build(): coil3.network/NetworkHeaders // coil3.network/NetworkHeaders.Builder.build|build(){}[0]
+        final fun set(kotlin/String, kotlin.collections/List<kotlin/String>): coil3.network/NetworkHeaders.Builder // coil3.network/NetworkHeaders.Builder.set|set(kotlin.String;kotlin.collections.List<kotlin.String>){}[0]
+        final fun set(kotlin/String, kotlin/String): coil3.network/NetworkHeaders.Builder // coil3.network/NetworkHeaders.Builder.set|set(kotlin.String;kotlin.String){}[0]
+    }
+
+    final object Companion { // coil3.network/NetworkHeaders.Companion|null[0]
+        final val EMPTY // coil3.network/NetworkHeaders.Companion.EMPTY|{}EMPTY[0]
+            final fun <get-EMPTY>(): coil3.network/NetworkHeaders // coil3.network/NetworkHeaders.Companion.EMPTY.<get-EMPTY>|<get-EMPTY>(){}[0]
+    }
+}
+
+final class coil3.network/NetworkRequest { // coil3.network/NetworkRequest|null[0]
+    constructor <init>(kotlin/String, kotlin/String = ..., coil3.network/NetworkHeaders = ..., coil3.network/NetworkRequestBody? = ...) // coil3.network/NetworkRequest.<init>|<init>(kotlin.String;kotlin.String;coil3.network.NetworkHeaders;coil3.network.NetworkRequestBody?){}[0]
+    constructor <init>(kotlin/String, kotlin/String = ..., coil3.network/NetworkHeaders = ..., coil3.network/NetworkRequestBody? = ..., coil3/Extras = ...) // coil3.network/NetworkRequest.<init>|<init>(kotlin.String;kotlin.String;coil3.network.NetworkHeaders;coil3.network.NetworkRequestBody?;coil3.Extras){}[0]
+
+    final val body // coil3.network/NetworkRequest.body|{}body[0]
+        final fun <get-body>(): coil3.network/NetworkRequestBody? // coil3.network/NetworkRequest.body.<get-body>|<get-body>(){}[0]
+    final val extras // coil3.network/NetworkRequest.extras|{}extras[0]
+        final fun <get-extras>(): coil3/Extras // coil3.network/NetworkRequest.extras.<get-extras>|<get-extras>(){}[0]
+    final val headers // coil3.network/NetworkRequest.headers|{}headers[0]
+        final fun <get-headers>(): coil3.network/NetworkHeaders // coil3.network/NetworkRequest.headers.<get-headers>|<get-headers>(){}[0]
+    final val method // coil3.network/NetworkRequest.method|{}method[0]
+        final fun <get-method>(): kotlin/String // coil3.network/NetworkRequest.method.<get-method>|<get-method>(){}[0]
+    final val url // coil3.network/NetworkRequest.url|{}url[0]
+        final fun <get-url>(): kotlin/String // coil3.network/NetworkRequest.url.<get-url>|<get-url>(){}[0]
+
+    final fun copy(kotlin/String = ..., kotlin/String = ..., coil3.network/NetworkHeaders = ..., coil3.network/NetworkRequestBody? = ...): coil3.network/NetworkRequest // coil3.network/NetworkRequest.copy|copy(kotlin.String;kotlin.String;coil3.network.NetworkHeaders;coil3.network.NetworkRequestBody?){}[0]
+    final fun copy(kotlin/String = ..., kotlin/String = ..., coil3.network/NetworkHeaders = ..., coil3.network/NetworkRequestBody? = ..., coil3/Extras = ...): coil3.network/NetworkRequest // coil3.network/NetworkRequest.copy|copy(kotlin.String;kotlin.String;coil3.network.NetworkHeaders;coil3.network.NetworkRequestBody?;coil3.Extras){}[0]
+}
+
+final class coil3.network/NetworkResponse { // coil3.network/NetworkResponse|null[0]
+    constructor <init>(kotlin/Int = ..., kotlin/Long = ..., kotlin/Long = ..., coil3.network/NetworkHeaders = ..., coil3.network/NetworkResponseBody? = ..., kotlin/Any? = ...) // coil3.network/NetworkResponse.<init>|<init>(kotlin.Int;kotlin.Long;kotlin.Long;coil3.network.NetworkHeaders;coil3.network.NetworkResponseBody?;kotlin.Any?){}[0]
+
+    final val body // coil3.network/NetworkResponse.body|{}body[0]
+        final fun <get-body>(): coil3.network/NetworkResponseBody? // coil3.network/NetworkResponse.body.<get-body>|<get-body>(){}[0]
+    final val code // coil3.network/NetworkResponse.code|{}code[0]
+        final fun <get-code>(): kotlin/Int // coil3.network/NetworkResponse.code.<get-code>|<get-code>(){}[0]
+    final val delegate // coil3.network/NetworkResponse.delegate|{}delegate[0]
+        final fun <get-delegate>(): kotlin/Any? // coil3.network/NetworkResponse.delegate.<get-delegate>|<get-delegate>(){}[0]
+    final val headers // coil3.network/NetworkResponse.headers|{}headers[0]
+        final fun <get-headers>(): coil3.network/NetworkHeaders // coil3.network/NetworkResponse.headers.<get-headers>|<get-headers>(){}[0]
+    final val requestMillis // coil3.network/NetworkResponse.requestMillis|{}requestMillis[0]
+        final fun <get-requestMillis>(): kotlin/Long // coil3.network/NetworkResponse.requestMillis.<get-requestMillis>|<get-requestMillis>(){}[0]
+    final val responseMillis // coil3.network/NetworkResponse.responseMillis|{}responseMillis[0]
+        final fun <get-responseMillis>(): kotlin/Long // coil3.network/NetworkResponse.responseMillis.<get-responseMillis>|<get-responseMillis>(){}[0]
+
+    final fun copy(kotlin/Int = ..., kotlin/Long = ..., kotlin/Long = ..., coil3.network/NetworkHeaders = ..., coil3.network/NetworkResponseBody? = ..., kotlin/Any? = ...): coil3.network/NetworkResponse // coil3.network/NetworkResponse.copy|copy(kotlin.Int;kotlin.Long;kotlin.Long;coil3.network.NetworkHeaders;coil3.network.NetworkResponseBody?;kotlin.Any?){}[0]
+}
+
+final object coil3.network/CacheNetworkResponse { // coil3.network/CacheNetworkResponse|null[0]
+    final fun readFrom(okio/BufferedSource): coil3.network/NetworkResponse // coil3.network/CacheNetworkResponse.readFrom|readFrom(okio.BufferedSource){}[0]
+    final fun writeTo(coil3.network/NetworkResponse, okio/BufferedSink) // coil3.network/CacheNetworkResponse.writeTo|writeTo(coil3.network.NetworkResponse;okio.BufferedSink){}[0]
+}
+
+final val coil3.network/httpBody // coil3.network/httpBody|@coil3.Extras.Key.Companion{}httpBody[0]
+    final fun (coil3/Extras.Key.Companion).<get-httpBody>(): coil3/Extras.Key<coil3.network/NetworkRequestBody?> // coil3.network/httpBody.<get-httpBody>|<get-httpBody>@coil3.Extras.Key.Companion(){}[0]
+final val coil3.network/httpBody // coil3.network/httpBody|@coil3.request.ImageRequest{}httpBody[0]
+    final fun (coil3.request/ImageRequest).<get-httpBody>(): coil3.network/NetworkRequestBody? // coil3.network/httpBody.<get-httpBody>|<get-httpBody>@coil3.request.ImageRequest(){}[0]
+final val coil3.network/httpBody // coil3.network/httpBody|@coil3.request.Options{}httpBody[0]
+    final fun (coil3.request/Options).<get-httpBody>(): coil3.network/NetworkRequestBody? // coil3.network/httpBody.<get-httpBody>|<get-httpBody>@coil3.request.Options(){}[0]
+final val coil3.network/httpHeaders // coil3.network/httpHeaders|@coil3.Extras.Key.Companion{}httpHeaders[0]
+    final fun (coil3/Extras.Key.Companion).<get-httpHeaders>(): coil3/Extras.Key<coil3.network/NetworkHeaders> // coil3.network/httpHeaders.<get-httpHeaders>|<get-httpHeaders>@coil3.Extras.Key.Companion(){}[0]
+final val coil3.network/httpHeaders // coil3.network/httpHeaders|@coil3.request.ImageRequest{}httpHeaders[0]
+    final fun (coil3.request/ImageRequest).<get-httpHeaders>(): coil3.network/NetworkHeaders // coil3.network/httpHeaders.<get-httpHeaders>|<get-httpHeaders>@coil3.request.ImageRequest(){}[0]
+final val coil3.network/httpHeaders // coil3.network/httpHeaders|@coil3.request.Options{}httpHeaders[0]
+    final fun (coil3.request/Options).<get-httpHeaders>(): coil3.network/NetworkHeaders // coil3.network/httpHeaders.<get-httpHeaders>|<get-httpHeaders>@coil3.request.Options(){}[0]
+final val coil3.network/httpMethod // coil3.network/httpMethod|@coil3.Extras.Key.Companion{}httpMethod[0]
+    final fun (coil3/Extras.Key.Companion).<get-httpMethod>(): coil3/Extras.Key<kotlin/String> // coil3.network/httpMethod.<get-httpMethod>|<get-httpMethod>@coil3.Extras.Key.Companion(){}[0]
+final val coil3.network/httpMethod // coil3.network/httpMethod|@coil3.request.ImageRequest{}httpMethod[0]
+    final fun (coil3.request/ImageRequest).<get-httpMethod>(): kotlin/String // coil3.network/httpMethod.<get-httpMethod>|<get-httpMethod>@coil3.request.ImageRequest(){}[0]
+final val coil3.network/httpMethod // coil3.network/httpMethod|@coil3.request.Options{}httpMethod[0]
+    final fun (coil3.request/Options).<get-httpMethod>(): kotlin/String // coil3.network/httpMethod.<get-httpMethod>|<get-httpMethod>@coil3.request.Options(){}[0]
+
+final fun (coil3.request/ImageRequest.Builder).coil3.network/httpBody(coil3.network/NetworkRequestBody): coil3.request/ImageRequest.Builder // coil3.network/httpBody|httpBody@coil3.request.ImageRequest.Builder(coil3.network.NetworkRequestBody){}[0]
+final fun (coil3.request/ImageRequest.Builder).coil3.network/httpHeaders(coil3.network/NetworkHeaders): coil3.request/ImageRequest.Builder // coil3.network/httpHeaders|httpHeaders@coil3.request.ImageRequest.Builder(coil3.network.NetworkHeaders){}[0]
+final fun (coil3.request/ImageRequest.Builder).coil3.network/httpMethod(kotlin/String): coil3.request/ImageRequest.Builder // coil3.network/httpMethod|httpMethod@coil3.request.ImageRequest.Builder(kotlin.String){}[0]
+final fun coil3.network/ConnectivityChecker(coil3/PlatformContext): coil3.network/ConnectivityChecker // coil3.network/ConnectivityChecker|ConnectivityChecker(coil3.PlatformContext){}[0]
+final fun coil3.network/NetworkRequestBody(okio/ByteString): coil3.network/NetworkRequestBody // coil3.network/NetworkRequestBody|NetworkRequestBody(okio.ByteString){}[0]
+final fun coil3.network/NetworkResponseBody(okio/BufferedSource): coil3.network/NetworkResponseBody // coil3.network/NetworkResponseBody|NetworkResponseBody(okio.BufferedSource){}[0]

coil/coil-network-core/build.gradle.kts

@@ -0,0 +1,34 @@
+// :coil:coil-network-core - vendored VERBATIM from coil-kt/coil into src/vendor.
+// Shared network-fetcher plumbing. Upstream: linux + apple, no mingwX64.
+// Upstream's non* source sets sit ABOVE nativeMain here (see coil-core's build file
+// and compose-fork.txt for why). Provenance = compose-fork.txt; never hand-edit
+// src/vendor - change the manifest + `python scripts/compose-fork/sync.py coil/coil-network-core`.
+plugins {
+	alias(libs.plugins.kotlin.multiplatform)
+}
+
+val vHostSupportsMingw = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+kotlin {
+	linuxArm64(); linuxX64(); macosArm64(); if (vHostSupportsMingw) mingwX64()
+	applyDefaultHierarchyTemplate()
+	sourceSets {
+		commonMain {
+			dependencies { api(project(":coil:coil-core")) }
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+		val vNonAndroidMain = create("coilNonAndroidMain") {
+			dependsOn(commonMain.get())
+			kotlin.srcDir("src/vendor/nonAndroid/kotlin")
+		}
+		nativeMain { dependsOn(vNonAndroidMain) }
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=coil3.annotation.InternalCoilApi",
+			"-opt-in=coil3.annotation.ExperimentalCoilApi",
+			"-opt-in=coil3.annotation.DelicateCoilApi",
+		)
+	}
+}

coil/coil-network-core/compose-fork.txt

@@ -0,0 +1,37 @@
+# :coil:coil-network-core - shared network fetcher plumbing.
+# Upstream: linux + apple, no mingwX64.
+# Upstream source sets collapse onto this port: it has NO android, jvm or js
+# target, so nonAndroidMain / nonJvmCommonMain / nonJsCommonMain / nativeMain all
+# apply to EVERY target here. They land in TWO trees, not one: the non* sets keep
+# their own level (src/vendor/nonAndroid) ABOVE src/vendor/native, because some of
+# them declare `expect`s whose `actual`s live in upstream nativeMain - collapsing
+# both into one source set makes expect and actual siblings, which is an error. appleMain is macosArm64
+# only and nonAppleMain is linux + mingw, so those two keep their own trees (the
+# build file wires a `nonAppleMain` intermediate; appleMain comes from the default
+# hierarchy template).
+SET_REPO=https://github.com/coil-kt/coil@<COIL_REF>
+
+SET_FOLDER=coil-network-core/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/coil3/network/CacheNetworkResponse.kt -> src/vendor/common/kotlin/coil3/network/CacheNetworkResponse.kt
+#     | commonMain/kotlin/coil3/network/CacheStrategy.kt -> src/vendor/common/kotlin/coil3/network/CacheStrategy.kt
+#     | commonMain/kotlin/coil3/network/ConcurrentRequestStrategy.kt -> src/vendor/common/kotlin/coil3/network/ConcurrentRequestStrategy.kt
+#     | commonMain/kotlin/coil3/network/ConnectivityChecker.kt -> src/vendor/common/kotlin/coil3/network/ConnectivityChecker.kt
+#     | commonMain/kotlin/coil3/network/HttpException.kt -> src/vendor/common/kotlin/coil3/network/HttpException.kt
+#     | commonMain/kotlin/coil3/network/NetworkClient.kt -> src/vendor/common/kotlin/coil3/network/NetworkClient.kt
+#     | commonMain/kotlin/coil3/network/NetworkFetcher.kt -> src/vendor/common/kotlin/coil3/network/NetworkFetcher.kt
+#     | commonMain/kotlin/coil3/network/NetworkHeaders.kt -> src/vendor/common/kotlin/coil3/network/NetworkHeaders.kt
+#     | commonMain/kotlin/coil3/network/imageRequests.kt -> src/vendor/common/kotlin/coil3/network/imageRequests.kt
+#     | commonMain/kotlin/coil3/network/internal/DefaultCacheStrategy.kt -> src/vendor/common/kotlin/coil3/network/internal/DefaultCacheStrategy.kt
+#     | commonMain/kotlin/coil3/network/internal/SingleParameterLazy.kt -> src/vendor/common/kotlin/coil3/network/internal/SingleParameterLazy.kt
+#     | commonMain/kotlin/coil3/network/internal/utils.kt -> src/vendor/common/kotlin/coil3/network/internal/utils.kt
+nonAndroidMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonAndroidMain/kotlin/coil3/network/ConnectivityChecker.kt -> src/vendor/nonAndroid/kotlin/coil3/network/ConnectivityChecker.kt
+#     | nonAndroidMain/kotlin/coil3/network/internal/utils.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/network/internal/utils.nonAndroid.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   androidMain (2)
+#     | androidMain/kotlin/coil3/network/ConnectivityChecker.kt -> src/vendor/android/kotlin/coil3/network/ConnectivityChecker.kt
+#     | androidMain/kotlin/coil3/network/internal/utils.android.kt -> src/vendor/android/kotlin/coil3/network/internal/utils.android.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>

coil/coil-network-ktor3/api/coil-network-ktor3.klib.api

@@ -0,0 +1,18 @@
+// Klib ABI Dump
+// Targets: [linuxArm64, linuxX64, macosArm64, mingwX64]
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: true
+// - Show declarations: true
+
+// Library unique name: <com.bitsycore.coil3:coil-network-ktor3>
+final val coil3.network.ktor3.internal/initHook // coil3.network.ktor3.internal/initHook|{}initHook[0]
+    final fun <get-initHook>(): kotlin/Any // coil3.network.ktor3.internal/initHook.<get-initHook>|<get-initHook>(){}[0]
+
+final fun (io.ktor.client/HttpClient).coil3.network.ktor3/asNetworkClient(): coil3.network/NetworkClient // coil3.network.ktor3/asNetworkClient|asNetworkClient@io.ktor.client.HttpClient(){}[0]
+final fun coil3.network.ktor3/KtorNetworkFetcherFactory(): coil3.network/NetworkFetcher.Factory // coil3.network.ktor3/KtorNetworkFetcherFactory|KtorNetworkFetcherFactory(){}[0]
+final fun coil3.network.ktor3/KtorNetworkFetcherFactory(io.ktor.client/HttpClient): coil3.network/NetworkFetcher.Factory // coil3.network.ktor3/KtorNetworkFetcherFactory|KtorNetworkFetcherFactory(io.ktor.client.HttpClient){}[0]
+final fun coil3.network.ktor3/KtorNetworkFetcherFactory(io.ktor.client/HttpClient, coil3.network/ConcurrentRequestStrategy = ...): coil3.network/NetworkFetcher.Factory // coil3.network.ktor3/KtorNetworkFetcherFactory|KtorNetworkFetcherFactory(io.ktor.client.HttpClient;coil3.network.ConcurrentRequestStrategy){}[0]
+final fun coil3.network.ktor3/KtorNetworkFetcherFactory(kotlin/Function0<io.ktor.client/HttpClient> = ..., kotlin/Function0<coil3.network/CacheStrategy> = ..., kotlin/Function1<coil3/PlatformContext, coil3.network/ConnectivityChecker> = ...): coil3.network/NetworkFetcher.Factory // coil3.network.ktor3/KtorNetworkFetcherFactory|KtorNetworkFetcherFactory(kotlin.Function0<io.ktor.client.HttpClient>;kotlin.Function0<coil3.network.CacheStrategy>;kotlin.Function1<coil3.PlatformContext,coil3.network.ConnectivityChecker>){}[0]
+final fun coil3.network.ktor3/KtorNetworkFetcherFactory(kotlin/Function0<io.ktor.client/HttpClient> = ..., kotlin/Function0<coil3.network/CacheStrategy> = ..., kotlin/Function1<coil3/PlatformContext, coil3.network/ConnectivityChecker> = ..., kotlin/Function0<coil3.network/ConcurrentRequestStrategy> = ...): coil3.network/NetworkFetcher.Factory // coil3.network.ktor3/KtorNetworkFetcherFactory|KtorNetworkFetcherFactory(kotlin.Function0<io.ktor.client.HttpClient>;kotlin.Function0<coil3.network.CacheStrategy>;kotlin.Function1<coil3.PlatformContext,coil3.network.ConnectivityChecker>;kotlin.Function0<coil3.network.ConcurrentRequestStrategy>){}[0]
+final fun coil3.network.ktor3/KtorNetworkFetcherFactory(kotlin/Function0<io.ktor.client/HttpClient>): coil3.network/NetworkFetcher.Factory // coil3.network.ktor3/KtorNetworkFetcherFactory|KtorNetworkFetcherFactory(kotlin.Function0<io.ktor.client.HttpClient>){}[0]

coil/coil-network-ktor3/build.gradle.kts

@@ -0,0 +1,42 @@
+// :coil:coil-network-ktor3 - vendored VERBATIM from coil-kt/coil into src/vendor.
+// Ktor 3 network fetcher, on the port's existing ktor pin.
+// Upstream's non* source sets sit ABOVE nativeMain here (see coil-core's build file
+// and compose-fork.txt for why). Provenance = compose-fork.txt; never hand-edit
+// src/vendor - change the manifest + `python scripts/compose-fork/sync.py coil/coil-network-ktor3`.
+plugins {
+	alias(libs.plugins.kotlin.multiplatform)
+}
+
+val vHostSupportsMingw = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+kotlin {
+	linuxArm64(); linuxX64(); macosArm64(); if (vHostSupportsMingw) mingwX64()
+	applyDefaultHierarchyTemplate()
+	sourceSets {
+		commonMain {
+			dependencies {
+				api(project(":coil:coil-core"))
+				api(project(":coil:coil-network-core"))
+				api(libs.ktor.client.core)
+			}
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+		val vNonAndroidMain = create("coilNonAndroidMain") {
+			dependsOn(commonMain.get())
+			kotlin.srcDir("src/vendor/nonAndroid/kotlin")
+			dependencies { implementation(libs.kotlinx.io.okio) }
+		}
+		nativeMain {
+			dependsOn(vNonAndroidMain)
+			kotlin.srcDir("src/vendor/native/kotlin")
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=coil3.annotation.InternalCoilApi",
+			"-opt-in=coil3.annotation.ExperimentalCoilApi",
+			"-opt-in=coil3.annotation.DelicateCoilApi",
+		)
+	}
+}

coil/coil-network-ktor3/compose-fork.txt

@@ -0,0 +1,32 @@
+# :coil:coil-network-ktor3 - Ktor 3 network fetcher. Upstream: linux + apple, no mingwX64.
+# Pairs with the port's existing ktor pin (the `ktor` entry in libs.versions.toml).
+# Upstream source sets collapse onto this port: it has NO android, jvm or js
+# target, so nonAndroidMain / nonJvmCommonMain / nonJsCommonMain / nativeMain all
+# apply to EVERY target here. They land in TWO trees, not one: the non* sets keep
+# their own level (src/vendor/nonAndroid) ABOVE src/vendor/native, because some of
+# them declare `expect`s whose `actual`s live in upstream nativeMain - collapsing
+# both into one source set makes expect and actual siblings, which is an error. appleMain is macosArm64
+# only and nonAppleMain is linux + mingw, so those two keep their own trees (the
+# build file wires a `nonAppleMain` intermediate; appleMain comes from the default
+# hierarchy template).
+SET_REPO=https://github.com/coil-kt/coil@<COIL_REF>
+
+SET_FOLDER=coil-network-ktor3/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/coil3/network/ktor3/KtorNetworkFetcher.kt -> src/vendor/common/kotlin/coil3/network/ktor3/KtorNetworkFetcher.kt
+#     | commonMain/kotlin/coil3/network/ktor3/internal/KtorNetworkFetcherServiceLoaderTarget.kt -> src/vendor/common/kotlin/coil3/network/ktor3/internal/KtorNetworkFetcherServiceLoaderTarget.kt
+#     | commonMain/kotlin/coil3/network/ktor3/internal/utils.kt -> src/vendor/common/kotlin/coil3/network/ktor3/internal/utils.kt
+nonJvmCommonMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonJvmCommonMain/kotlin/coil3/network/ktor3/internal/utils.nonJvmCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/network/ktor3/internal/utils.nonJvmCommon.kt
+nativeMain/kotlin/ -> src/vendor/native/kotlin/
+#     | nativeMain/kotlin/coil3/network/ktor3/internal/KtorNetworkFetcherServiceLoaderTarget.native.kt -> src/vendor/native/kotlin/coil3/network/ktor3/internal/KtorNetworkFetcherServiceLoaderTarget.native.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   jsMain (1)
+#     | jsMain/kotlin/coil3/network/ktor3/internal/KtorNetworkFetcherServiceLoaderTarget.js.kt -> src/vendor/js/kotlin/coil3/network/ktor3/internal/KtorNetworkFetcherServiceLoaderTarget.js.kt
+#   jvmCommonMain (1)
+#     | jvmCommonMain/kotlin/coil3/network/ktor3/internal/utils.jvmCommon.kt -> src/vendor/jvmCommon/kotlin/coil3/network/ktor3/internal/utils.jvmCommon.kt
+#   wasmJsMain (1)
+#     | wasmJsMain/kotlin/coil3/network/ktor3/internal/KtorNetworkFetcherServiceLoaderTarget.wasmJs.kt -> src/vendor/wasmJs/kotlin/coil3/network/ktor3/internal/KtorNetworkFetcherServiceLoaderTarget.wasmJs.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>

coil/coil-svg/api/coil-svg.klib.api

@@ -0,0 +1,123 @@
+// Klib ABI Dump
+// Targets: [linuxArm64, linuxX64, macosArm64, mingwX64]
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: true
+// - Show declarations: true
+
+// Library unique name: <com.bitsycore.coil3:coil-svg>
+abstract interface coil3.svg/Svg { // coil3.svg/Svg|null[0]
+    abstract val height // coil3.svg/Svg.height|{}height[0]
+        abstract fun <get-height>(): kotlin/Float // coil3.svg/Svg.height.<get-height>|<get-height>(){}[0]
+    abstract val width // coil3.svg/Svg.width|{}width[0]
+        abstract fun <get-width>(): kotlin/Float // coil3.svg/Svg.width.<get-width>|<get-width>(){}[0]
+
+    abstract var viewBox // coil3.svg/Svg.viewBox|{}viewBox[0]
+        abstract fun <get-viewBox>(): coil3.svg/Svg.ViewBox? // coil3.svg/Svg.viewBox.<get-viewBox>|<get-viewBox>(){}[0]
+        abstract fun <set-viewBox>(coil3.svg/Svg.ViewBox?) // coil3.svg/Svg.viewBox.<set-viewBox>|<set-viewBox>(coil3.svg.Svg.ViewBox?){}[0]
+
+    abstract fun asImage(kotlin/Int = ..., kotlin/Int = ...): coil3/Image // coil3.svg/Svg.asImage|asImage(kotlin.Int;kotlin.Int){}[0]
+    abstract fun height(kotlin/String) // coil3.svg/Svg.height|height(kotlin.String){}[0]
+    abstract fun options(coil3.request/Options) // coil3.svg/Svg.options|options(coil3.request.Options){}[0]
+    abstract fun width(kotlin/String) // coil3.svg/Svg.width|width(kotlin.String){}[0]
+
+    abstract fun interface Parser { // coil3.svg/Svg.Parser|null[0]
+        abstract fun parse(okio/BufferedSource): coil3.svg/Svg // coil3.svg/Svg.Parser.parse|parse(okio.BufferedSource){}[0]
+
+        final object Companion { // coil3.svg/Svg.Parser.Companion|null[0]
+            final val DEFAULT // coil3.svg/Svg.Parser.Companion.DEFAULT|{}DEFAULT[0]
+                final fun <get-DEFAULT>(): coil3.svg/Svg.Parser // coil3.svg/Svg.Parser.Companion.DEFAULT.<get-DEFAULT>|<get-DEFAULT>(){}[0]
+        }
+    }
+
+    final class ViewBox { // coil3.svg/Svg.ViewBox|null[0]
+        constructor <init>(kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float) // coil3.svg/Svg.ViewBox.<init>|<init>(kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float){}[0]
+
+        final val bottom // coil3.svg/Svg.ViewBox.bottom|{}bottom[0]
+            final fun <get-bottom>(): kotlin/Float // coil3.svg/Svg.ViewBox.bottom.<get-bottom>|<get-bottom>(){}[0]
+        final val left // coil3.svg/Svg.ViewBox.left|{}left[0]
+            final fun <get-left>(): kotlin/Float // coil3.svg/Svg.ViewBox.left.<get-left>|<get-left>(){}[0]
+        final val right // coil3.svg/Svg.ViewBox.right|{}right[0]
+            final fun <get-right>(): kotlin/Float // coil3.svg/Svg.ViewBox.right.<get-right>|<get-right>(){}[0]
+        final val top // coil3.svg/Svg.ViewBox.top|{}top[0]
+            final fun <get-top>(): kotlin/Float // coil3.svg/Svg.ViewBox.top.<get-top>|<get-top>(){}[0]
+
+        final fun component1(): kotlin/Float // coil3.svg/Svg.ViewBox.component1|component1(){}[0]
+        final fun component2(): kotlin/Float // coil3.svg/Svg.ViewBox.component2|component2(){}[0]
+        final fun component3(): kotlin/Float // coil3.svg/Svg.ViewBox.component3|component3(){}[0]
+        final fun component4(): kotlin/Float // coil3.svg/Svg.ViewBox.component4|component4(){}[0]
+        final fun copy(kotlin/Float = ..., kotlin/Float = ..., kotlin/Float = ..., kotlin/Float = ...): coil3.svg/Svg.ViewBox // coil3.svg/Svg.ViewBox.copy|copy(kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float){}[0]
+        final fun equals(kotlin/Any?): kotlin/Boolean // coil3.svg/Svg.ViewBox.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // coil3.svg/Svg.ViewBox.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // coil3.svg/Svg.ViewBox.toString|toString(){}[0]
+    }
+}
+
+final class coil3.svg/SvgDecoder : coil3.decode/Decoder { // coil3.svg/SvgDecoder|null[0]
+    constructor <init>(coil3.decode/ImageSource, coil3.request/Options, coil3.svg/Svg.Parser = ..., kotlin/Function1<coil3/PlatformContext, kotlin/Float> = ..., kotlin/Boolean = ..., kotlin/Boolean = ...) // coil3.svg/SvgDecoder.<init>|<init>(coil3.decode.ImageSource;coil3.request.Options;coil3.svg.Svg.Parser;kotlin.Function1<coil3.PlatformContext,kotlin.Float>;kotlin.Boolean;kotlin.Boolean){}[0]
+    constructor <init>(coil3.decode/ImageSource, coil3.request/Options, kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ...) // coil3.svg/SvgDecoder.<init>|<init>(coil3.decode.ImageSource;coil3.request.Options;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean){}[0]
+
+    final val density // coil3.svg/SvgDecoder.density|{}density[0]
+        final fun <get-density>(): kotlin/Function1<coil3/PlatformContext, kotlin/Float> // coil3.svg/SvgDecoder.density.<get-density>|<get-density>(){}[0]
+    final val parser // coil3.svg/SvgDecoder.parser|{}parser[0]
+        final fun <get-parser>(): coil3.svg/Svg.Parser // coil3.svg/SvgDecoder.parser.<get-parser>|<get-parser>(){}[0]
+    final val renderToBitmap // coil3.svg/SvgDecoder.renderToBitmap|{}renderToBitmap[0]
+        final fun <get-renderToBitmap>(): kotlin/Boolean // coil3.svg/SvgDecoder.renderToBitmap.<get-renderToBitmap>|<get-renderToBitmap>(){}[0]
+    final val scaleToDensity // coil3.svg/SvgDecoder.scaleToDensity|{}scaleToDensity[0]
+        final fun <get-scaleToDensity>(): kotlin/Boolean // coil3.svg/SvgDecoder.scaleToDensity.<get-scaleToDensity>|<get-scaleToDensity>(){}[0]
+    final val useViewBoundsAsIntrinsicSize // coil3.svg/SvgDecoder.useViewBoundsAsIntrinsicSize|{}useViewBoundsAsIntrinsicSize[0]
+        final fun <get-useViewBoundsAsIntrinsicSize>(): kotlin/Boolean // coil3.svg/SvgDecoder.useViewBoundsAsIntrinsicSize.<get-useViewBoundsAsIntrinsicSize>|<get-useViewBoundsAsIntrinsicSize>(){}[0]
+
+    final suspend fun decode(): coil3.decode/DecodeResult // coil3.svg/SvgDecoder.decode|decode(){}[0]
+
+    final class Factory : coil3.decode/Decoder.Factory { // coil3.svg/SvgDecoder.Factory|null[0]
+        constructor <init>(coil3.svg/Svg.Parser = ..., kotlin/Function1<coil3/PlatformContext, kotlin/Float> = ..., kotlin/Boolean = ..., kotlin/Boolean = ...) // coil3.svg/SvgDecoder.Factory.<init>|<init>(coil3.svg.Svg.Parser;kotlin.Function1<coil3.PlatformContext,kotlin.Float>;kotlin.Boolean;kotlin.Boolean){}[0]
+        constructor <init>(kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ...) // coil3.svg/SvgDecoder.Factory.<init>|<init>(kotlin.Boolean;kotlin.Boolean;kotlin.Boolean){}[0]
+
+        final val density // coil3.svg/SvgDecoder.Factory.density|{}density[0]
+            final fun <get-density>(): kotlin/Function1<coil3/PlatformContext, kotlin/Float> // coil3.svg/SvgDecoder.Factory.density.<get-density>|<get-density>(){}[0]
+        final val parser // coil3.svg/SvgDecoder.Factory.parser|{}parser[0]
+            final fun <get-parser>(): coil3.svg/Svg.Parser // coil3.svg/SvgDecoder.Factory.parser.<get-parser>|<get-parser>(){}[0]
+        final val renderToBitmap // coil3.svg/SvgDecoder.Factory.renderToBitmap|{}renderToBitmap[0]
+            final fun <get-renderToBitmap>(): kotlin/Boolean // coil3.svg/SvgDecoder.Factory.renderToBitmap.<get-renderToBitmap>|<get-renderToBitmap>(){}[0]
+        final val scaleToDensity // coil3.svg/SvgDecoder.Factory.scaleToDensity|{}scaleToDensity[0]
+            final fun <get-scaleToDensity>(): kotlin/Boolean // coil3.svg/SvgDecoder.Factory.scaleToDensity.<get-scaleToDensity>|<get-scaleToDensity>(){}[0]
+        final val useViewBoundsAsIntrinsicSize // coil3.svg/SvgDecoder.Factory.useViewBoundsAsIntrinsicSize|{}useViewBoundsAsIntrinsicSize[0]
+            final fun <get-useViewBoundsAsIntrinsicSize>(): kotlin/Boolean // coil3.svg/SvgDecoder.Factory.useViewBoundsAsIntrinsicSize.<get-useViewBoundsAsIntrinsicSize>|<get-useViewBoundsAsIntrinsicSize>(){}[0]
+
+        final fun create(coil3.fetch/SourceFetchResult, coil3.request/Options, coil3/ImageLoader): coil3.decode/Decoder? // coil3.svg/SvgDecoder.Factory.create|create(coil3.fetch.SourceFetchResult;coil3.request.Options;coil3.ImageLoader){}[0]
+    }
+
+    final object Companion { // coil3.svg/SvgDecoder.Companion|null[0]
+        final val NO_DENSITY // coil3.svg/SvgDecoder.Companion.NO_DENSITY|{}NO_DENSITY[0]
+            final fun <get-NO_DENSITY>(): kotlin/Function1<coil3/PlatformContext, kotlin/Float> // coil3.svg/SvgDecoder.Companion.NO_DENSITY.<get-NO_DENSITY>|<get-NO_DENSITY>(){}[0]
+        final val PLATFORM_DENSITY // coil3.svg/SvgDecoder.Companion.PLATFORM_DENSITY|{}PLATFORM_DENSITY[0]
+            final fun <get-PLATFORM_DENSITY>(): kotlin/Function1<coil3/PlatformContext, kotlin/Float> // coil3.svg/SvgDecoder.Companion.PLATFORM_DENSITY.<get-PLATFORM_DENSITY>|<get-PLATFORM_DENSITY>(){}[0]
+    }
+}
+
+final class coil3.svg/SvgImage : coil3/Image { // coil3.svg/SvgImage|null[0]
+    constructor <init>(org.jetbrains.skia.svg/SVGDOM, kotlin/Int, kotlin/Int) // coil3.svg/SvgImage.<init>|<init>(org.jetbrains.skia.svg.SVGDOM;kotlin.Int;kotlin.Int){}[0]
+
+    final val height // coil3.svg/SvgImage.height|{}height[0]
+        final fun <get-height>(): kotlin/Int // coil3.svg/SvgImage.height.<get-height>|<get-height>(){}[0]
+    final val shareable // coil3.svg/SvgImage.shareable|{}shareable[0]
+        final fun <get-shareable>(): kotlin/Boolean // coil3.svg/SvgImage.shareable.<get-shareable>|<get-shareable>(){}[0]
+    final val size // coil3.svg/SvgImage.size|{}size[0]
+        final fun <get-size>(): kotlin/Long // coil3.svg/SvgImage.size.<get-size>|<get-size>(){}[0]
+    final val svg // coil3.svg/SvgImage.svg|{}svg[0]
+        final fun <get-svg>(): org.jetbrains.skia.svg/SVGDOM // coil3.svg/SvgImage.svg.<get-svg>|<get-svg>(){}[0]
+    final val width // coil3.svg/SvgImage.width|{}width[0]
+        final fun <get-width>(): kotlin/Int // coil3.svg/SvgImage.width.<get-width>|<get-width>(){}[0]
+
+    final fun draw(org.jetbrains.skia/Canvas) // coil3.svg/SvgImage.draw|draw(org.jetbrains.skia.Canvas){}[0]
+}
+
+final val coil3.svg.internal/initHook // coil3.svg.internal/initHook|{}initHook[0]
+    final fun <get-initHook>(): kotlin/Any // coil3.svg.internal/initHook.<get-initHook>|<get-initHook>(){}[0]
+final val coil3.svg/height // coil3.svg/height|@coil3.svg.Svg.ViewBox{}height[0]
+    final fun (coil3.svg/Svg.ViewBox).<get-height>(): kotlin/Float // coil3.svg/height.<get-height>|<get-height>@coil3.svg.Svg.ViewBox(){}[0]
+final val coil3.svg/width // coil3.svg/width|@coil3.svg.Svg.ViewBox{}width[0]
+    final fun (coil3.svg/Svg.ViewBox).<get-width>(): kotlin/Float // coil3.svg/width.<get-width>|<get-width>@coil3.svg.Svg.ViewBox(){}[0]
+
+final fun (coil3.decode/DecodeUtils).coil3.svg/isSvg(okio/BufferedSource): kotlin/Boolean // coil3.svg/isSvg|isSvg@coil3.decode.DecodeUtils(okio.BufferedSource){}[0]

coil/coil-svg/build.gradle.kts

@@ -0,0 +1,55 @@
+// :coil:coil-svg - SVG decoding, vendored VERBATIM from coil-kt/coil into src/vendor.
+// Upstream: linux + apple, no mingwX64. The non-android decoder goes through skiko's
+// SVGDOM, so mingwX64 binds the bitsycore skiko FORK like :compose:ui:ui-graphics.
+// Upstream's non* source sets sit ABOVE nativeMain here (see coil-core).
+plugins {
+	alias(libs.plugins.kotlin.multiplatform)
+}
+
+val vHostSupportsMingw = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+kotlin {
+	linuxArm64(); linuxX64(); macosArm64(); if (vHostSupportsMingw) mingwX64()
+	applyDefaultHierarchyTemplate()
+	sourceSets {
+		commonMain {
+			dependencies { api(project(":coil:coil-core")) }
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+		// Two PARALLEL skiko branches (official for macOS/Linux, the bitsycore fork for
+		// mingwX64), each two levels deep so nonAndroid `expect`s and nativeMain
+		// `actual`s are not siblings. See coil/coil-core/build.gradle.kts for the why.
+		fun skikoBranch(inName: String, inSkiko: Any): org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet {
+			val vNonAndroid = create("${inName}NonAndroidMain") {
+				dependsOn(commonMain.get())
+				kotlin.srcDir("src/vendor/nonAndroid/kotlin")
+				dependencies { implementation(inSkiko) }
+			}
+			return create("${inName}NativeMain") {
+				dependsOn(vNonAndroid)
+				kotlin.srcDir("src/vendor/native/kotlin")
+			}
+		}
+
+		val vOfficial = skikoBranch("coilSvgOfficial", libs.skiko)
+		get("macosArm64Main").dependsOn(vOfficial)
+		get("linuxX64Main").dependsOn(vOfficial)
+		get("linuxArm64Main").dependsOn(vOfficial)
+
+		if (vHostSupportsMingw) {
+			val vFork = skikoBranch(
+				"coilSvgFork",
+				"com.bitsycore.skiko:skiko:${providers.gradleProperty("skikoMingwVersion").getOrElse(libs.versions.skikoMingw.get())}",
+			)
+			get("mingwX64Main").dependsOn(vFork)
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=coil3.annotation.InternalCoilApi",
+			"-opt-in=coil3.annotation.ExperimentalCoilApi",
+			"-opt-in=coil3.annotation.DelicateCoilApi",
+		)
+	}
+}

coil/coil-svg/compose-fork.txt

@@ -0,0 +1,44 @@
+# :coil:coil-svg - SVG decoding. Upstream: linux + apple, no mingwX64.
+# The non-android decoder goes through skiko's SVGDOM.
+# Upstream source sets collapse onto this port: it has NO android, jvm or js
+# target, so nonAndroidMain / nonJvmCommonMain / nonJsCommonMain / nativeMain all
+# apply to EVERY target here. They land in TWO trees, not one: the non* sets keep
+# their own level (src/vendor/nonAndroid) ABOVE src/vendor/native, because some of
+# them declare `expect`s whose `actual`s live in upstream nativeMain - collapsing
+# both into one source set makes expect and actual siblings, which is an error. appleMain is macosArm64
+# only and nonAppleMain is linux + mingw, so those two keep their own trees (the
+# build file wires a `nonAppleMain` intermediate; appleMain comes from the default
+# hierarchy template).
+SET_REPO=https://github.com/coil-kt/coil@<COIL_REF>
+
+SET_FOLDER=coil-svg/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/coil3/svg/Svg.kt -> src/vendor/common/kotlin/coil3/svg/Svg.kt
+#     | commonMain/kotlin/coil3/svg/SvgDecoder.kt -> src/vendor/common/kotlin/coil3/svg/SvgDecoder.kt
+#     | commonMain/kotlin/coil3/svg/decodeUtils.kt -> src/vendor/common/kotlin/coil3/svg/decodeUtils.kt
+#     | commonMain/kotlin/coil3/svg/internal/SvgDecoderServiceLoaderTarget.kt -> src/vendor/common/kotlin/coil3/svg/internal/SvgDecoderServiceLoaderTarget.kt
+#     | commonMain/kotlin/coil3/svg/internal/parseSvg.kt -> src/vendor/common/kotlin/coil3/svg/internal/parseSvg.kt
+#     | commonMain/kotlin/coil3/svg/internal/utils.kt -> src/vendor/common/kotlin/coil3/svg/internal/utils.kt
+nonAndroidMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonAndroidMain/kotlin/coil3/svg/SvgImage.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/svg/SvgImage.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/svg/internal/parseSvg.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/svg/internal/parseSvg.nonAndroid.kt
+#     | nonAndroidMain/kotlin/coil3/svg/internal/utils.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/svg/internal/utils.nonAndroid.kt
+nonJvmCommonMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonJvmCommonMain/kotlin/coil3/svg/internal/utils.nonJvmCommon.kt -> src/vendor/nonAndroid/kotlin/coil3/svg/internal/utils.nonJvmCommon.kt
+nativeMain/kotlin/ -> src/vendor/native/kotlin/
+#     | nativeMain/kotlin/coil3/svg/internal/SvgDecoderServiceLoaderTarget.native.kt -> src/vendor/native/kotlin/coil3/svg/internal/SvgDecoderServiceLoaderTarget.native.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   androidMain (4)
+#     | androidMain/kotlin/coil3/svg/SvgImage.android.kt -> src/vendor/android/kotlin/coil3/svg/SvgImage.android.kt
+#     | androidMain/kotlin/coil3/svg/imageRequests.android.kt -> src/vendor/android/kotlin/coil3/svg/imageRequests.android.kt
+#     | androidMain/kotlin/coil3/svg/internal/parseSvg.android.kt -> src/vendor/android/kotlin/coil3/svg/internal/parseSvg.android.kt
+#     | androidMain/kotlin/coil3/svg/internal/utils.android.kt -> src/vendor/android/kotlin/coil3/svg/internal/utils.android.kt
+#   jsMain (1)
+#     | jsMain/kotlin/coil3/svg/internal/SvgDecoderServiceLoaderTarget.js.kt -> src/vendor/js/kotlin/coil3/svg/internal/SvgDecoderServiceLoaderTarget.js.kt
+#   jvmCommonMain (1)
+#     | jvmCommonMain/kotlin/coil3/svg/internal/utils.jvmCommon.kt -> src/vendor/jvmCommon/kotlin/coil3/svg/internal/utils.jvmCommon.kt
+#   wasmJsMain (1)
+#     | wasmJsMain/kotlin/coil3/svg/internal/SvgDecoderServiceLoaderTarget.wasmJs.kt -> src/vendor/wasmJs/kotlin/coil3/svg/internal/SvgDecoderServiceLoaderTarget.wasmJs.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>

coil/coil/api/coil.klib.api

@@ -0,0 +1,19 @@
+// Klib ABI Dump
+// Targets: [linuxArm64, linuxX64, macosArm64, mingwX64]
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: true
+// - Show declarations: true
+
+// Library unique name: <com.bitsycore.coil3:coil>
+final object coil3/SingletonImageLoader { // coil3/SingletonImageLoader|null[0]
+    final fun get(coil3/PlatformContext): coil3/ImageLoader // coil3/SingletonImageLoader.get|get(coil3.PlatformContext){}[0]
+    final fun reset() // coil3/SingletonImageLoader.reset|reset(){}[0]
+    final fun setSafe(coil3/SingletonImageLoader.Factory) // coil3/SingletonImageLoader.setSafe|setSafe(coil3.SingletonImageLoader.Factory){}[0]
+    final fun setUnsafe(coil3/ImageLoader) // coil3/SingletonImageLoader.setUnsafe|setUnsafe(coil3.ImageLoader){}[0]
+    final fun setUnsafe(coil3/SingletonImageLoader.Factory) // coil3/SingletonImageLoader.setUnsafe|setUnsafe(coil3.SingletonImageLoader.Factory){}[0]
+
+    abstract fun interface Factory { // coil3/SingletonImageLoader.Factory|null[0]
+        abstract fun newImageLoader(coil3/PlatformContext): coil3/ImageLoader // coil3/SingletonImageLoader.Factory.newImageLoader|newImageLoader(coil3.PlatformContext){}[0]
+    }
+}

coil/coil/build.gradle.kts

@@ -0,0 +1,34 @@
+// :coil:coil - vendored VERBATIM from coil-kt/coil into src/vendor.
+// The singleton ImageLoader facade. Upstream: linux + apple, no mingwX64.
+// Upstream's non* source sets sit ABOVE nativeMain here (see coil-core's build file
+// and compose-fork.txt for why). Provenance = compose-fork.txt; never hand-edit
+// src/vendor - change the manifest + `python scripts/compose-fork/sync.py coil/coil`.
+plugins {
+	alias(libs.plugins.kotlin.multiplatform)
+}
+
+val vHostSupportsMingw = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+kotlin {
+	linuxArm64(); linuxX64(); macosArm64(); if (vHostSupportsMingw) mingwX64()
+	applyDefaultHierarchyTemplate()
+	sourceSets {
+		commonMain {
+			dependencies { api(project(":coil:coil-core")) }
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+		val vNonAndroidMain = create("coilNonAndroidMain") {
+			dependsOn(commonMain.get())
+			kotlin.srcDir("src/vendor/nonAndroid/kotlin")
+		}
+		nativeMain { dependsOn(vNonAndroidMain) }
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=coil3.annotation.InternalCoilApi",
+			"-opt-in=coil3.annotation.ExperimentalCoilApi",
+			"-opt-in=coil3.annotation.DelicateCoilApi",
+		)
+	}
+}

coil/coil/compose-fork.txt

@@ -0,0 +1,24 @@
+# :coil:coil - the singleton ImageLoader facade. Upstream: linux + apple, no mingwX64.
+# Upstream source sets collapse onto this port: it has NO android, jvm or js
+# target, so nonAndroidMain / nonJvmCommonMain / nonJsCommonMain / nativeMain all
+# apply to EVERY target here. They land in TWO trees, not one: the non* sets keep
+# their own level (src/vendor/nonAndroid) ABOVE src/vendor/native, because some of
+# them declare `expect`s whose `actual`s live in upstream nativeMain - collapsing
+# both into one source set makes expect and actual siblings, which is an error. appleMain is macosArm64
+# only and nonAppleMain is linux + mingw, so those two keep their own trees (the
+# build file wires a `nonAppleMain` intermediate; appleMain comes from the default
+# hierarchy template).
+SET_REPO=https://github.com/coil-kt/coil@<COIL_REF>
+
+SET_FOLDER=coil/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/coil3/SingletonImageLoader.kt -> src/vendor/common/kotlin/coil3/SingletonImageLoader.kt
+nonAndroidMain/kotlin/ -> src/vendor/nonAndroid/kotlin/
+#     | nonAndroidMain/kotlin/coil3/SingletonImageLoader.nonAndroid.kt -> src/vendor/nonAndroid/kotlin/coil3/SingletonImageLoader.nonAndroid.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   androidMain (2)
+#     | androidMain/kotlin/coil3/SingletonImageLoader.android.kt -> src/vendor/android/kotlin/coil3/SingletonImageLoader.android.kt
+#     | androidMain/kotlin/coil3/singletonImageLoaders.android.kt -> src/vendor/android/kotlin/coil3/singletonImageLoaders.android.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>

components/resources/components-resources/api/components-resources.klib.api

@@ -0,0 +1,238 @@
+// Klib ABI Dump
+// Targets: [linuxArm64, linuxX64, macosArm64, mingwX64]
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: true
+// - Show declarations: true
+
+// Library unique name: <com.bitsycore.compose.components:components-resources>
+open annotation class org.jetbrains.compose.resources/ExperimentalResourceApi : kotlin/Annotation { // org.jetbrains.compose.resources/ExperimentalResourceApi|null[0]
+    constructor <init>() // org.jetbrains.compose.resources/ExperimentalResourceApi.<init>|<init>(){}[0]
+}
+
+open annotation class org.jetbrains.compose.resources/InternalResourceApi : kotlin/Annotation { // org.jetbrains.compose.resources/InternalResourceApi|null[0]
+    constructor <init>() // org.jetbrains.compose.resources/InternalResourceApi.<init>|<init>(){}[0]
+}
+
+open annotation class org.jetbrains.compose.resources/ResourceContentHash : kotlin/Annotation { // org.jetbrains.compose.resources/ResourceContentHash|null[0]
+    constructor <init>(kotlin/Int) // org.jetbrains.compose.resources/ResourceContentHash.<init>|<init>(kotlin.Int){}[0]
+
+    final val hash // org.jetbrains.compose.resources/ResourceContentHash.hash|{}hash[0]
+        final fun <get-hash>(): kotlin/Int // org.jetbrains.compose.resources/ResourceContentHash.hash.<get-hash>|<get-hash>(){}[0]
+}
+
+final enum class org.jetbrains.compose.resources/DensityQualifier : kotlin/Enum<org.jetbrains.compose.resources/DensityQualifier>, org.jetbrains.compose.resources/Qualifier { // org.jetbrains.compose.resources/DensityQualifier|null[0]
+    enum entry HDPI // org.jetbrains.compose.resources/DensityQualifier.HDPI|null[0]
+    enum entry LDPI // org.jetbrains.compose.resources/DensityQualifier.LDPI|null[0]
+    enum entry MDPI // org.jetbrains.compose.resources/DensityQualifier.MDPI|null[0]
+    enum entry XHDPI // org.jetbrains.compose.resources/DensityQualifier.XHDPI|null[0]
+    enum entry XXHDPI // org.jetbrains.compose.resources/DensityQualifier.XXHDPI|null[0]
+    enum entry XXXHDPI // org.jetbrains.compose.resources/DensityQualifier.XXXHDPI|null[0]
+
+    final val dpi // org.jetbrains.compose.resources/DensityQualifier.dpi|{}dpi[0]
+        final fun <get-dpi>(): kotlin/Int // org.jetbrains.compose.resources/DensityQualifier.dpi.<get-dpi>|<get-dpi>(){}[0]
+    final val entries // org.jetbrains.compose.resources/DensityQualifier.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<org.jetbrains.compose.resources/DensityQualifier> // org.jetbrains.compose.resources/DensityQualifier.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): org.jetbrains.compose.resources/DensityQualifier // org.jetbrains.compose.resources/DensityQualifier.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<org.jetbrains.compose.resources/DensityQualifier> // org.jetbrains.compose.resources/DensityQualifier.values|values#static(){}[0]
+
+    final object Companion { // org.jetbrains.compose.resources/DensityQualifier.Companion|null[0]
+        final fun selectByDensity(kotlin/Float): org.jetbrains.compose.resources/DensityQualifier // org.jetbrains.compose.resources/DensityQualifier.Companion.selectByDensity|selectByDensity(kotlin.Float){}[0]
+        final fun selectByValue(kotlin/Int): org.jetbrains.compose.resources/DensityQualifier // org.jetbrains.compose.resources/DensityQualifier.Companion.selectByValue|selectByValue(kotlin.Int){}[0]
+    }
+}
+
+final enum class org.jetbrains.compose.resources/ThemeQualifier : kotlin/Enum<org.jetbrains.compose.resources/ThemeQualifier>, org.jetbrains.compose.resources/Qualifier { // org.jetbrains.compose.resources/ThemeQualifier|null[0]
+    enum entry DARK // org.jetbrains.compose.resources/ThemeQualifier.DARK|null[0]
+    enum entry LIGHT // org.jetbrains.compose.resources/ThemeQualifier.LIGHT|null[0]
+
+    final val entries // org.jetbrains.compose.resources/ThemeQualifier.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<org.jetbrains.compose.resources/ThemeQualifier> // org.jetbrains.compose.resources/ThemeQualifier.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): org.jetbrains.compose.resources/ThemeQualifier // org.jetbrains.compose.resources/ThemeQualifier.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<org.jetbrains.compose.resources/ThemeQualifier> // org.jetbrains.compose.resources/ThemeQualifier.values|values#static(){}[0]
+
+    final object Companion { // org.jetbrains.compose.resources/ThemeQualifier.Companion|null[0]
+        final fun selectByValue(kotlin/Boolean): org.jetbrains.compose.resources/ThemeQualifier // org.jetbrains.compose.resources/ThemeQualifier.Companion.selectByValue|selectByValue(kotlin.Boolean){}[0]
+    }
+}
+
+abstract interface org.jetbrains.compose.resources/Qualifier // org.jetbrains.compose.resources/Qualifier|null[0]
+
+abstract interface org.jetbrains.compose.resources/ResourceReader { // org.jetbrains.compose.resources/ResourceReader|null[0]
+    abstract fun getUri(kotlin/String): kotlin/String // org.jetbrains.compose.resources/ResourceReader.getUri|getUri(kotlin.String){}[0]
+    abstract suspend fun read(kotlin/String): kotlin/ByteArray // org.jetbrains.compose.resources/ResourceReader.read|read(kotlin.String){}[0]
+    abstract suspend fun readPart(kotlin/String, kotlin/Long, kotlin/Long): kotlin/ByteArray // org.jetbrains.compose.resources/ResourceReader.readPart|readPart(kotlin.String;kotlin.Long;kotlin.Long){}[0]
+}
+
+final class org.jetbrains.compose.resources.vector.xmldom/MalformedXMLException : kotlin/Exception { // org.jetbrains.compose.resources.vector.xmldom/MalformedXMLException|null[0]
+    constructor <init>(kotlin/String?) // org.jetbrains.compose.resources.vector.xmldom/MalformedXMLException.<init>|<init>(kotlin.String?){}[0]
+}
+
+final class org.jetbrains.compose.resources/DrawableResource : org.jetbrains.compose.resources/Resource { // org.jetbrains.compose.resources/DrawableResource|null[0]
+    constructor <init>(kotlin/String, kotlin.collections/Set<org.jetbrains.compose.resources/ResourceItem>) // org.jetbrains.compose.resources/DrawableResource.<init>|<init>(kotlin.String;kotlin.collections.Set<org.jetbrains.compose.resources.ResourceItem>){}[0]
+}
+
+final class org.jetbrains.compose.resources/FontResource : org.jetbrains.compose.resources/Resource { // org.jetbrains.compose.resources/FontResource|null[0]
+    constructor <init>(kotlin/String, kotlin.collections/Set<org.jetbrains.compose.resources/ResourceItem>) // org.jetbrains.compose.resources/FontResource.<init>|<init>(kotlin.String;kotlin.collections.Set<org.jetbrains.compose.resources.ResourceItem>){}[0]
+}
+
+final class org.jetbrains.compose.resources/LanguageQualifier : org.jetbrains.compose.resources/Qualifier { // org.jetbrains.compose.resources/LanguageQualifier|null[0]
+    constructor <init>(kotlin/String) // org.jetbrains.compose.resources/LanguageQualifier.<init>|<init>(kotlin.String){}[0]
+
+    final val language // org.jetbrains.compose.resources/LanguageQualifier.language|{}language[0]
+        final fun <get-language>(): kotlin/String // org.jetbrains.compose.resources/LanguageQualifier.language.<get-language>|<get-language>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // org.jetbrains.compose.resources/LanguageQualifier.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // org.jetbrains.compose.resources/LanguageQualifier.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // org.jetbrains.compose.resources/LanguageQualifier.toString|toString(){}[0]
+}
+
+final class org.jetbrains.compose.resources/MissingResourceException : kotlin/Exception { // org.jetbrains.compose.resources/MissingResourceException|null[0]
+    constructor <init>(kotlin/String) // org.jetbrains.compose.resources/MissingResourceException.<init>|<init>(kotlin.String){}[0]
+}
+
+final class org.jetbrains.compose.resources/PluralStringResource : org.jetbrains.compose.resources/Resource { // org.jetbrains.compose.resources/PluralStringResource|null[0]
+    constructor <init>(kotlin/String, kotlin/String, kotlin.collections/Set<org.jetbrains.compose.resources/ResourceItem>) // org.jetbrains.compose.resources/PluralStringResource.<init>|<init>(kotlin.String;kotlin.String;kotlin.collections.Set<org.jetbrains.compose.resources.ResourceItem>){}[0]
+
+    final val key // org.jetbrains.compose.resources/PluralStringResource.key|{}key[0]
+        final fun <get-key>(): kotlin/String // org.jetbrains.compose.resources/PluralStringResource.key.<get-key>|<get-key>(){}[0]
+}
+
+final class org.jetbrains.compose.resources/RegionQualifier : org.jetbrains.compose.resources/Qualifier { // org.jetbrains.compose.resources/RegionQualifier|null[0]
+    constructor <init>(kotlin/String) // org.jetbrains.compose.resources/RegionQualifier.<init>|<init>(kotlin.String){}[0]
+
+    final val region // org.jetbrains.compose.resources/RegionQualifier.region|{}region[0]
+        final fun <get-region>(): kotlin/String // org.jetbrains.compose.resources/RegionQualifier.region.<get-region>|<get-region>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // org.jetbrains.compose.resources/RegionQualifier.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // org.jetbrains.compose.resources/RegionQualifier.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // org.jetbrains.compose.resources/RegionQualifier.toString|toString(){}[0]
+}
+
+final class org.jetbrains.compose.resources/ResourceEnvironment { // org.jetbrains.compose.resources/ResourceEnvironment|null[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // org.jetbrains.compose.resources/ResourceEnvironment.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // org.jetbrains.compose.resources/ResourceEnvironment.hashCode|hashCode(){}[0]
+}
+
+final class org.jetbrains.compose.resources/ResourceItem { // org.jetbrains.compose.resources/ResourceItem|null[0]
+    constructor <init>(kotlin.collections/Set<org.jetbrains.compose.resources/Qualifier>, kotlin/String, kotlin/Long, kotlin/Long) // org.jetbrains.compose.resources/ResourceItem.<init>|<init>(kotlin.collections.Set<org.jetbrains.compose.resources.Qualifier>;kotlin.String;kotlin.Long;kotlin.Long){}[0]
+
+    final fun copy(kotlin.collections/Set<org.jetbrains.compose.resources/Qualifier> = ..., kotlin/String = ..., kotlin/Long = ..., kotlin/Long = ...): org.jetbrains.compose.resources/ResourceItem // org.jetbrains.compose.resources/ResourceItem.copy|copy(kotlin.collections.Set<org.jetbrains.compose.resources.Qualifier>;kotlin.String;kotlin.Long;kotlin.Long){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // org.jetbrains.compose.resources/ResourceItem.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // org.jetbrains.compose.resources/ResourceItem.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // org.jetbrains.compose.resources/ResourceItem.toString|toString(){}[0]
+}
+
+final class org.jetbrains.compose.resources/ScriptQualifier : org.jetbrains.compose.resources/Qualifier { // org.jetbrains.compose.resources/ScriptQualifier|null[0]
+    constructor <init>(kotlin/String) // org.jetbrains.compose.resources/ScriptQualifier.<init>|<init>(kotlin.String){}[0]
+
+    final val script // org.jetbrains.compose.resources/ScriptQualifier.script|{}script[0]
+        final fun <get-script>(): kotlin/String // org.jetbrains.compose.resources/ScriptQualifier.script.<get-script>|<get-script>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // org.jetbrains.compose.resources/ScriptQualifier.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // org.jetbrains.compose.resources/ScriptQualifier.hashCode|hashCode(){}[0]
+    final fun isEmpty(): kotlin/Boolean // org.jetbrains.compose.resources/ScriptQualifier.isEmpty|isEmpty(){}[0]
+    final fun toString(): kotlin/String // org.jetbrains.compose.resources/ScriptQualifier.toString|toString(){}[0]
+}
+
+final class org.jetbrains.compose.resources/StringArrayResource : org.jetbrains.compose.resources/Resource { // org.jetbrains.compose.resources/StringArrayResource|null[0]
+    constructor <init>(kotlin/String, kotlin/String, kotlin.collections/Set<org.jetbrains.compose.resources/ResourceItem>) // org.jetbrains.compose.resources/StringArrayResource.<init>|<init>(kotlin.String;kotlin.String;kotlin.collections.Set<org.jetbrains.compose.resources.ResourceItem>){}[0]
+
+    final val key // org.jetbrains.compose.resources/StringArrayResource.key|{}key[0]
+        final fun <get-key>(): kotlin/String // org.jetbrains.compose.resources/StringArrayResource.key.<get-key>|<get-key>(){}[0]
+}
+
+final class org.jetbrains.compose.resources/StringResource : org.jetbrains.compose.resources/Resource { // org.jetbrains.compose.resources/StringResource|null[0]
+    constructor <init>(kotlin/String, kotlin/String, kotlin.collections/Set<org.jetbrains.compose.resources/ResourceItem>) // org.jetbrains.compose.resources/StringResource.<init>|<init>(kotlin.String;kotlin.String;kotlin.collections.Set<org.jetbrains.compose.resources.ResourceItem>){}[0]
+
+    final val key // org.jetbrains.compose.resources/StringResource.key|{}key[0]
+        final fun <get-key>(): kotlin/String // org.jetbrains.compose.resources/StringResource.key.<get-key>|<get-key>(){}[0]
+}
+
+sealed class org.jetbrains.compose.resources/Resource { // org.jetbrains.compose.resources/Resource|null[0]
+    open fun equals(kotlin/Any?): kotlin/Boolean // org.jetbrains.compose.resources/Resource.equals|equals(kotlin.Any?){}[0]
+    open fun hashCode(): kotlin/Int // org.jetbrains.compose.resources/Resource.hashCode|hashCode(){}[0]
+}
+
+final object org.jetbrains.compose.resources/ResourceCaches // org.jetbrains.compose.resources/ResourceCaches|null[0]
+
+final val org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_And$stableprop // org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_And$stableprop|#static{}org_jetbrains_compose_resources_plural_PluralRule_Condition_And$stableprop[0]
+final val org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_Or$stableprop // org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_Or$stableprop|#static{}org_jetbrains_compose_resources_plural_PluralRule_Condition_Or$stableprop[0]
+final val org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_Relation$stableprop // org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_Relation$stableprop|#static{}org_jetbrains_compose_resources_plural_PluralRule_Condition_Relation$stableprop[0]
+final val org.jetbrains.compose.resources.vector.xmldom/org_jetbrains_compose_resources_vector_xmldom_MalformedXMLException$stableprop // org.jetbrains.compose.resources.vector.xmldom/org_jetbrains_compose_resources_vector_xmldom_MalformedXMLException$stableprop|#static{}org_jetbrains_compose_resources_vector_xmldom_MalformedXMLException$stableprop[0]
+final val org.jetbrains.compose.resources/LocalResourceReader // org.jetbrains.compose.resources/LocalResourceReader|{}LocalResourceReader[0]
+    final fun <get-LocalResourceReader>(): androidx.compose.runtime/ProvidableCompositionLocal<org.jetbrains.compose.resources/ResourceReader> // org.jetbrains.compose.resources/LocalResourceReader.<get-LocalResourceReader>|<get-LocalResourceReader>(){}[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_DrawableResource$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_DrawableResource$stableprop|#static{}org_jetbrains_compose_resources_DrawableResource$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_FontResource$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_FontResource$stableprop|#static{}org_jetbrains_compose_resources_FontResource$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Bitmap$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Bitmap$stableprop|#static{}org_jetbrains_compose_resources_ImageCache_Bitmap$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Svg$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Svg$stableprop|#static{}org_jetbrains_compose_resources_ImageCache_Svg$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Vector$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Vector$stableprop|#static{}org_jetbrains_compose_resources_ImageCache_Vector$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_LanguageQualifier$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_LanguageQualifier$stableprop|#static{}org_jetbrains_compose_resources_LanguageQualifier$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_MissingResourceException$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_MissingResourceException$stableprop|#static{}org_jetbrains_compose_resources_MissingResourceException$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_PluralStringResource$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_PluralStringResource$stableprop|#static{}org_jetbrains_compose_resources_PluralStringResource$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_RegionQualifier$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_RegionQualifier$stableprop|#static{}org_jetbrains_compose_resources_RegionQualifier$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_Resource$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_Resource$stableprop|#static{}org_jetbrains_compose_resources_Resource$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceCaches$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceCaches$stableprop|#static{}org_jetbrains_compose_resources_ResourceCaches$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceEnvironment$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceEnvironment$stableprop|#static{}org_jetbrains_compose_resources_ResourceEnvironment$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceItem$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceItem$stableprop|#static{}org_jetbrains_compose_resources_ResourceItem$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_ScriptQualifier$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ScriptQualifier$stableprop|#static{}org_jetbrains_compose_resources_ScriptQualifier$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringArrayResource$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringArrayResource$stableprop|#static{}org_jetbrains_compose_resources_StringArrayResource$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Array$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Array$stableprop|#static{}org_jetbrains_compose_resources_StringItem_Array$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Plurals$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Plurals$stableprop|#static{}org_jetbrains_compose_resources_StringItem_Plurals$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Value$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Value$stableprop|#static{}org_jetbrains_compose_resources_StringItem_Value$stableprop[0]
+final val org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringResource$stableprop // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringResource$stableprop|#static{}org_jetbrains_compose_resources_StringResource$stableprop[0]
+
+final fun (kotlin/ByteArray).org.jetbrains.compose.resources/decodeToImageBitmap(): androidx.compose.ui.graphics/ImageBitmap // org.jetbrains.compose.resources/decodeToImageBitmap|decodeToImageBitmap@kotlin.ByteArray(){}[0]
+final fun (kotlin/ByteArray).org.jetbrains.compose.resources/decodeToImageVector(androidx.compose.ui.unit/Density): androidx.compose.ui.graphics.vector/ImageVector // org.jetbrains.compose.resources/decodeToImageVector|decodeToImageVector@kotlin.ByteArray(androidx.compose.ui.unit.Density){}[0]
+final fun (kotlin/ByteArray).org.jetbrains.compose.resources/decodeToSvgPainter(androidx.compose.ui.unit/Density): androidx.compose.ui.graphics.painter/Painter // org.jetbrains.compose.resources/decodeToSvgPainter|decodeToSvgPainter@kotlin.ByteArray(androidx.compose.ui.unit.Density){}[0]
+final fun org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_And$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_And$stableprop_getter|org_jetbrains_compose_resources_plural_PluralRule_Condition_And$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_Or$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_Or$stableprop_getter|org_jetbrains_compose_resources_plural_PluralRule_Condition_Or$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_Relation$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources.plural/org_jetbrains_compose_resources_plural_PluralRule_Condition_Relation$stableprop_getter|org_jetbrains_compose_resources_plural_PluralRule_Condition_Relation$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources.vector.xmldom/org_jetbrains_compose_resources_vector_xmldom_MalformedXMLException$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources.vector.xmldom/org_jetbrains_compose_resources_vector_xmldom_MalformedXMLException$stableprop_getter|org_jetbrains_compose_resources_vector_xmldom_MalformedXMLException$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/Font(org.jetbrains.compose.resources/FontResource, androidx.compose.ui.text.font/FontWeight?, androidx.compose.ui.text.font/FontStyle, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.ui.text.font/Font // org.jetbrains.compose.resources/Font|Font(org.jetbrains.compose.resources.FontResource;androidx.compose.ui.text.font.FontWeight?;androidx.compose.ui.text.font.FontStyle;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/Font(org.jetbrains.compose.resources/FontResource, androidx.compose.ui.text.font/FontWeight?, androidx.compose.ui.text.font/FontStyle, androidx.compose.ui.text.font/FontVariation.Settings?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.ui.text.font/Font // org.jetbrains.compose.resources/Font|Font(org.jetbrains.compose.resources.FontResource;androidx.compose.ui.text.font.FontWeight?;androidx.compose.ui.text.font.FontStyle;androidx.compose.ui.text.font.FontVariation.Settings?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/getResourceUri(kotlin/String): kotlin/String // org.jetbrains.compose.resources/getResourceUri|getResourceUri(kotlin.String){}[0]
+final fun org.jetbrains.compose.resources/getSystemResourceEnvironment(): org.jetbrains.compose.resources/ResourceEnvironment // org.jetbrains.compose.resources/getSystemResourceEnvironment|getSystemResourceEnvironment(){}[0]
+final fun org.jetbrains.compose.resources/imageResource(org.jetbrains.compose.resources/DrawableResource, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.ui.graphics/ImageBitmap // org.jetbrains.compose.resources/imageResource|imageResource(org.jetbrains.compose.resources.DrawableResource;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_DrawableResource$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_DrawableResource$stableprop_getter|org_jetbrains_compose_resources_DrawableResource$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_FontResource$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_FontResource$stableprop_getter|org_jetbrains_compose_resources_FontResource$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Bitmap$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Bitmap$stableprop_getter|org_jetbrains_compose_resources_ImageCache_Bitmap$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Svg$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Svg$stableprop_getter|org_jetbrains_compose_resources_ImageCache_Svg$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Vector$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ImageCache_Vector$stableprop_getter|org_jetbrains_compose_resources_ImageCache_Vector$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_LanguageQualifier$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_LanguageQualifier$stableprop_getter|org_jetbrains_compose_resources_LanguageQualifier$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_MissingResourceException$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_MissingResourceException$stableprop_getter|org_jetbrains_compose_resources_MissingResourceException$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_PluralStringResource$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_PluralStringResource$stableprop_getter|org_jetbrains_compose_resources_PluralStringResource$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_RegionQualifier$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_RegionQualifier$stableprop_getter|org_jetbrains_compose_resources_RegionQualifier$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_Resource$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_Resource$stableprop_getter|org_jetbrains_compose_resources_Resource$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceCaches$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceCaches$stableprop_getter|org_jetbrains_compose_resources_ResourceCaches$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceEnvironment$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceEnvironment$stableprop_getter|org_jetbrains_compose_resources_ResourceEnvironment$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceItem$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ResourceItem$stableprop_getter|org_jetbrains_compose_resources_ResourceItem$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_ScriptQualifier$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_ScriptQualifier$stableprop_getter|org_jetbrains_compose_resources_ScriptQualifier$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringArrayResource$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringArrayResource$stableprop_getter|org_jetbrains_compose_resources_StringArrayResource$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Array$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Array$stableprop_getter|org_jetbrains_compose_resources_StringItem_Array$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Plurals$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Plurals$stableprop_getter|org_jetbrains_compose_resources_StringItem_Plurals$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Value$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringItem_Value$stableprop_getter|org_jetbrains_compose_resources_StringItem_Value$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringResource$stableprop_getter(): kotlin/Int // org.jetbrains.compose.resources/org_jetbrains_compose_resources_StringResource$stableprop_getter|org_jetbrains_compose_resources_StringResource$stableprop_getter(){}[0]
+final fun org.jetbrains.compose.resources/painterResource(org.jetbrains.compose.resources/DrawableResource, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.ui.graphics.painter/Painter // org.jetbrains.compose.resources/painterResource|painterResource(org.jetbrains.compose.resources.DrawableResource;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/pluralStringResource(org.jetbrains.compose.resources/PluralStringResource, kotlin/Int, androidx.compose.runtime/Composer?, kotlin/Int): kotlin/String // org.jetbrains.compose.resources/pluralStringResource|pluralStringResource(org.jetbrains.compose.resources.PluralStringResource;kotlin.Int;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/pluralStringResource(org.jetbrains.compose.resources/PluralStringResource, kotlin/Int, kotlin/Array<out kotlin/Any>..., androidx.compose.runtime/Composer?, kotlin/Int): kotlin/String // org.jetbrains.compose.resources/pluralStringResource|pluralStringResource(org.jetbrains.compose.resources.PluralStringResource;kotlin.Int;kotlin.Array<out|kotlin.Any>...;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/rememberResourceEnvironment(androidx.compose.runtime/Composer?, kotlin/Int): org.jetbrains.compose.resources/ResourceEnvironment // org.jetbrains.compose.resources/rememberResourceEnvironment|rememberResourceEnvironment(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/stringArrayResource(org.jetbrains.compose.resources/StringArrayResource, androidx.compose.runtime/Composer?, kotlin/Int): kotlin.collections/List<kotlin/String> // org.jetbrains.compose.resources/stringArrayResource|stringArrayResource(org.jetbrains.compose.resources.StringArrayResource;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/stringResource(org.jetbrains.compose.resources/StringResource, androidx.compose.runtime/Composer?, kotlin/Int): kotlin/String // org.jetbrains.compose.resources/stringResource|stringResource(org.jetbrains.compose.resources.StringResource;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/stringResource(org.jetbrains.compose.resources/StringResource, kotlin/Array<out kotlin/Any>..., androidx.compose.runtime/Composer?, kotlin/Int): kotlin/String // org.jetbrains.compose.resources/stringResource|stringResource(org.jetbrains.compose.resources.StringResource;kotlin.Array<out|kotlin.Any>...;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun org.jetbrains.compose.resources/vectorResource(org.jetbrains.compose.resources/DrawableResource, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.ui.graphics.vector/ImageVector // org.jetbrains.compose.resources/vectorResource|vectorResource(org.jetbrains.compose.resources.DrawableResource;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final suspend fun org.jetbrains.compose.resources/getDrawableResourceBytes(org.jetbrains.compose.resources/ResourceEnvironment, org.jetbrains.compose.resources/DrawableResource): kotlin/ByteArray // org.jetbrains.compose.resources/getDrawableResourceBytes|getDrawableResourceBytes(org.jetbrains.compose.resources.ResourceEnvironment;org.jetbrains.compose.resources.DrawableResource){}[0]
+final suspend fun org.jetbrains.compose.resources/getFontResourceBytes(org.jetbrains.compose.resources/ResourceEnvironment, org.jetbrains.compose.resources/FontResource): kotlin/ByteArray // org.jetbrains.compose.resources/getFontResourceBytes|getFontResourceBytes(org.jetbrains.compose.resources.ResourceEnvironment;org.jetbrains.compose.resources.FontResource){}[0]
+final suspend fun org.jetbrains.compose.resources/getPluralString(org.jetbrains.compose.resources/PluralStringResource, kotlin/Int): kotlin/String // org.jetbrains.compose.resources/getPluralString|getPluralString(org.jetbrains.compose.resources.PluralStringResource;kotlin.Int){}[0]
+final suspend fun org.jetbrains.compose.resources/getPluralString(org.jetbrains.compose.resources/PluralStringResource, kotlin/Int, kotlin/Array<out kotlin/Any>...): kotlin/String // org.jetbrains.compose.resources/getPluralString|getPluralString(org.jetbrains.compose.resources.PluralStringResource;kotlin.Int;kotlin.Array<out|kotlin.Any>...){}[0]
+final suspend fun org.jetbrains.compose.resources/getPluralString(org.jetbrains.compose.resources/ResourceEnvironment, org.jetbrains.compose.resources/PluralStringResource, kotlin/Int): kotlin/String // org.jetbrains.compose.resources/getPluralString|getPluralString(org.jetbrains.compose.resources.ResourceEnvironment;org.jetbrains.compose.resources.PluralStringResource;kotlin.Int){}[0]
+final suspend fun org.jetbrains.compose.resources/getPluralString(org.jetbrains.compose.resources/ResourceEnvironment, org.jetbrains.compose.resources/PluralStringResource, kotlin/Int, kotlin/Array<out kotlin/Any>...): kotlin/String // org.jetbrains.compose.resources/getPluralString|getPluralString(org.jetbrains.compose.resources.ResourceEnvironment;org.jetbrains.compose.resources.PluralStringResource;kotlin.Int;kotlin.Array<out|kotlin.Any>...){}[0]
+final suspend fun org.jetbrains.compose.resources/getString(org.jetbrains.compose.resources/ResourceEnvironment, org.jetbrains.compose.resources/StringResource): kotlin/String // org.jetbrains.compose.resources/getString|getString(org.jetbrains.compose.resources.ResourceEnvironment;org.jetbrains.compose.resources.StringResource){}[0]
+final suspend fun org.jetbrains.compose.resources/getString(org.jetbrains.compose.resources/ResourceEnvironment, org.jetbrains.compose.resources/StringResource, kotlin/Array<out kotlin/Any>...): kotlin/String // org.jetbrains.compose.resources/getString|getString(org.jetbrains.compose.resources.ResourceEnvironment;org.jetbrains.compose.resources.StringResource;kotlin.Array<out|kotlin.Any>...){}[0]
+final suspend fun org.jetbrains.compose.resources/getString(org.jetbrains.compose.resources/StringResource): kotlin/String // org.jetbrains.compose.resources/getString|getString(org.jetbrains.compose.resources.StringResource){}[0]
+final suspend fun org.jetbrains.compose.resources/getString(org.jetbrains.compose.resources/StringResource, kotlin/Array<out kotlin/Any>...): kotlin/String // org.jetbrains.compose.resources/getString|getString(org.jetbrains.compose.resources.StringResource;kotlin.Array<out|kotlin.Any>...){}[0]
+final suspend fun org.jetbrains.compose.resources/getStringArray(org.jetbrains.compose.resources/ResourceEnvironment, org.jetbrains.compose.resources/StringArrayResource): kotlin.collections/List<kotlin/String> // org.jetbrains.compose.resources/getStringArray|getStringArray(org.jetbrains.compose.resources.ResourceEnvironment;org.jetbrains.compose.resources.StringArrayResource){}[0]
+final suspend fun org.jetbrains.compose.resources/getStringArray(org.jetbrains.compose.resources/StringArrayResource): kotlin.collections/List<kotlin/String> // org.jetbrains.compose.resources/getStringArray|getStringArray(org.jetbrains.compose.resources.StringArrayResource){}[0]
+final suspend fun org.jetbrains.compose.resources/readResourceBytes(kotlin/String): kotlin/ByteArray // org.jetbrains.compose.resources/readResourceBytes|readResourceBytes(kotlin.String){}[0]

components/resources/components-resources/build.gradle.kts

@@ -0,0 +1,60 @@
+// :components-resources - the official Compose Multiplatform resources runtime
+// (org.jetbrains.compose.components:components-resources), vendored because the
+// Maven artifact ships no mingwX64/linux klibs. Public API is byte-for-byte
+// upstream (painterResource / stringResource / Font / qualifiers / Res codegen
+// compatibility); the platform actuals are this port's: data.kres reading,
+// image decode via :ui's Skia decoder, SDL locale/theme environment. Apps' JVM
+// targets keep using the official Maven artifact - this module is native-only.
+
+plugins {
+	alias(libs.plugins.kotlin.multiplatform)
+	alias(libs.plugins.kotlin.plugin.compose)
+}
+
+repositories {
+	google()
+	mavenCentral()
+	maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
+}
+
+val vHostSupportsMingw = rootProject.extra["vHostSupportsMingw"] as Boolean
+
+kotlin {
+	linuxArm64()
+	linuxX64()
+	macosArm64()
+	if (vHostSupportsMingw) mingwX64()
+
+	applyDefaultHierarchyTemplate()
+
+	sourceSets {
+		commonMain {
+			kotlin.srcDir("src/vendor/common/kotlin")
+			dependencies {
+				// foundation (isSystemInDarkTheme in ResourceEnvironment) pulls the
+				// whole ui surface + loadComposeResourceBytes + the sdl3 cinterop
+				// types transitively (all edges are api).
+				api(project(":compose:foundation:foundation"))
+				implementation(libs.kotlinx.coroutines.core)
+			}
+		}
+		nativeMain {
+			kotlin.srcDir("src/vendor/native/kotlin")
+			// src/nativeMain/kotlin also holds the Font / Image resource actuals -
+			// pure project code that delegates to the project font registry
+			// (IconFont / NamedFont) and the :ui-graphics Skia decoder
+			// (decodeEncodedImageBitmap). Skiko-free, so a single native set covers
+			// every target.
+		}
+	}
+
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			// Upstream's library build opts the whole module into its own
+			// annotations; the vendored files rely on that.
+			"-opt-in=org.jetbrains.compose.resources.InternalResourceApi",
+			"-opt-in=org.jetbrains.compose.resources.ExperimentalResourceApi",
+		)
+	}
+}

components/resources/components-resources/compose-fork.txt

@@ -1,13 +1,13 @@
-# Files vendored VERBATIM from JetBrains/compose-multiplatform (the umbrella repo —
+# Files vendored VERBATIM from JetBrains/compose-multiplatform (the umbrella repo -
 # NOT compose-multiplatform-core) into :components-resources. The official
 # org.jetbrains.compose.components:components-resources artifact publishes NO
 # mingwX64/linux variants, so the runtime library is vendored and the platform
 # actuals are project code:
-#   src/nativeMain      — ResourceReader (data.kres), getSystemEnvironment (SDL),
-#                         pure-Kotlin DomXmlParser (upstream's is Darwin NSXMLParser)
-#   src/sdlRendererMain — image decode via the :ui SDL3_image hook, SVG unsupported,
-#                         Font via the project font registry
-#   vendor/skikoRenderer — upstream skikoMain Skia-bound files, verbatim
+#   src/nativeMain      - ResourceReader (data.kres), getSystemEnvironment (SDL),
+#                         pure-Kotlin DomXmlParser (upstream's is Darwin NSXMLParser),
+#                         and the Font/Image resource actuals: renderer-agnostic
+#                         project code (image decode via the :ui-graphics Skia
+#                         decoder, Font via the project font registry)
 # Re-sync: python scripts/compose-fork/sync.py components/resources/library
 
 SET_REPO=https://github.com/JetBrains/compose-multiplatform@<COMPOSE_REF>
@@ -43,21 +43,20 @@ blockingMain/kotlin/ -> src/vendor/native/kotlin/
 nativeMain/kotlin/ -> src/vendor/native/kotlin/
 #     | nativeMain/kotlin/org/jetbrains/compose/resources/ImageResources.native.kt -> src/vendor/native/kotlin/org/jetbrains/compose/resources/ImageResources.native.kt
 #     | nativeMain/kotlin/org/jetbrains/compose/resources/vector/xmldom/DomXmlParser.kt -> src/vendor/native/kotlin/org/jetbrains/compose/resources/vector/xmldom/DomXmlParser.kt
-# Darwin-only (Foundation NSXMLParser) — replaced by a pure-Kotlin project parser
+# Darwin-only (Foundation NSXMLParser) - replaced by a pure-Kotlin project parser
 # in src/nativeMain so mingwX64/linux compile.
 !nativeMain/kotlin/org/jetbrains/compose/resources/vector/xmldom/DomXmlParser.kt
 
-# Portable pieces of upstream skikoMain (no Skia references — pure delegation /
-# runtime-only) — every native target gets them.
+# Portable pieces of upstream skikoMain (no Skia references - pure delegation /
+# runtime-only) - every native target gets them.
 skikoMain/kotlin/org/jetbrains/compose/resources/ImageDecoders.skiko.kt -> src/vendor/native/kotlin/org/jetbrains/compose/resources/ImageDecoders.skiko.kt
 skikoMain/kotlin/org/jetbrains/compose/resources/ResourceReader.skiko.kt -> src/vendor/native/kotlin/org/jetbrains/compose/resources/ResourceReader.skiko.kt
 
-# Skia-bound pieces — upstream's skikoMain actuals rely on Compose-Desktop Skia
+# Skia-bound pieces - upstream's skikoMain actuals rely on Compose-Desktop Skia
 # extensions (SystemFont / toComposeImageBitmap / nativeCanvas) this port's :ui
-# doesn't expose. Since the sdlRenderer actuals (src/sdlRendererMain/kotlin/) use
-# pure project APIs (IconFont / NamedFont / decodeEncodedImageBitmap) that work
-# on either renderer, the module's build shares those with skikoRendererMain
-# instead of vendoring the upstream files. Opt them out of the sync.
+# doesn't expose. The module's own Font/Image actuals (src/nativeMain/kotlin/)
+# use pure project APIs (IconFont / NamedFont / decodeEncodedImageBitmap)
+# instead, so opt the upstream Skia-bound files out.
 !skikoMain/kotlin/org/jetbrains/compose/resources/ImageResources.skiko.kt
 !skikoMain/kotlin/org/jetbrains/compose/resources/FontResources.skiko.kt
 !skikoMain/kotlin/org/jetbrains/compose/resources/SvgPainter.kt

components/resources/components-resources/src/nativeMain/kotlin/org/jetbrains/compose/resources/FontResources.native.kt

@@ -1,5 +1,11 @@
 @file:OptIn(InternalResourceApi::class, ExperimentalResourceApi::class)
 
+// VENDOR-REIMPL(COMPOSE_REF): components/resources/library/src/skikoMain/kotlin/org/jetbrains/compose/resources/FontResources.skiko.kt @ v1.12.0
+// Project REIMPLEMENTATION, not a derived copy: same package + signatures,
+// different body (the port replaces upstream's skiko scene/platform layer).
+// Upstream edits to the counterpart do NOT need reconciling here - re-check
+// only if the expect/actual SIGNATURES change.
+
 package org.jetbrains.compose.resources
 
 import org.jetbrains.compose.resources.InternalResourceApi
@@ -15,16 +21,16 @@ import com.compose.sdl.icons.IconFont
 import com.compose.sdl.text.NamedFont
 
 // ==================
-// MARK: Font actuals — SDL renderer
+// MARK: Font actuals - Skia text stack via the project font registry
 // ==================
 
-/* The SDL text stack resolves fonts by FAMILY NAME through the project font
-   registry (IconFont.registerIcon — the general byte-font table, not just
+/** The Skia text stack resolves fonts by FAMILY NAME through the project font
+   registry (IconFont.registerIcon - the general byte-font table, not just
    icons). A font resource therefore loads its bytes through the resource
    reader, registers them under a per-resource family name, and returns a
-   [NamedFont] — `FontFamily(Font(Res.font.x))` then renders through the
+   [NamedFont] - `FontFamily(Font(Res.font.x))` then renders through the
    standard project pipeline. Weight/style are carried on the NamedFont;
-   variation axes apply at draw time via the renderer's axis support. */
+   variation axes apply at draw time via Skia's axis support. */
 
 private val emptyFont: Font = NamedFont("res-font:<loading>")
 

components/resources/components-resources/src/nativeMain/kotlin/org/jetbrains/compose/resources/ImageResources.native.kt

@@ -0,0 +1,86 @@
+@file:OptIn(InternalResourceApi::class, ExperimentalResourceApi::class)
+
+// VENDOR-REIMPL(COMPOSE_REF): components/resources/library/src/skikoMain/kotlin/org/jetbrains/compose/resources/ImageResources.skiko.kt @ v1.12.0
+// Project REIMPLEMENTATION, not a derived copy: same package + signatures,
+// different body (the port replaces upstream's skiko scene/platform layer).
+// Upstream edits to the counterpart do NOT need reconciling here - re-check
+// only if the expect/actual SIGNATURES change.
+
+package org.jetbrains.compose.resources
+
+import org.jetbrains.compose.resources.InternalResourceApi
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.IntSize
+import com.compose.sdl.graphics.decodeEncodedImageBitmap
+import com.compose.sdl.graphics.decodeSvgAt
+import com.compose.sdl.graphics.svgIntrinsicSize
+import kotlin.math.roundToInt
+
+// ==================
+// MARK: Image actuals - Skia decode via the :ui-graphics hook
+// ==================
+
+/** Decoding goes through the :ui-graphics Skia hook the SDL backend registers
+   at init (decodeEncodedImageBitmap). resourceDensity/targetDensity are ignored:
+   under this port's Option-B density flow layout runs in physical pixels and
+   drawables ship at a single density, so no decode-time rescale applies. */
+internal actual fun ByteArray.toImageBitmap(resourceDensity: Int, targetDensity: Int): ImageBitmap =
+	decodeEncodedImageBitmap(this)
+		?: error("Image decode failed - is the render backend initialised before painterResource ran?")
+
+/** SVG element = the raw document bytes; rendering is size-driven (see SvgPainter). */
+internal actual class SvgElement(val bytes: ByteArray)
+
+internal actual fun ByteArray.toSvgElement(): SvgElement = SvgElement(this)
+
+/** Resolution-independent SVG painter: reports the document's intrinsic size for
+   layout, but RE-RASTERISES the vector at the actual draw size each time the draw
+   size changes (1-entry size cache), so a scaled-up SVG stays crisp instead of
+   upscaling one intrinsic-size bitmap. Mirrors upstream desktop's SVGPainter. */
+internal actual fun SvgElement.toSvgPainter(density: Density): Painter = SvgPainter(bytes)
+
+private class SvgPainter(private val bytes: ByteArray) : Painter() {
+
+	override val intrinsicSize: Size = svgIntrinsicSize(bytes) ?: Size.Unspecified
+
+	private var fAlpha: Float = 1f
+	private var fColorFilter: ColorFilter? = null
+	private var fCacheKey: Long = -1L
+	private var fCacheBitmap: ImageBitmap? = null
+
+	override fun applyAlpha(alpha: Float): Boolean { fAlpha = alpha; return true }
+	override fun applyColorFilter(colorFilter: ColorFilter?): Boolean { fColorFilter = colorFilter; return true }
+
+	private fun rasterFor(inWidthPx: Int, inHeightPx: Int): ImageBitmap? {
+		val vKey = (inWidthPx.toLong() shl 32) or inHeightPx.toLong()
+		if (vKey == fCacheKey && fCacheBitmap != null) return fCacheBitmap
+		val vBitmap = decodeSvgAt(bytes, inWidthPx, inHeightPx) ?: return null
+		fCacheKey = vKey
+		fCacheBitmap = vBitmap
+		return vBitmap
+	}
+
+	override fun DrawScope.onDraw() {
+		val vWpx = size.width.roundToInt()
+		val vHpx = size.height.roundToInt()
+		if (vWpx <= 0 || vHpx <= 0) return
+		val vBitmap = rasterFor(vWpx, vHpx) ?: return
+		drawImage(
+			vBitmap,
+			srcOffset = IntOffset.Zero,
+			srcSize = IntSize(vBitmap.width, vBitmap.height),
+			dstOffset = IntOffset.Zero,
+			dstSize = IntSize(vWpx, vHpx),
+			alpha = fAlpha,
+			colorFilter = fColorFilter,
+		)
+	}
+}

components/resources/components-resources/src/nativeMain/kotlin/org/jetbrains/compose/resources/ResourceEnvironment.native.kt

@@ -0,0 +1,33 @@
+@file:OptIn(InternalResourceApi::class, ExperimentalResourceApi::class)
+
+package org.jetbrains.compose.resources
+
+import org.jetbrains.compose.resources.InternalResourceApi
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import com.compose.sdl.res.preferredLocaleProvider
+import com.compose.sdl.res.systemThemeIsDarkProvider
+
+// ==================
+// MARK: ResourceEnvironment - platform-env-seam actual
+// ==================
+
+/** Non-composable system environment for qualifier resolution (values-fr,
+   drawable-dark, …): locale + theme come from the platform-env seams installed
+   by the SDL layer, so :components-resources carries no dependency on the sdl3
+   cinterop. Density is reported as 1f - under this port's Option-B density flow
+   layout runs in physical pixels and drawables are bundled at a single density,
+   so the mdpi bucket is always the right one. The COMPOSABLE path
+   (rememberResourceEnvironment) doesn't use this: it reads LocalDensity /
+   isSystemInDarkTheme from the composition. */
+internal actual fun getSystemEnvironment(): ResourceEnvironment {
+	val (vLanguage, vRegion) = preferredLocaleProvider?.invoke() ?: ("" to "")
+	val vDark = systemThemeIsDarkProvider?.invoke() ?: false
+	return ResourceEnvironment(
+		language = LanguageQualifier(vLanguage),
+		// SDL locales carry language+country only - no script subtag.
+		script = ScriptQualifier(""),
+		region = RegionQualifier(vRegion),
+		theme = ThemeQualifier.selectByValue(isDark = vDark),
+		density = DensityQualifier.selectByDensity(1f),
+	)
+}