feat(bridge): expose the material3-adaptive version to consumers

material3-adaptive rides its own release train upstream (1.3.0-rc01), like material3 does, so a consumer had no way to express its version through the plugin - they would have had to hardcode a number and keep it in sync with the port by hand. Adds composeDesktopNative.composeMaterial3Adaptive alongside the existing compose / composeMaterial3 / composeRuntime accessors, stamped into bridge-version.properties from the version catalog like the others. The README consumer snippet now shows the adaptive coordinates, and calls out that window-core has to be declared DIRECTLY when commonMain touches WindowSizeClass - substituted modules hide their transitives from the common metadata classpath.
feat(demo): make the Adaptive screen fold on a live resize
2026-10-07 03:37:26 +00:00 · 2026-09-22 16:52:25 +02:00 · 2026-09-22 16:46:57 +02:00 · 2026-09-22 16:07:23 +02:00 · 2026-09-22 15:51:26 +02:00 · 2026-09-22 15:48:21 +02:00
214 changed files with 9382 additions and 3432 deletions
@@ -64,3 +64,4 @@ __pycache__/

 # Probe artifacts written to the repo root by demo --nav3test / --searchesctest / --dialoganimtest
 /*.bmp
+/local.properties
@@ -38,8 +38,8 @@ Rendering is **Skia everywhere** behind one `RenderBackend` - Metal / OpenGL
 - **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 GitHub Packages as
-  `com.bitsycore.skiko:skiko:0.150.1-mingw.1` (override with
+  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`).

@@ -57,59 +57,83 @@ Library modules mirror upstream Compose Multiplatform's `compose/` tree.
 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/window/`. `:ui` depends on `:sdl-core` and its renderer
+`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.* CORE (Modifier, LayoutNode,
+│   ├── 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/                 → :ui-graphics - androidx.compose.ui.graphics.* + the Skia actuals
+│   ├── 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/                     → :ui-text   - androidx.compose.ui.text.* + the skiko text engine
+│   ├── 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/                     → :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-tooling-preview/          → :ui-tooling-preview - androidx.compose.ui.tooling.preview.*
+│   ├── 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.*
+│   └── adaptive/                    → the material3-adaptive family, VENDORED VERBATIM.
+│       │                              org.jetbrains.compose.material3.adaptive:* publishes
+│       │                              ios + macosArm64 ONLY - no linux, no mingw (issue #4).
+│       │                              Nothing in the sources blocks those targets: every
+│       │                              actual the native legs need already exists upstream
+│       │                              (nonAndroidMain / skikoMain / nativeMain), and the one
+│       │                              real dependency, androidx.window:window-core, ALREADY
+│       │                              publishes linux + mingw + macos. The artifacts were
+│       │                              missing purely because upstream never enabled the
+│       │                              targets - so this port is vendor-only, ZERO source
+│       │                              edits. Upstream's skikoMain (the ~75 l10n tables +
+│       │                              Strings / drag-handle actuals) lands in src/vendor/
+│       │                              native/ next to upstream's own nativeMain actuals;
+│       │                              they actualise disjoint expects so they coexist.
+│       │                              com.bitsycore.compose.material3.adaptive:<module>.
+│       ├── adaptive/                → :compose:material3:adaptive:adaptive  - WindowAdaptiveInfo /
+│       │                              Posture / window size class. api-exposes window-core.
+│       ├── adaptive-layout/         → :compose:material3:adaptive:adaptive-layout - ListDetail /
+│       │                              SupportingPane / ThreePane scaffolds + pane motion
+│       ├── adaptive-navigation/     → :compose:material3:adaptive:adaptive-navigation -
+│       │                              ThreePaneScaffoldNavigator + back behaviour
+│       └── adaptive-navigation3/    → :compose:material3:adaptive:adaptive-navigation3 -
+│                                      SceneStrategy bindings for nav3 (→ :navigation3-ui)
 ├── material/
-│   └── material-ripple/             → :material-ripple - androidx.compose.material.ripple.*
-└── desktop/native/window/           → :desktop-native-window - nativeComposeApp { Window(...) {} }
+│   └── 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-core   - the NAKED sdl3 cinterop + platform primitives
+└── 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
+└── 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
@@ -127,7 +151,7 @@ utils/
                                                    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
@@ -140,8 +164,60 @@ components/
                                                    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.compose.desktop.native
+                                                    .pulse:<module>, NOT upstream's com.bitsycore.lib:
+                                                    <module>. Pulse is the one vendored dep that is
+                                                    ITSELF a com.bitsycore library, so the republish is
+                                                    namespaced under this project rather than a bare
+                                                    com.bitsycore.pulse that would read like upstream;
+                                                    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
@@ -206,14 +282,37 @@ libs/                → gitignored per-host static SDL3 output of
                      scripts/build-sdl/build-all.py on Windows
 ```

-Module PATHS stay short (`:ui`, `:foundation`, `:desktop-native-window`, …) -
-`settings.gradle.kts` redirects `projectDir` for each so build files across
-the repo stay terse. `androidx.collection` is a plain Maven dependency
+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  ←──────────────────────┘   ↑              ↑
@@ -232,6 +331,14 @@ sees the split modules. Full DAG: `:ui-util → collection`; `:ui-geometry → :
 `:foundation → :animation, :foundation-layout, :animation-core, :ui`;
 `:material-ripple → :foundation, :animation-core`;
 `:material3 → :foundation, :material-ripple, :animation-core, :foundation-layout`.
+The adaptive family sits beside material3 rather than under it - it depends on
+`:ui` / `:foundation` / `:animation-core`, NOT on `:material3`:
+`:adaptive → :ui, :foundation, window-core`;
+`:adaptive-layout → :adaptive, :ui, :animation-core, :animation, :foundation,
+:foundation-layout, :ui-geometry, collection, window-core`;
+`:adaptive-navigation → :adaptive-layout, :foundation, :ui-util`;
+`:adaptive-navigation3 → :adaptive-navigation, :navigation3-ui, collection,
+navigationevent-compose`.

 `: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
@@ -312,8 +419,17 @@ Two categories of code live in each module:
   // VENDOR-BASE(COMPOSE_REF): <path> @ <tag>     ← for umbrella-repo files
   ```

-   `scripts/compose-fork/check-vendor-drift.py` reads these at every ref
-   bump: it flags any file whose recorded base lags the current pin and
+   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
@@ -414,8 +530,8 @@ Passing raw `px.dp` will double-scale on Retina.
 ./gradlew :apidemo:runDebugExecutableLinuxX64

 # Windows (from Windows - mingw cross-build from macOS/Linux fails at cinterop).
-# Links the bitsycore skiko FORK from GitHub Packages (com.bitsycore.skiko:skiko:
-# 0.150.1-mingw.1, override -PskikoMingwVersion); the bridge plugin drops
+# 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
@@ -472,8 +588,12 @@ executable, loaded via `SDL_GetBasePath()`). Contents:
 scripts/compose-fork/sync.sh
 ```

-Upstream ref: `scripts/compose-fork/compose.properties` - set to a durable tag
-of `JetBrains/compose-multiplatform-core`. Bump the ref → re-sync → let the
+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).
@@ -481,8 +601,18 @@ drift / vendor-clean guardrails are in
 ## Key files by area - start here when you need to find something

 ### Renderer + main loop
- `compose/desktop/native/window/src/nativeMain/…/ComposeWindow.kt` - main loop,
-  recomposer lifecycle, SDL event dispatch, composition-local seeding.
+- `compose/desktop/native/desktop-native-window/src/nativeMain/…/` - the window
+  module, one concern per file:
+  - `ComposeWindow.kt` - the PUBLIC surface (`ApplicationScope`, `Window()`,
+    `nativeComposeApp`, `nativeComposeWindow`) + the main loop.
+  - `WindowInstance.kt` - one SDL window: backend + render backend + root host +
+    its own recomposer/composition, event handling, frame pump, teardown. This is
+    where composition-local seeding lives.
+  - `AppRuntime.kt` - the live-window registry + create/destroy lifecycle.
+  - `WindowAttributes.kt` - the Compose Desktop `Window()` attribute bundle.
+  - `FrameTiming.kt` - deterministic/virtual frame clocks and the
+    probe-quiescence hooks (`disableInfiniteAnimations`, `useVirtualFrameTime`,
+    `windowHasInvalidations`).
 - `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`).
@@ -547,9 +677,23 @@ Open renderer / fidelity / release work is tracked in [PLAN.md](PLAN.md).

 ## Conventions

-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).
+Kotlin standard style for formatting (braces, wrapping, indentation).
+
+Naming, as the code actually is - this paragraph used to claim "no prefixes",
+which had not been true for a long time:
+
+- **`m` for private/protected members** - `mWidth`, `mSurface`, `mCache`. NOT
+  `f`: the `f` prefix was retired across the project, so do not reintroduce it.
+- **`v` for local variables** - `vWindow`, `vResult`.
+- **`in` for function parameters** - `inTitle`, `inWidth`. Note Compose
+  `@Composable` parameters are the exception: they stay plain, because the name
+  is part of the call-site API (`title = `, `onCloseRequest = `).
+- **`k` for private file-level constants** - `kMaxFrames`, `kIsWindows`.
+- Public API surface is plain `camelCase` - prefixes are for implementation
+  detail only, and nothing prefixed should ever reach the klib dump.
+
+VENDORED code under `src/vendor/` follows UPSTREAM's naming, untouched - it is
+copied byte-for-byte, so never re-prefix anything in it.

 Section headers inside a file, when useful:

@@ -640,8 +784,29 @@ Verified in-tree (api-exposed by `:ui` unless noted):
 - `androidx.navigationevent:navigationevent-compose` 1.1.2 - predictive-back
  event plumbing (BackHandler, NavDisplay gestures).
 - `androidx.collection:collection` - plain Maven dep, not a module.
+- `androidx.window:window-core` **1.5.0** - WindowSizeClass / the adaptive
+  window model. Publishes mingwX64 + linux + macos under BOTH coordinate sets;
+  the port takes the google one like the rest of the androidx stack. This is
+  what makes the material3-adaptive vendoring a pure re-target: the dependency
+  everybody assumed was the blocker was never missing.
+- `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`.

@@ -651,7 +816,7 @@ Caveats that make these work here (all already wired - listed so nobody
 - The google `LocalViewModelStoreOwner` / `LocalSavedStateRegistryOwner` /
  `LocalLifecycleOwner` are PLAIN composition locals - the JB HostDefault
  mechanism (`compositionLocalWithHostDefaultOf`) does not exist in google
-  artifacts. `WindowArchitectureOwner` (ComposeWindow.kt) provides all three
+  artifacts. `WindowArchitectureOwner` (WindowInstance.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).
@@ -103,7 +103,7 @@ 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.1` (override `-PskikoMingwVersion`).
+  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
@@ -172,7 +172,7 @@ All Windows divergences live **below Kotlin** - the mingw source set reuses
 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.1`) and its GN args are **not verifiable from this
+`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
@@ -371,7 +371,7 @@ macOS↔Windows delta is expected upstream behavior.
      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.1` GN args. **REMAINING:** whoever
+      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.
@@ -391,21 +391,21 @@ 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`)
+  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`) →
+  SDL right-click → `PointerButton.Secondary` (`AppEvent.kt`) →
      `isSecondaryPressed` (`PointerEventBridge`). The three "NOP" seams belong to the
-      DISABLED *new* context-menu API and are unreachable - **DONE:** their misleading
+  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).
+  **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" /
@@ -417,14 +417,14 @@ re-vendoring.** The debt is **completing native-actual stubs**.
      (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
+- [x] **P0** Float pointer coordinates - `AppEvent.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
+  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.
+  by grep). Builds + runs clean on macosArm64.

 ### P1 - quality / parity

@@ -521,7 +521,7 @@ re-vendoring.** The debt is **completing native-actual stubs**.
 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`).
+**`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-
@@ -554,7 +554,7 @@ joystick.
      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
+      `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.**

@@ -727,6 +727,30 @@ A read-only feasibility map (no code changed) found two layers:
 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).

+### 7c. `demo --multiwintest` segfault on mingwX64 - ✅ FIXED
+
+The multi-window probe exited 139 with no output, so it had silently been
+asserting nothing. Root cause: an OpenGL context is per-WINDOW but "current" is
+per-THREAD, and `SDL_GL_MakeCurrent` ran only once at creation
+(`Sdl3Backend.init`) with nothing re-binding it per frame. With two windows open,
+whichever initialised last owned the thread - so window A issued its draw and
+swap against window B's context (silent corruption while both lived), and
+destroying B left the current context dangling, faulting in `present()`.
+
+Fixed in `SkiaGLBridge` by binding the window's own context at every entry point
+that touches GL: `init`, `ensureSize` (before its unchanged-size early return -
+this is the per-frame bind that covers the draw phase), `present`, and `destroy`
+(so a window frees its GPU objects against its own context). Purely additive, 29
+lines.
+
+Single-window rendering is bit-identical before and after (same mean RGB
+[46.6 44.4 51.5] and 167 distinct colours on the Buttons screenshot), which is
+expected: SDL short-circuits a redundant bind. `--multiwintest` now PASSes.
+
+NOTE the multi-window path was never correct, not just at teardown - two live
+windows were sharing one context. Anything that looked like flicker or
+cross-window corruption before this is explained by it.
+
 ## Accepted 1.0.0 gaps (documented, not fixed)

 Drag-OUT of window (SDL platform limit; drop-IN works), full accessibility pipeline (out of
@@ -734,3 +758,209 @@ scope for desktop 1.0 - but ship the non-throwing `PlatformScreenReader` no-op),
 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).
+
+## 8. material3-adaptive ported to desktop native (2026-09-22) - ✅ LANDED
+
+Asked for in [issue #4](https://github.com/bitsycore/compose-desktop-native/issues/4):
+`org.jetbrains.compose.material3.adaptive:*` 1.3.0-rc01 publishes `ios_arm64
+ios_simulator_arm64 macos_arm64` and nothing else - no linux, no mingw. (It DOES
+carry macosArm64, which answers the reporter's open question.)
+
+**The port needed zero source edits.** Two things made it a pure re-target:
+
+1. Every platform actual the native legs want already exists upstream -
+   `adaptive/nonAndroidMain` (`calculatePosture`), `adaptive-layout/skikoMain`
+   (the ~75 l10n tables + `Strings` + the drag handle) and
+   `adaptive-layout/nativeMain` (`identityHashCode`, `isGraphicsLayerElement`).
+2. `androidx.window:window-core` - the dependency `adaptive` api-exposes, and the
+   obvious suspect for why the artifacts stop at apple - has published
+   `linux_x64 linux_arm64 mingw_x64 macos_arm64` klibs all along, under BOTH the
+   google and jetbrains coordinates.
+
+So the artifacts were missing purely because upstream never enabled the targets.
+
+**Landed** as four modules under `compose/material3/adaptive/`
+(`com.bitsycore.compose.material3.adaptive:*`), 125 files vendored verbatim off the
+existing `COMPOSE_CORE_REF` pin - no new SET_REPO. Upstream's `skikoMain` lands in
+`src/vendor/native/` beside upstream's own `nativeMain`; they actualise disjoint
+expects so they share one source set. Both bridges substitute all four. `demo --screen=Adaptive` renders a
+`ListDetailPaneScaffold`, and `demo --adaptivetest` drives one window
+wide -> narrow -> wide and asserts the scaffold folds and unfolds, which is what
+actually proves the resize chain end to end (SDL resize -> the owner's
+snapshot-backed containerSize -> recomposition -> BoxWithConstraints re-measure ->
+a new PaneScaffoldDirective -> a new scaffold value).
+
+The demo screen computes its directive from the width IT gets rather than taking
+the `rememberListDetailPaneScaffoldNavigator` default, which is the window size
+class: the shell spends 190dp on the sidebar plus 48dp of padding, so defaulting
+folds ~240dp too late and leaves two panes in a region already too cramped for
+them. Pane-hosting apps that are not full-window should do the same.
+
+One wrinkle worth remembering, and a textbook case of the granular-metadata trap
+already documented in CLAUDE.md: because `adaptive` is SUBSTITUTED on native
+configs, KGP drops its transitives from the commonMain metadata classpath, so the
+shared demo screen could not see `WindowSizeClass` until `window-core` was declared
+DIRECTLY in `demo`'s commonMain.
+
+Not yet exercised: `adaptive-navigation3` builds and dumps API but has no demo
+screen - the nav3 SceneStrategy path is unproven at runtime.
+
+## 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.compose.desktop.native.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.
@@ -1,4 +1,4 @@
-[![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
@@ -18,6 +18,9 @@ executable for macOS (arm64), Linux (x64/arm64), and Windows (mingwX64), using
 - **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`.
@@ -68,13 +71,30 @@ 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.

+`Window()` takes the same attributes as Compose Desktop's - `undecorated`,
+`transparent`, `resizable`, `enabled`, `focusable`, `alwaysOnTop`,
+`onPreviewKeyEvent` and `onKeyEvent` - and re-applies them when they change.
+(`transparent` is the one exception: SDL needs it at window-creation time, so it
+is fixed for the window's life.)
+
+When the Compose-level API doesn't reach far enough, drop to SDL directly:
+
+```kotlin
+val handles = window.rawSdlHandles()   // SDL_Window* / SDL_Renderer* / GL / Metal
+handles.window?.let { sdl3.SDL_FlashWindow(it.reinterpret(), SDL_FLASH_BRIEFLY) }
+```
+
+The pointers are a snapshot valid only while the window lives, and which ones
+are non-null depends on the resolved renderer (`glContext` for Skia OpenGL,
+`metalView` for Metal, `renderer` for CPU raster).
+
 ### Building in this repo

 ```kotlin
 commonMain.dependencies {
-    implementation(project(":desktop-native-window")) // window shell + main loop
-    implementation(project(":material3"))        // Material 3 widgets
-    implementation(project(":material-symbols")) // icon-font composables (optional)
+    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)
 }
 ```

@@ -98,23 +118,29 @@ plugins {

 commonMain.dependencies {
    // The plugin exposes the exact Compose versions the port tracks, so you
-    // never hand-match them (material3 is versioned separately upstream).
+    // never hand-match them (material3 and material3-adaptive each ride their
+    // own release train 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}")
+
+    // material3-adaptive, which upstream publishes for apple targets only.
+    // Note adaptive api-exposes androidx.window:window-core - declare it
+    // DIRECTLY if your commonMain touches WindowSizeClass, since substituted
+    // modules hide their transitives from the common metadata classpath.
+    val vAdaptive = composeDesktopNative.composeMaterial3Adaptive
+    implementation("org.jetbrains.compose.material3.adaptive:adaptive:$vAdaptive")
+    implementation("org.jetbrains.compose.material3.adaptive:adaptive-layout:$vAdaptive")
+    implementation("androidx.window:window-core:1.5.0")
 }
 ```

-**Two GitHub Packages repos are needed.** A consumer declares the port's repo
-(`bitsycore/compose-desktop-native`) **and** the skiko fork's (`bitsycore/skiko`).
-The Windows (mingwX64) target renders through the bitsycore skiko fork, and
-GitHub Packages binds each package name to a **single** repository - so
-`com.bitsycore.skiko` can't be mirrored into the port's repo, it stays in its
-own. Scope them with `includeGroup`/`excludeGroup("com.bitsycore.skiko")`
-(macOS/Linux pull the official skiko from Maven Central instead; if you build no
-mingwX64 you can omit the fork repo). The exact `repositories {}` snippet,
-credentials, and version pinning:
+**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
@@ -152,16 +178,123 @@ client certificates.

 ## Modules

-One Gradle module per upstream Compose artifact, mirroring the upstream
-`compose/` tree. The renderer lives in `:ui` and the `sdl3` cinterop in
-`:sdl-core`; `:desktop-native-window` is the SDL integration layer. `:material-symbols`, `:components-resources`, and
-`:navigation3-ui` are project or vendored modules that the official Maven
-artifacts do not cover for Kotlin/Native desktop.
+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. The full module map, dependency graph, and the list of
-compatible artifacts are in [CLAUDE.md](CLAUDE.md).
+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.compose.desktop.native.pulse` |
+| **material3-adaptive** (all four) | ios + macosArm64 only upstream - no linux, no mingw | `com.bitsycore.compose.material3.adaptive` |
+
+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.1 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.1** | The vendored sources are the `v1.12.1` tag of both upstream repos, and the JVM parity leg forces the same version - no dev-build skew. skiko is unchanged at 0.150.1, so the mingwX64 fork still matches its Skia base. |
+| 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.1` | *not forked - the official klibs serve every target* |
+| UI | `org.jetbrains.compose.ui:ui*:1.12.1` | `com.bitsycore.compose.ui:ui*` |
+| Foundation | `org.jetbrains.compose.foundation:foundation*:1.12.1` | `com.bitsycore.compose.foundation:foundation*` |
+| Animation | `org.jetbrains.compose.animation:animation*:1.12.1` | `com.bitsycore.compose.animation:animation*` |
+| Material Ripple | `org.jetbrains.compose.material:material-ripple:1.12.1` | `com.bitsycore.compose.material:material-ripple` |
+| Material3 | `org.jetbrains.compose.material3:material3:1.12.0-alpha03` | `com.bitsycore.compose.material3:material3` |
+| Material3 Adaptive | `org.jetbrains.compose.material3.adaptive:adaptive*:1.3.0-rc01` | `com.bitsycore.compose.material3.adaptive:adaptive*` |
+| Resources | `org.jetbrains.compose.components:components-resources:1.12.1` | `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.1 ships (Jetpack Material3 1.5.0-alpha22).
+material3-adaptive rides a third train again.
+
+**material3-adaptive** (`adaptive`, `adaptive-layout`, `adaptive-navigation`,
+`adaptive-navigation3`) is published upstream for ios and macosArm64 only - no
+linux, no mingw. This port ships all four for every desktop-native target. It
+needed no source changes at all: every platform actual the native legs want is
+already in upstream's `nonAndroidMain` / `skikoMain` / `nativeMain`, and
+`androidx.window:window-core` - the one dependency involved - has published
+linux, mingw and macos klibs the whole time. The artifacts were missing only
+because upstream never turned the targets on. `demo --screen=Adaptive` renders
+a live `ListDetailPaneScaffold`.
+
+### 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.3` | `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.compose.desktop.native.pulse:*` | no desktop-native artifact upstream - and Pulse is itself a `com.bitsycore` library, so the republish is namespaced under this project |
+
+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.1.7` |
+| 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` |

 ## Building

@@ -177,6 +310,10 @@ 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.

+## Support
+
+[Bitsycore's Discord](https://discord.gg/kGnraVAtDR)
+
 ## Documentation

 - [TOOLING.md](TOOLING.md): building the native libs, vendoring, and verification.
@@ -48,15 +48,24 @@ Reach for this after a fresh checkout or a ref bump. Details:
 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/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). Run both on
-every ref bump.
+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

@@ -145,6 +154,7 @@ 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 --adaptivetest    # material3-adaptive folds/unfolds on a LIVE window resize
 demo.kexe --soaktest        # memory soak (CDN_SOAK_SCREEN, CDN_SOAK_STATIC, CDN_SOAK_CYCLES)
 ```

@@ -160,8 +170,8 @@ gradlew.bat :apidemo:runDebugExecutableMingwX64
 ```

 mingwX64 renders through Skia via the **bitsycore skiko fork**, consumed from
-GitHub Packages as `com.bitsycore.skiko:skiko:0.150.1-mingw.1` (macOS/Linux use
-official Skiko). The runtime `skiko-windows-x64.dll` is auto-provisioned next
+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.
@@ -184,8 +194,9 @@ single file to edit; know which axis you are changing.
 |---------|-------|-------|
 | 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. |
-| JVM parity forcing | `vComposeJvmVersion` in `demo`, `apidemo`, and `material-symbols` `build.gradle.kts`. | Must be a version PUBLISHED to Maven Central. It may lag the vendored native ref (a documented skew) until the matching version is published. |
-| Skiko | `skiko` in `gradle/libs.versions.toml`. | macOS/Linux use official Skiko (`org.jetbrains.skiko`); mingwX64 uses the bitsycore fork (`com.bitsycore.skiko:skiko:0.150.1-mingw.1` from GitHub Packages), 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. |
+| 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.1 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. |

@@ -193,12 +204,17 @@ single file to edit; know which axis you are changing.

 Run this on each upstream bump; it is the flow that keeps the sync tax low.

-1. Edit `COMPOSE_CORE_REF` / `COMPOSE_REF` in `compose.properties` (and `compose`
-   in `libs.versions.toml` if the coordinate version moved).
+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.
+   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
@@ -68,7 +68,7 @@ kotlin {
                implementation("org.jetbrains.compose.material3:material3:$vComposeM3JvmVersion")

                // Common Material Symbols Utility
-                implementation(project(":material-symbols"))
+                implementation(project(":utils:material-symbols"))

                implementation(libs.ktor.client.core)
                implementation(libs.ktor.client.content.negotiation)
@@ -81,13 +81,17 @@ kotlin {
        }
        nativeMain {
            dependencies {
-                implementation(project(":desktop-native-window"))
+                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)
            }
@@ -915,7 +915,13 @@ internal fun App() {
    val vExtended = if (vDark) vPalette.scheme.darkExtended else vPalette.scheme.lightExtended
    val vC = appColorsFromScheme(vScheme)

-    MaterialTheme(colorScheme = vScheme) {
+    // PARITY: pin the default text family to the bundled NotoSans on BOTH stacks.
+    // Left alone, native resolves FontFamily.Default to the bundled font while the
+    // JVM leg resolves it to a system face, so every un-familied Text was being
+    // compared against a different typeface (see Fonts.kt).
+    val vTypography = MaterialTheme.typography.withDefaultFontFamily(defaultFontFamily)
+
+    MaterialTheme(colorScheme = vScheme, typography = vTypography) {
        CompositionLocalProvider(
            LocalAppColors provides vC,
            LocalVolticExtended provides vExtended,
@@ -56,11 +56,11 @@ internal class PackState(
    // 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)
-    private val fOwnRequests = mutableStateListOf<ReqState>().apply {
+    private val mOwnRequests = mutableStateListOf<ReqState>().apply {
        inPack.requests.forEach { add(ReqState(it)) }   // packs (and the loose root) may be empty
    }
    val requests: androidx.compose.runtime.snapshots.SnapshotStateList<ReqState>
-        get() = linkedSource?.requests ?: fOwnRequests
+        get() = linkedSource?.requests ?: mOwnRequests
    val isLinked: Boolean get() = linkedSource != null
    var parent: PackState? =
        null                                                  // enclosing pack (null = top-level / root)
@@ -1,5 +1,6 @@
 package apidemo

+import androidx.compose.material3.Typography
 import androidx.compose.ui.text.font.FontFamily

 // ==================
@@ -11,6 +12,9 @@ import androidx.compose.ui.text.font.FontFamily
 // 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?
@@ -18,3 +22,47 @@ 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),
+    )
+}
@@ -11,7 +11,7 @@ import kotlinx.serialization.json.JsonElement
 // respects the editor's "tab size" (TextLayoutConfig.tabWidth), exactly like
 // typed tabs. Lenient so slightly-off JSON (single quotes, trailing commas)
 // still reformats instead of failing.
-private val fPrettyJson = Json {
+private val mPrettyJson = Json {
    prettyPrint = true
    prettyPrintIndent = "\t"
    isLenient = true
@@ -23,7 +23,7 @@ private val fPrettyJson = Json {
 fun formatBody(inText: String, inFormat: BodyFormat): String =
    when (inFormat) {
        BodyFormat.JSON -> runCatching {
-            fPrettyJson.encodeToString(JsonElement.serializer(), fPrettyJson.parseToJsonElement(inText))
+            mPrettyJson.encodeToString(JsonElement.serializer(), mPrettyJson.parseToJsonElement(inText))
        }.getOrDefault(inText)

        BodyFormat.XML -> runCatching { formatXml(inText) }.getOrDefault(inText)
@@ -22,7 +22,7 @@ macOS/Linux). Same TLS stack as the client-cert path in CurlMtls.kt.
 run() is a suspend fun - call it off the UI dispatcher. */
 class HttpRunner {

-    private val fClient = createApiHttpClient()
+    private val mClient = createApiHttpClient()

    init {
        // Clear any temporary client certs a prior crash left in the Windows
@@ -36,7 +36,7 @@ class HttpRunner {
        if (inReq.hasClientCert) return curlSendWithClientCert(inReq)
        val vMark = TimeSource.Monotonic.markNow()
        return try {
-            val vResp: HttpResponse = fClient.request(inReq.url.trim()) {
+            val vResp: HttpResponse = mClient.request(inReq.url.trim()) {
                method = HttpMethod.parse(inReq.method.name)
                inReq.params
                    .filter { it.enabled && it.key.isNotBlank() }
@@ -113,7 +113,7 @@ class HttpRunner {
        }
    }

-    fun close() = fClient.close()
+    fun close() = mClient.close()
 }

 /** Heuristic for a non-text body: textual content types (text, json, xml, html,
@@ -9,7 +9,7 @@ import okio.Path.Companion.toPath
 // MARK: Pack persistence (okio + kotlinx.serialization)
 // ==================

-private val fJson = Json {
+private val mJson = Json {
    prettyPrint = true
    prettyPrintIndent = "  "
    ignoreUnknownKeys = true
@@ -20,7 +20,7 @@ private val fJson = Json {
 error message. */
 fun exportPack(inPack: Pack, inPath: String): String? = try {
    systemFileSystem.write(inPath.trim().toPath()) {
-        writeUtf8(fJson.encodeToString(inPack))
+        writeUtf8(mJson.encodeToString(inPack))
    }
    null
 } catch (e: Throwable) {
@@ -30,7 +30,7 @@ fun exportPack(inPack: Pack, inPath: String): String? = try {
 /** Read a pack back from inPath. */
 fun importPack(inPath: String): Result<Pack> = try {
    val vText = systemFileSystem.read(inPath.trim().toPath()) { readUtf8() }
-    Result.success(fJson.decodeFromString<Pack>(vText))
+    Result.success(mJson.decodeFromString<Pack>(vText))
 } catch (e: Throwable) {
    Result.failure(e)
 }
@@ -38,7 +38,7 @@ fun importPack(inPath: String): Result<Pack> = try {
 /** Write a whole self-contained session to inPath. Returns null on success. */
 fun exportSession(inSession: Session, inPath: String): String? = try {
    systemFileSystem.write(inPath.trim().toPath()) {
-        writeUtf8(fJson.encodeToString(inSession))
+        writeUtf8(mJson.encodeToString(inSession))
    }
    null
 } catch (e: Throwable) {
@@ -48,7 +48,7 @@ fun exportSession(inSession: Session, inPath: String): String? = try {
 /** Read a session back from inPath. */
 fun importSession(inPath: String): Result<Session> = try {
    val vText = systemFileSystem.read(inPath.trim().toPath()) { readUtf8() }
-    Result.success(fJson.decodeFromString<Session>(vText))
+    Result.success(mJson.decodeFromString<Session>(vText))
 } catch (e: Throwable) {
    Result.failure(e)
 }
@@ -85,7 +85,7 @@ fun writeBytesFile(inPath: String, inBytes: ByteArray): String? = try {
 /** 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))
+    mJson.encodeToString(JsonElement.serializer(), mJson.parseToJsonElement(inText))
 } catch (_: Throwable) {
    inText
 }
@@ -64,7 +64,7 @@ data class Session(
 // MARK: Load / save (app-data dir via okio)
 // ==================

-private val fStateJson = Json {
+private val mStateJson = Json {
    ignoreUnknownKeys = true
    encodeDefaults = true
    prettyPrint = true
@@ -88,7 +88,7 @@ fun loadAppState(): AppState {
    val vPath = stateFilePath() ?: return AppState()
    return try {
        val vText = systemFileSystem.read(vPath.toPath()) { readUtf8() }
-        fStateJson.decodeFromString<AppState>(vText)
+        mStateJson.decodeFromString<AppState>(vText)
    } catch (_: Throwable) {
        AppState()
    }
@@ -99,7 +99,7 @@ the session, not the user's exported .json packs). */
 fun saveAppState(inState: AppState) {
    val vPath = stateFilePath() ?: return
    try {
-        systemFileSystem.write(vPath.toPath()) { writeUtf8(fStateJson.encodeToString(inState)) }
+        systemFileSystem.write(vPath.toPath()) { writeUtf8(mStateJson.encodeToString(inState)) }
    } catch (_: Throwable) {
        // ignore - nothing the user can act on, and packs can still be exported
    }
@@ -21,3 +21,15 @@ actual val monoFontFamily: FontFamily? by lazy {
 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))
+    }
+}
@@ -1,19 +1,48 @@
 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.
-fun main() = application {
+//
+//   --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 {
@@ -25,8 +54,54 @@ fun main() = application {
        onPreviewKeyEvent = { jvmOnKeyShortcut?.invoke(it) ?: false },
        title = "API Manager - JVM (upstream Compose)",
        icon = vIcon,
-        state = rememberWindowState(width = 1240.dp, height = 820.dp),
+        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()
+    }
+}
@@ -19,6 +19,7 @@ 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
@@ -156,9 +157,9 @@ actual fun wrappedRowCount(inText: String, inFontPx: Int, inMaxWidthPx: Int, inF

 /** 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)
+private var mTabWidth by mutableStateOf(4)
 actual var editorTabWidth: Int
-    get() = fTabWidth
+    get() = mTabWidth
    set(value) {
-        fTabWidth = value
+        mTabWidth = value
    }
@@ -23,3 +23,16 @@ actual val monoFontFamilyName: String? 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)
+    }
+}
@@ -1,7 +1,13 @@
 package apidemo

 import com.compose.sdl.AppWindowIcon
+import com.compose.sdl.disableInfiniteAnimations
 import com.compose.sdl.nativeComposeWindow
+import com.compose.sdl.useVirtualFrameTime
+import com.compose.sdl.windowHasInvalidations
+import kotlinx.cinterop.ExperimentalForeignApi
+import utils.encodeBmpBgra32
+import utils.writeFile

 // ==================
 // MARK: Entry point (native - SDL window shell)
@@ -15,6 +21,57 @@ private val kAppIcon = AppWindowIcon(
    dark = listOf("icon/voltic-icon-dark-128.rgba", "icon/voltic-icon-dark-32.rgba")
 )

-fun main() {
-    nativeComposeWindow(title = "API Manager", width = 1240, height = 820, icon = kAppIcon) { App() }
+private const val kWidth = 1240
+private const val kHeight = 820
+
+/** Safety net for content that never stops invalidating. */
+private const val kMaxFrames = 300
+
+/**
+ * Entry point.
+ *
+ * `--screenshot=<path.bmp>` renders to quiescence and dumps the framebuffer, then
+ * exits - the native half of the JVM-vs-native drift check (the JVM half is
+ * `./gradlew :apidemo:run --args=--screenshot=<path.png>`, which goes through
+ * ImageComposeScene). The capture is a GPU READBACK, not a screen grab, so it
+ * does not care whether the window is visible or occluded.
+ */
+@OptIn(ExperimentalForeignApi::class)
+fun main(args: Array<String>) {
+    val screenshot = args.firstOrNull { it.startsWith("--screenshot=") }?.substringAfter('=')
+    if (screenshot != null) {
+        // Match the JVM leg: freeze infinite animations and drive a virtual clock so
+        // entrance animations settle deterministically instead of run-to-run.
+        disableInfiniteAnimations = true
+        useVirtualFrameTime = true
+    }
+
+    nativeComposeWindow(
+        title = "API Manager",
+        width = kWidth,
+        height = kHeight,
+        icon = kAppIcon,
+        onFrame = if (screenshot != null) {
+            // Capture once the window reports no pending invalidations for a few
+            // consecutive frames, or at the cap. Mirrors :demo's parity path.
+            var quietFrames = 0
+            { backend, frameIndex ->
+                quietFrames = if (windowHasInvalidations()) 0 else quietFrames + 1
+                if (quietFrames >= 3 || frameIndex >= kMaxFrames) {
+                    if (frameIndex >= kMaxFrames) {
+                        println("Screenshot: quiescence not reached by frame $frameIndex - capturing anyway")
+                    }
+                    val snap = backend.snapshotBgra()
+                    if (snap != null) {
+                        val (w, h, bgra) = snap
+                        writeFile(screenshot, encodeBmpBgra32(w, h, bgra))
+                        println("Wrote screenshot: $screenshot (${w}x$h, settled at frame $frameIndex)")
+                    } else {
+                        println("Screenshot snapshot was null")
+                    }
+                    false   // quit
+                } else true
+            }
+        } else null,
+    ) { App() }
 }
@@ -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
+}
@@ -32,27 +32,50 @@ val vPublishVersion = (System.getenv("PUBLISH_VERSION") ?: "0.0.0-SNAPSHOT").rem
 // headline app-shell artifact, published under com.bitsycore.compose.
 val kDefaultGroup = "com.bitsycore.compose.sdl"
 val kAreaGroups = mapOf(
-    ":ui" to "com.bitsycore.compose.ui",
-    ":ui-graphics" to "com.bitsycore.compose.ui",
-    ":ui-text" to "com.bitsycore.compose.ui",
-    ":ui-unit" to "com.bitsycore.compose.ui",
-    ":ui-geometry" to "com.bitsycore.compose.ui",
-    ":ui-util" to "com.bitsycore.compose.ui",
-    ":ui-backhandler" to "com.bitsycore.compose.ui",
-    ":ui-tooling-preview" to "com.bitsycore.compose.ui",
-    ":foundation" to "com.bitsycore.compose.foundation",
-    ":foundation-layout" to "com.bitsycore.compose.foundation",
-    ":animation" to "com.bitsycore.compose.animation",
-    ":animation-core" to "com.bitsycore.compose.animation",
-    ":animation-graphics" to "com.bitsycore.compose.animation",
-    ":material3" to "com.bitsycore.compose.material3",
-    ":material-ripple" to "com.bitsycore.compose.material",
-    ":components-resources" to "com.bitsycore.compose.components",
-    ":navigation3-ui" to "com.bitsycore.navigation3",
-    ":desktop-native-window" to "com.bitsycore.compose",
+    ":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:material3:adaptive:adaptive" to "com.bitsycore.compose.material3.adaptive",
+    ":compose:material3:adaptive:adaptive-layout" to "com.bitsycore.compose.material3.adaptive",
+    ":compose:material3:adaptive:adaptive-navigation" to "com.bitsycore.compose.material3.adaptive",
+    ":compose:material3:adaptive:adaptive-navigation3" to "com.bitsycore.compose.material3.adaptive",
+    ":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.compose.desktop.native.pulse",
+    ":pulse:pulse-viewmodel" to "com.bitsycore.compose.desktop.native.pulse",
+    ":pulse:pulse-savedstate" to "com.bitsycore.compose.desktop.native.pulse",
+    ":pulse:pulse-compose" to "com.bitsycore.compose.desktop.native.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 = groupFor(path)
    version = vPublishVersion
@@ -72,14 +95,22 @@ allprojects {

 val kAppModules = setOf(":demo", ":apidemo")
 val kPublishedLibs = setOf(
-    ":sdl-core",
-    ":ui", ":ui-util", ":ui-geometry", ":ui-graphics", ":ui-text",
-    ":ui-unit", ":ui-backhandler", ":ui-tooling-preview",
-    ":animation-core", ":animation", ":animation-graphics",
-    ":foundation", ":foundation-layout",
-    ":material3", ":material-ripple",
-    ":desktop-native-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:material3:adaptive:adaptive", ":compose:material3:adaptive:adaptive-layout", ":compose:material3:adaptive:adaptive-navigation", ":compose:material3:adaptive:adaptive-navigation3",
+    ":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
@@ -110,7 +141,7 @@ subprojects {
        configurations.configureEach {
            resolutionStrategy.dependencySubstitution {
                kPublishedLibs.forEach { modulePath ->
-                    val vArtifactId = modulePath.removePrefix(":")
+                    val vArtifactId = artifactIdFor(modulePath)
                    substitute(project(modulePath))
                        .using(module("${groupFor(modulePath)}:$vArtifactId:$kConsumeVersion"))
                        .because("-PuseGithubPackages=true")
@@ -128,6 +159,9 @@ subprojects {
        }
        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> {
@@ -178,27 +212,57 @@ allprojects {
    configurations.configureEach {
        if (vNativeTargetTokens.any { name.contains(it, ignoreCase = true) }) {
            resolutionStrategy.dependencySubstitution {
-                substitute(module("org.jetbrains.compose.ui:ui")).using(project(":ui"))
+                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(":ui-graphics"))
-                substitute(module("org.jetbrains.compose.ui:ui-text")).using(project(":ui-text"))
-                substitute(module("org.jetbrains.compose.ui:ui-unit")).using(project(":ui-unit"))
-                substitute(module("org.jetbrains.compose.ui:ui-geometry")).using(project(":ui-geometry"))
-                substitute(module("org.jetbrains.compose.ui:ui-util")).using(project(":ui-util"))
-                substitute(module("org.jetbrains.compose.ui:ui-tooling-preview")).using(project(":ui-tooling-preview"))
-                substitute(module("org.jetbrains.compose.foundation:foundation")).using(project(":foundation"))
-                substitute(module("org.jetbrains.compose.foundation:foundation-layout")).using(project(":foundation-layout"))
-                substitute(module("org.jetbrains.compose.animation:animation")).using(project(":animation"))
-                substitute(module("org.jetbrains.compose.animation:animation-core")).using(project(":animation-core"))
-                substitute(module("org.jetbrains.compose.material3:material3")).using(project(":material3"))
+                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"))
+                // material3-adaptive: upstream publishes ios + macosArm64 only - no
+                // linux, no mingw (issues/4). Vendored as :compose:material3:adaptive:*.
+                substitute(module("org.jetbrains.compose.material3.adaptive:adaptive")).using(project(":compose:material3:adaptive:adaptive"))
+                substitute(module("org.jetbrains.compose.material3.adaptive:adaptive-layout")).using(project(":compose:material3:adaptive:adaptive-layout"))
+                substitute(module("org.jetbrains.compose.material3.adaptive:adaptive-navigation")).using(project(":compose:material3:adaptive:adaptive-navigation"))
+                substitute(module("org.jetbrains.compose.material3.adaptive:adaptive-navigation3")).using(project(":compose:material3:adaptive:adaptive-navigation3"))
                // 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-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"))
+                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. Pulse is itself a com.bitsycore library, so the port's
+                // republish is namespaced under THIS project rather than a bare
+                // com.bitsycore.pulse, which would read like the upstream artifact. 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"))
            }
        }
    }
@@ -197,7 +197,7 @@ private fun Project.addFontEntries(
 		inTask.from(vNotoFile) { into("font") }
 		inDownloadNotoFonts?.let { inTask.dependsOn(it) }
 	}
-	val vSymbolsProject = rootProject.project(":material-symbols")
+	val vSymbolsProject = rootProject.project(":utils:material-symbols")
 	for (vStyle in inUsedStyles) {
 		@Suppress("UNCHECKED_CAST")
 		val vFontFile = vSymbolsProject.extra["iconFontFile$vStyle"] as Provider<RegularFile>
@@ -232,7 +232,7 @@ private fun Project.registerIconSubsetPipeline(inUsedStyles: List<String>): Map<
 	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(":material-symbols").layout.projectDirectory
+		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") })
@@ -259,7 +259,7 @@ private fun Project.registerSubsetTask(
 	inIconsBuildDir: Provider<Directory>,
 	inFindUsage: TaskProvider<*>,
 ): TaskProvider<*> {
-	val vSymbolsProject = rootProject.project(":material-symbols")
+	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")
@@ -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]
@@ -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",
+		)
+	}
+}
@@ -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 ---- >>>>
@@ -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]
@@ -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",
+		)
+	}
+}
@@ -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 ---- >>>>
@@ -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",
+		)
+	}
+}
@@ -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 ---- >>>>
@@ -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]
@@ -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",
+		)
+	}
+}
@@ -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 ---- >>>>
@@ -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]
@@ -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",
+		)
+	}
+}
@@ -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 ---- >>>>
@@ -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]
@@ -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",
+		)
+	}
+}
@@ -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 ---- >>>>
@@ -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]
+    }
+}
@@ -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",
+		)
+	}
+}
@@ -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 ---- >>>>
@@ -11,12 +11,6 @@ plugins {
 	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 {
@@ -34,7 +28,7 @@ kotlin {
 				// foundation (isSystemInDarkTheme in ResourceEnvironment) pulls the
 				// whole ui surface + loadComposeResourceBytes + the sdl3 cinterop
 				// types transitively (all edges are api).
-				api(project(":foundation"))
+				api(project(":compose:foundation:foundation"))
 				implementation(libs.kotlinx.coroutines.core)
 			}
 		}
@@ -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
@@ -1,5 +1,11 @@
@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
@@ -45,20 +51,20 @@ 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
+	private var mAlpha: Float = 1f
+	private var mColorFilter: ColorFilter? = null
+	private var mCacheKey: Long = -1L
+	private var mCacheBitmap: ImageBitmap? = null

-	override fun applyAlpha(alpha: Float): Boolean { fAlpha = alpha; return true }
-	override fun applyColorFilter(colorFilter: ColorFilter?): Boolean { fColorFilter = colorFilter; return true }
+	override fun applyAlpha(alpha: Float): Boolean { mAlpha = alpha; return true }
+	override fun applyColorFilter(colorFilter: ColorFilter?): Boolean { mColorFilter = 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
+		if (vKey == mCacheKey && mCacheBitmap != null) return mCacheBitmap
 		val vBitmap = decodeSvgAt(bytes, inWidthPx, inHeightPx) ?: return null
-		fCacheKey = vKey
-		fCacheBitmap = vBitmap
+		mCacheKey = vKey
+		mCacheBitmap = vBitmap
 		return vBitmap
 	}

@@ -73,8 +79,8 @@ private class SvgPainter(private val bytes: ByteArray) : Painter() {
 			srcSize = IntSize(vBitmap.width, vBitmap.height),
 			dstOffset = IntOffset.Zero,
 			dstSize = IntSize(vWpx, vHpx),
-			alpha = fAlpha,
-			colorFilter = fColorFilter,
+			alpha = mAlpha,
+			colorFilter = mColorFilter,
 		)
 	}
 }
@@ -16,7 +16,7 @@ package org.jetbrains.compose.resources.vector.xmldom
   CDATA skipping, and the five predefined entities plus numeric character
   references. No DTD expansion, no processing-instruction handling beyond
   skipping - malformed input throws MalformedXMLException like upstream. */
-// VENDOR-BASE(COMPOSE_REF): components/resources/library/src/nativeMain/kotlin/org/jetbrains/compose/resources/vector/xmldom/DomXmlParser.kt @ v1.12.0-beta03+dev4483
+// VENDOR-BASE(COMPOSE_REF): components/resources/library/src/nativeMain/kotlin/org/jetbrains/compose/resources/vector/xmldom/DomXmlParser.kt @ v1.12.1
 // (fresh REIMPL, not a copy-edit - the base ref marks the upstream API it tracks)

 internal fun parse(xml: String): Element {
@@ -32,13 +32,13 @@ private class Attr(val prefix: String, val localName: String, val nsUri: String,
 	val qualifiedName: String get() = if (prefix.isEmpty()) localName else "$prefix:$localName"
 }

-private class NodeListImpl(private val fNodes: List<Node>) : NodeList {
-	override fun item(i: Int): Node = fNodes[i]
-	override val length: Int get() = fNodes.size
+private class NodeListImpl(private val mNodes: List<Node>) : NodeList {
+	override fun item(i: Int): Node = mNodes[i]
+	override val length: Int get() = mNodes.size
 }

-private class TextNodeImpl(private val fText: String) : Node {
-	override val textContent: String? get() = fText
+private class TextNodeImpl(private val mText: String) : Node {
+	override val textContent: String? get() = mText
 	override val nodeName: String get() = "#text"
 	override val localName: String get() = ""
 	override val childNodes: NodeList = NodeListImpl(emptyList())
@@ -47,16 +47,16 @@ private class TextNodeImpl(private val fText: String) : Node {
 }

 private class ElementImpl(
-	private val fPrefix: String,
+	private val mPrefix: String,
 	override val localName: String,
 	override val namespaceURI: String,
-	private val fAttrs: List<Attr>,
+	private val mAttrs: List<Attr>,
 	// Innermost-first chain of xmlns scopes: each is prefix -> uri ("" = default ns).
-	private val fNsScope: List<Map<String, String>>,
+	private val mNsScope: List<Map<String, String>>,
 ) : Element {
 	var children: List<Node> = emptyList()

-	override val nodeName: String get() = if (fPrefix.isEmpty()) localName else "$fPrefix:$localName"
+	override val nodeName: String get() = if (mPrefix.isEmpty()) localName else "$mPrefix:$localName"
 	override val childNodes: NodeList get() = NodeListImpl(children)

 	// Concatenated descendant text - what DOM's textContent does.
@@ -72,7 +72,7 @@ private class ElementImpl(

 	override fun lookupPrefix(namespaceURI: String): String {
 		if (namespaceURI.isEmpty()) return ""
-		for (vScope in fNsScope) {
+		for (vScope in mNsScope) {
 			for ((vPrefix, vUri) in vScope) {
 				if (vUri == namespaceURI && vPrefix.isNotEmpty()) return vPrefix
 			}
@@ -81,22 +81,22 @@ private class ElementImpl(
 	}

 	override fun getAttributeNS(nameSpaceURI: String, localName: String): String =
-		fAttrs.firstOrNull { it.nsUri == nameSpaceURI && it.localName == localName }?.value ?: ""
+		mAttrs.firstOrNull { it.nsUri == nameSpaceURI && it.localName == localName }?.value ?: ""

 	override fun getAttribute(name: String): String =
-		fAttrs.firstOrNull { it.qualifiedName == name }?.value ?: ""
+		mAttrs.firstOrNull { it.qualifiedName == name }?.value ?: ""
 }

 // ============
 //  The parser - one pass over the string with a cursor.
-private class XmlDomParser(private val fXml: String) {
-	private var fPos = 0
+private class XmlDomParser(private val mXml: String) {
+	private var mPos = 0

 	fun skipProlog() {
 		while (true) {
 			skipWhitespace()
 			when {
-				lookingAt("") -> fPos++
+				lookingAt("") -> mPos++
 				lookingAt("<?") -> skipUntil("?>")
 				lookingAt("<!--") -> skipUntil("-->")
 				lookingAt("<!DOCTYPE") -> skipDoctype()
@@ -112,7 +112,7 @@ private class XmlDomParser(private val fXml: String) {
 		if (!lookingAt("<") || lookingAt("</")) return null
 		expect("<")
 		val vQName = readName()
-		if (vQName.isEmpty()) throw MalformedXMLException("empty element name at $fPos")
+		if (vQName.isEmpty()) throw MalformedXMLException("empty element name at $mPos")

 		// Attributes (collect raw first - xmlns declarations shape the scope
 		// that THIS element's own prefix resolves against).
@@ -121,7 +121,7 @@ private class XmlDomParser(private val fXml: String) {
 			skipWhitespace()
 			if (lookingAt("/>") || lookingAt(">")) break
 			val vAttrName = readName()
-			if (vAttrName.isEmpty()) throw MalformedXMLException("bad attribute at $fPos")
+			if (vAttrName.isEmpty()) throw MalformedXMLException("bad attribute at $mPos")
 			skipWhitespace(); expect("="); skipWhitespace()
 			vRawAttrs.add(vAttrName to readQuotedValue())
 		}
@@ -160,7 +160,7 @@ private class XmlDomParser(private val fXml: String) {
 		val vElement = ElementImpl(vPrefix, vLocal, resolveNs(vPrefix), vAttrs, vScope)

 		if (lookingAt("/>")) {
-			fPos += 2
+			mPos += 2
 			return vElement
 		}
 		expect(">")
@@ -169,9 +169,9 @@ private class XmlDomParser(private val fXml: String) {
 		val vChildren = ArrayList<Node>()
 		while (true) {
 			when {
-				fPos >= fXml.length -> throw MalformedXMLException("unclosed <$vQName>")
+				mPos >= mXml.length -> throw MalformedXMLException("unclosed <$vQName>")
 				lookingAt("</") -> {
-					fPos += 2
+					mPos += 2
 					val vClose = readName()
 					skipWhitespace(); expect(">")
 					if (vClose != vQName) throw MalformedXMLException("mismatched </$vClose> for <$vQName>")
@@ -180,18 +180,18 @@ private class XmlDomParser(private val fXml: String) {
 				}
 				lookingAt("<!--") -> skipUntil("-->")
 				lookingAt("<![CDATA[") -> {
-					val vEnd = fXml.indexOf("]]>", fPos + 9)
+					val vEnd = mXml.indexOf("]]>", mPos + 9)
 					if (vEnd < 0) throw MalformedXMLException("unclosed CDATA")
-					vChildren.add(TextNodeImpl(fXml.substring(fPos + 9, vEnd)))
-					fPos = vEnd + 3
+					vChildren.add(TextNodeImpl(mXml.substring(mPos + 9, vEnd)))
+					mPos = vEnd + 3
 				}
 				lookingAt("<?") -> skipUntil("?>")
 				lookingAt("<") -> parseElement(vScope)?.let { vChildren.add(it) }
 				else -> {
-					val vNext = fXml.indexOf('<', fPos).let { if (it < 0) fXml.length else it }
-					val vText = decodeEntities(fXml.substring(fPos, vNext))
+					val vNext = mXml.indexOf('<', mPos).let { if (it < 0) mXml.length else it }
+					val vText = decodeEntities(mXml.substring(mPos, vNext))
 					if (vText.isNotBlank()) vChildren.add(TextNodeImpl(vText))
-					fPos = vNext
+					mPos = vNext
 				}
 			}
 		}
@@ -200,28 +200,28 @@ private class XmlDomParser(private val fXml: String) {
 	// ============
 	//  Lexing helpers

-	private fun lookingAt(inToken: String): Boolean = fXml.startsWith(inToken, fPos)
+	private fun lookingAt(inToken: String): Boolean = mXml.startsWith(inToken, mPos)

 	private fun expect(inToken: String) {
-		if (!lookingAt(inToken)) throw MalformedXMLException("expected '$inToken' at $fPos")
-		fPos += inToken.length
+		if (!lookingAt(inToken)) throw MalformedXMLException("expected '$inToken' at $mPos")
+		mPos += inToken.length
 	}

 	private fun skipWhitespace() {
-		while (fPos < fXml.length && fXml[fPos].isWhitespace()) fPos++
+		while (mPos < mXml.length && mXml[mPos].isWhitespace()) mPos++
 	}

 	private fun skipUntil(inToken: String) {
-		val vEnd = fXml.indexOf(inToken, fPos)
+		val vEnd = mXml.indexOf(inToken, mPos)
 		if (vEnd < 0) throw MalformedXMLException("unterminated '$inToken' section")
-		fPos = vEnd + inToken.length
+		mPos = vEnd + inToken.length
 	}

 	/* DOCTYPE may nest an internal subset in [ ] - skip to the matching '>'. */
 	private fun skipDoctype() {
 		var vDepth = 0
-		while (fPos < fXml.length) {
-			val c = fXml[fPos++]
+		while (mPos < mXml.length) {
+			val c = mXml[mPos++]
 			if (c == '[') vDepth++
 			else if (c == ']') vDepth--
 			else if (c == '>' && vDepth <= 0) return
@@ -230,24 +230,24 @@ private class XmlDomParser(private val fXml: String) {
 	}

 	private fun readName(): String {
-		val vStart = fPos
-		while (fPos < fXml.length) {
-			val c = fXml[fPos]
+		val vStart = mPos
+		while (mPos < mXml.length) {
+			val c = mXml[mPos]
 			if (c.isWhitespace() || c == '=' || c == '>' || c == '/' || c == '<') break
-			fPos++
+			mPos++
 		}
-		return fXml.substring(vStart, fPos)
+		return mXml.substring(vStart, mPos)
 	}

 	private fun readQuotedValue(): String {
-		if (fPos >= fXml.length) throw MalformedXMLException("unterminated attribute value")
-		val vQuote = fXml[fPos]
-		if (vQuote != '"' && vQuote != '\'') throw MalformedXMLException("attribute value must be quoted at $fPos")
-		fPos++
-		val vEnd = fXml.indexOf(vQuote, fPos)
+		if (mPos >= mXml.length) throw MalformedXMLException("unterminated attribute value")
+		val vQuote = mXml[mPos]
+		if (vQuote != '"' && vQuote != '\'') throw MalformedXMLException("attribute value must be quoted at $mPos")
+		mPos++
+		val vEnd = mXml.indexOf(vQuote, mPos)
 		if (vEnd < 0) throw MalformedXMLException("unterminated attribute value")
-		val vRaw = fXml.substring(fPos, vEnd)
-		fPos = vEnd + 1
+		val vRaw = mXml.substring(mPos, vEnd)
+		mPos = vEnd + 1
 		return decodeEntities(vRaw)
 	}

@@ -30,7 +30,7 @@ kotlin {
        commonMain {
            kotlin.srcDir("src/vendor/common/kotlin")
            dependencies {
-                api(project(":ui"))
+                api(project(":compose:ui:ui"))
            }
        }
        nativeMain {
@@ -28,8 +28,8 @@ kotlin {
 			dependencies {
 				// animation.graphics.* uses animation.* / animation.core.* and the vector
 				// graphics from ui (ui-graphics.vector, ui-util).
-				api(project(":animation"))
-				api(project(":ui"))
+				api(project(":compose:animation:animation"))
+				api(project(":compose:ui:ui"))
 			}
 			kotlin.srcDir("src/vendor/common/kotlin")
 		}
@@ -28,8 +28,8 @@ kotlin {
 			dependencies {
 				// animation.* imports animation.core.* and foundation.layout.* (Box/Row/Column);
 				// ui / runtime arrive transitively.
-				api(project(":animation-core"))
-				api(project(":foundation-layout"))
+				api(project(":compose:animation:animation-core"))
+				api(project(":compose:foundation:foundation-layout"))
 			}
 			kotlin.srcDir("src/vendor/common/kotlin")
 		}
@@ -28,8 +28,8 @@ final var com.compose.sdl/useVirtualFrameTime // com.compose.sdl/useVirtualFrame
    final fun <get-useVirtualFrameTime>(): kotlin/Boolean // com.compose.sdl/useVirtualFrameTime.<get-useVirtualFrameTime>|<get-useVirtualFrameTime>(){}[0]
    final fun <set-useVirtualFrameTime>(kotlin/Boolean) // com.compose.sdl/useVirtualFrameTime.<set-useVirtualFrameTime>|<set-useVirtualFrameTime>(kotlin.Boolean){}[0]

-final fun (com.compose.sdl/ApplicationScope).com.compose.sdl/Window(kotlin/Function0<kotlin/Unit>, kotlin/String?, kotlin/Int, kotlin/Int, com.compose.sdl/GpuMode?, com.compose.sdl/AppWindowIcon?, kotlin/Function2<com.compose.sdl/RenderBackend, kotlin/Int, kotlin/Boolean>?, kotlin/Function3<com.compose.sdl/ComposeWindowScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // com.compose.sdl/Window|Window@com.compose.sdl.ApplicationScope(kotlin.Function0<kotlin.Unit>;kotlin.String?;kotlin.Int;kotlin.Int;com.compose.sdl.GpuMode?;com.compose.sdl.AppWindowIcon?;kotlin.Function2<com.compose.sdl.RenderBackend,kotlin.Int,kotlin.Boolean>?;kotlin.Function3<com.compose.sdl.ComposeWindowScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun (com.compose.sdl/ApplicationScope).com.compose.sdl/Window(kotlin/Function0<kotlin/Unit>, kotlin/String?, kotlin/Int, kotlin/Int, com.compose.sdl/GpuMode?, com.compose.sdl/AppWindowIcon?, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, kotlin/Function1<androidx.compose.ui.input.key/KeyEvent, kotlin/Boolean>?, kotlin/Function1<androidx.compose.ui.input.key/KeyEvent, kotlin/Boolean>?, kotlin/Function2<com.compose.sdl/RenderBackend, kotlin/Int, kotlin/Boolean>?, kotlin/Function3<com.compose.sdl/ComposeWindowScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int, kotlin/Int) // com.compose.sdl/Window|Window@com.compose.sdl.ApplicationScope(kotlin.Function0<kotlin.Unit>;kotlin.String?;kotlin.Int;kotlin.Int;com.compose.sdl.GpuMode?;com.compose.sdl.AppWindowIcon?;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Function1<androidx.compose.ui.input.key.KeyEvent,kotlin.Boolean>?;kotlin.Function1<androidx.compose.ui.input.key.KeyEvent,kotlin.Boolean>?;kotlin.Function2<com.compose.sdl.RenderBackend,kotlin.Int,kotlin.Boolean>?;kotlin.Function3<com.compose.sdl.ComposeWindowScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int;kotlin.Int){}[0]
 final fun com.compose.sdl/com_compose_sdl_AppWindowIcon$stableprop_getter(): kotlin/Int // com.compose.sdl/com_compose_sdl_AppWindowIcon$stableprop_getter|com_compose_sdl_AppWindowIcon$stableprop_getter(){}[0]
 final fun com.compose.sdl/nativeComposeApp(kotlin/Function3<com.compose.sdl/ApplicationScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>) // com.compose.sdl/nativeComposeApp|nativeComposeApp(kotlin.Function3<com.compose.sdl.ApplicationScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>){}[0]
-final fun com.compose.sdl/nativeComposeWindow(kotlin/String = ..., kotlin/Int = ..., kotlin/Int = ..., com.compose.sdl/GpuMode = ..., com.compose.sdl/AppWindowIcon? = ..., kotlin/Function2<com.compose.sdl/RenderBackend, kotlin/Int, kotlin/Boolean>? = ..., kotlin/Function3<com.compose.sdl/ComposeWindowScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>) // com.compose.sdl/nativeComposeWindow|nativeComposeWindow(kotlin.String;kotlin.Int;kotlin.Int;com.compose.sdl.GpuMode;com.compose.sdl.AppWindowIcon?;kotlin.Function2<com.compose.sdl.RenderBackend,kotlin.Int,kotlin.Boolean>?;kotlin.Function3<com.compose.sdl.ComposeWindowScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>){}[0]
+final fun com.compose.sdl/nativeComposeWindow(kotlin/String = ..., kotlin/Int = ..., kotlin/Int = ..., com.compose.sdl/GpuMode = ..., com.compose.sdl/AppWindowIcon? = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Boolean = ..., kotlin/Function1<androidx.compose.ui.input.key/KeyEvent, kotlin/Boolean> = ..., kotlin/Function1<androidx.compose.ui.input.key/KeyEvent, kotlin/Boolean> = ..., kotlin/Function2<com.compose.sdl/RenderBackend, kotlin/Int, kotlin/Boolean>? = ..., kotlin/Function3<com.compose.sdl/ComposeWindowScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>) // com.compose.sdl/nativeComposeWindow|nativeComposeWindow(kotlin.String;kotlin.Int;kotlin.Int;com.compose.sdl.GpuMode;com.compose.sdl.AppWindowIcon?;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Function1<androidx.compose.ui.input.key.KeyEvent,kotlin.Boolean>;kotlin.Function1<androidx.compose.ui.input.key.KeyEvent,kotlin.Boolean>;kotlin.Function2<com.compose.sdl.RenderBackend,kotlin.Int,kotlin.Boolean>?;kotlin.Function3<com.compose.sdl.ComposeWindowScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>){}[0]
 final fun com.compose.sdl/windowHasInvalidations(): kotlin/Boolean // com.compose.sdl/windowHasInvalidations|windowHasInvalidations(){}[0]
@@ -34,12 +34,12 @@ kotlin {
            // out of :ui (upstream Compose layout).
            // Material widgets used to be re-exported from :material here; the
            // module was retired when :apidemo and :demo migrated to :material3.
-            // Apps that want Material 3 widgets pull `implementation(project(":material3"))`
+            // Apps that want Material 3 widgets pull `implementation(project(":compose:material3:material3"))`
            // themselves (:material3 doesn't need to be `api`-exposed - the
            // upstream vendored surface is stable and apps import it directly).
-            api(project(":ui"))
-            api(project(":foundation"))
-            api(project(":animation-core"))
+            api(project(":compose:ui:ui"))
+            api(project(":compose:foundation:foundation"))
+            api(project(":compose:animation:animation-core"))
            implementation(libs.kotlinx.coroutines.core)
            // setMain() / resetMain() - see Sdl3MainDispatcher.kt for usage.
            implementation(libs.kotlinx.coroutines.test)
@@ -0,0 +1,88 @@
+@file:OptIn(
+	androidx.compose.ui.InternalComposeUiApi::class,
+	androidx.compose.runtime.InternalComposeApi::class,
+)
+
+package com.compose.sdl
+
+import androidx.compose.runtime.AbstractApplier
+import androidx.compose.runtime.Composable
+import kotlinx.coroutines.CoroutineScope
+
+// ==================
+// MARK: App runtime internals
+// ==================
+
+internal class ApplicationScopeImpl(val runtime: AppRuntime) : ApplicationScope {
+	override fun exitApplication() { runtime.exitRequested = true }
+}
+
+/** Registry + lifecycle for the live windows. Windows are created by the app
+   composition (Window()'s remember) and destroyed by the LOOP - DisposableEffect
+   onDispose only schedules, because teardown disposes a composition and that
+   must not run re-entrantly inside another composition's apply pass. */
+internal class AppRuntime {
+	lateinit var scope: CoroutineScope
+	val windows = mutableListOf<WindowInstance>()
+	private val destroyQueue = mutableListOf<WindowInstance>()
+	var exitRequested = false
+	var hadWindow = false
+
+	fun windowFor(inId: UInt): WindowInstance? =
+		if (inId == 0u) windows.firstOrNull()
+		else windows.firstOrNull { it.backend.windowId == inId } ?: windows.firstOrNull()
+
+	fun markAllNeedFrame() {
+		for (vW in windows) vW.needsFrame = true
+	}
+
+	fun createWindow(
+		inTitle: String,
+		inWidth: Int,
+		inHeight: Int,
+		inGpu: GpuMode,
+		inIcon: AppWindowIcon?,
+		inAttrs: WindowAttributes,
+		inOnFrame: ((RenderBackend, Int) -> Boolean)?,
+		inPreviewKeyHandler: () -> ((androidx.compose.ui.input.key.KeyEvent) -> Boolean),
+		inKeyHandler: () -> ((androidx.compose.ui.input.key.KeyEvent) -> Boolean),
+		inContent: () -> (@Composable ComposeWindowScope.() -> Unit),
+	): WindowInstance {
+		val vWindow = WindowInstance(
+			inTitle, inWidth, inHeight, inGpu, inIcon, inAttrs, inOnFrame,
+			inPreviewKeyHandler, inKeyHandler, inContent,
+		)
+		// A Window() was declared either way - the "exit when the last window
+		// is gone" rule must also fire when every declared window failed to
+		// initialise (otherwise the loop would spin forever with none).
+		hadWindow = true
+		if (vWindow.init(scope)) {
+			windows.add(vWindow)
+		} else {
+			println("nativeComposeApp: window '$inTitle' failed to initialise")
+		}
+		return vWindow
+	}
+
+	fun scheduleDestroy(inWindow: WindowInstance) {
+		if (inWindow in windows && inWindow !in destroyQueue) destroyQueue.add(inWindow)
+	}
+
+	fun reapDestroyed() {
+		while (destroyQueue.isNotEmpty()) {
+			val vW = destroyQueue.removeLast()
+			windows.remove(vW)
+			vW.destroy()
+		}
+	}
+}
+
+// No-op applier for the app-level composition - it emits no UI nodes, only
+// side effects (each Window() manages a native window).
+internal class UnitApplier : AbstractApplier<Unit>(Unit) {
+	override fun insertTopDown(index: Int, instance: Unit) {}
+	override fun insertBottomUp(index: Int, instance: Unit) {}
+	override fun remove(index: Int, count: Int) {}
+	override fun move(from: Int, to: Int, count: Int) {}
+	override fun onClear() {}
+}
@@ -0,0 +1,357 @@
+@file:OptIn(
+	androidx.compose.ui.InternalComposeUiApi::class,
+	androidx.compose.runtime.InternalComposeApi::class,
+)
+
+package com.compose.sdl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.runtime.Composition
+import androidx.compose.runtime.Recomposer
+import androidx.compose.runtime.SideEffect
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.snapshots.Snapshot
+import kotlinx.coroutines.*
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import sdl3.SDL_Delay
+import sdl3.SDL_GetTicks
+import sdl3.SDL_Quit
+import sdl3.SDL_WaitEventTimeout
+
+// ==================
+// MARK: Application entry - nativeComposeApp + Window()
+// ==================
+
+/**
+ Multi-window entry point, shaped like Compose Desktop's `application {}`:
+
+     nativeComposeApp {
+         var showTools by remember { mutableStateOf(false) }
+         Window(onCloseRequest = ::exitApplication, title = "Main") { MainUi(onTools = { showTools = true }) }
+         if (showTools) Window(onCloseRequest = { showTools = false }, title = "Tools") { ToolsUi() }
+     }
+
+ The app CONTENT is itself a composition (no UI tree - a Unit applier): each
+ `Window(...)` call materialises an SDL window + renderer + root host + its own
+ recomposer/composition, and leaving the composition (state flips to false)
+ tears the window down. One main loop pumps the shared SDL event queue and
+ routes events per SDL window id.
+
+ Per-window pumping order matters: the render-bridge globals
+ (currentImageLoader / viewport) are per-renderer, so the
+ loop installs a window's globals before recomposing / laying out / drawing it.
+
+ `nativeComposeWindow(...)` remains as the single-window wrapper (all demo
+ probes and apidemo ride it unchanged).
+*/
+
+interface ApplicationScope {
+	/** Requests the main loop to exit after the current iteration (all windows
+	   are torn down on the way out). */
+	fun exitApplication()
+}
+
+/** Declares one native window for as long as this composable stays in the app
+   composition. `onCloseRequest` fires when the user asks the window to close
+   (OS close button, or `window.close()` from content) - remove the state that
+   composes this Window to actually close it, or call exitApplication(). */
+@Composable
+fun ApplicationScope.Window(
+	onCloseRequest: () -> Unit,
+	title: String = "ComposeNativeSDL3",
+	width: Int = 800,
+	height: Int = 600,
+	gpu: GpuMode = GpuMode.Auto,
+	icon: AppWindowIcon? = null,
+	undecorated: Boolean = false,
+	transparent: Boolean = false,
+	resizable: Boolean = true,
+	enabled: Boolean = true,
+	focusable: Boolean = true,
+	alwaysOnTop: Boolean = false,
+	onPreviewKeyEvent: (KeyEvent) -> Boolean = { false },
+	onKeyEvent: (KeyEvent) -> Boolean = { false },
+	onFrame: ((backend: RenderBackend, frameIndex: Int) -> Boolean)? = null,
+	content: @Composable ComposeWindowScope.() -> Unit,
+) {
+	val vScope = this as? ApplicationScopeImpl
+		?: error("Window() must be called inside nativeComposeApp { ... }")
+	val vContent = rememberUpdatedState(content)
+	val vClose = rememberUpdatedState(onCloseRequest)
+	val vPreviewKey = rememberUpdatedState(onPreviewKeyEvent)
+	val vKey = rememberUpdatedState(onKeyEvent)
+	val vAttrs = WindowAttributes(
+		undecorated = undecorated,
+		transparent = transparent,
+		resizable = resizable,
+		enabled = enabled,
+		focusable = focusable,
+		alwaysOnTop = alwaysOnTop,
+	)
+	val vWindow = remember {
+		vScope.runtime.createWindow(
+			inTitle = title,
+			inWidth = width,
+			inHeight = height,
+			inGpu = gpu,
+			inIcon = icon,
+			inAttrs = vAttrs,
+			inOnFrame = onFrame,
+			// Read through holders so updated lambdas propagate without
+			// recreating the window (same reason as the content holder below).
+			inPreviewKeyHandler = { vPreviewKey.value },
+			inKeyHandler = { vKey.value },
+			// The window composition reads the holder each recomposition, so
+			// updated content lambdas propagate without recreating the window.
+			inContent = { vContent.value },
+		).also { it.onCloseRequest = { vClose.value.invoke() } }
+	}
+	SideEffect {
+		if (vWindow.facade.title != title) vWindow.facade.setTitle(title)
+	}
+	// Re-apply only on a real change; `transparent` is creation-only (see
+	// WindowAttributes) so it is deliberately not re-applied here.
+	DisposableEffect(vAttrs) {
+		vWindow.applyAttributes(vAttrs)
+		onDispose { }
+	}
+	DisposableEffect(Unit) {
+		onDispose { vScope.runtime.scheduleDestroy(vWindow) }
+	}
+}
+
+/** Boots SDL + the Compose runtime, runs `content` as the application
+   composition, and drives every declared Window until exitApplication() or
+   the last window closes. */
+fun nativeComposeApp(content: @Composable ApplicationScope.() -> Unit) {
+	// Install the Main dispatcher BEFORE any window/owner exists: ComposeOwner
+	// captures Dispatchers.Main eagerly for its per-node coroutine scopes.
+	val mainDispatcher = Sdl3MainDispatcher()
+	@OptIn(ExperimentalCoroutinesApi::class)
+	Dispatchers.setMain(mainDispatcher)
+
+	val runtime = AppRuntime()
+
+	runBlocking {
+		runtime.scope = this
+
+		// App-level composition: no UI tree - it only declares Window()s.
+		val appClock = Sdl3FrameClock()
+		val appRecomposer = Recomposer(coroutineContext + appClock)
+		// The clock must be in the collector's context - runRecomposeAndApplyChanges
+		// awaits parent frames through it.
+		val appRecomposeJob = launch(appClock) { appRecomposer.runRecomposeAndApplyChanges() }
+		val appComposition = Composition(UnitApplier(), appRecomposer)
+		val appScope = ApplicationScopeImpl(runtime)
+
+		val snapshotHandle = Snapshot.registerGlobalWriteObserver {
+			// Only SCHEDULE a frame here; the apply is coalesced to once per loop
+			// iteration (top of loop + before each pump + before layout in
+			// renderFrame) instead of walking every snapshot observer on every
+			// individual state write. Mirrors upstream GlobalSnapshotManager,
+			// which schedules rather than applying inline.
+			runtime.markAllNeedFrame()
+		}
+
+		appComposition.setContent { appScope.content() }
+		// Compose the initial Window() declarations before entering the loop.
+		appClock.sendFrame(frameClockNanos())
+		yield()
+
+		// ============
+		//  Main loop
+		var vGcLastTicks = SDL_GetTicks()
+		var vRenderedSinceGc = false
+		while (!runtime.exitRequested) {
+			FrameProfiler.mark()
+			// One virtual 16.6ms tick per loop iteration (no-op unless useVirtualFrameTime) -
+			// all windows' clocks share the same timestamp this iteration.
+			advanceVirtualFrame()
+			Snapshot.sendApplyNotifications()
+
+			// ============
+			//  Events - one shared SDL queue, routed by window id.
+			val vEvents = pollEvents()
+			for (vEvent in vEvents) {
+				when (vEvent) {
+					is AppEvent.Quit -> {
+						// Platform quit = close request on every window; any
+						// veto (setOnCloseRequest returning false) keeps the
+						// app alive. No windows at all → plain exit.
+						if (runtime.windows.isEmpty()) runtime.exitRequested = true
+						else for (vW in runtime.windows.toList()) vW.requestClose()
+					}
+					is AppEvent.WindowClose -> runtime.windowFor(vEvent.windowId)?.requestClose()
+					is AppEvent.WindowResized -> runtime.windowFor(vEvent.windowId)?.onResizedEvent()
+					is AppEvent.RedrawNeeded -> runtime.windowFor(vEvent.windowId)?.let { it.needsFrame = true }
+					is AppEvent.SystemThemeChanged -> for (vW in runtime.windows) vW.onSystemThemeChanged()
+					is AppEvent.WindowActivation -> runtime.windowFor(vEvent.windowId)?.onActivationEvent(vEvent)
+					is AppEvent.Pointer -> runtime.windowFor(vEvent.windowId)?.onPointerEvent(vEvent)
+					is AppEvent.PointerExit -> runtime.windowFor(vEvent.windowId)?.onPointerExit()
+					is AppEvent.MouseWheel -> runtime.windowFor(vEvent.windowId)?.onWheelEvent(vEvent)
+					is AppEvent.Key -> runtime.windowFor(vEvent.windowId)?.onKeyEvent(vEvent)
+					is AppEvent.TextInput -> runtime.windowFor(vEvent.windowId)?.onTextInputEvent(vEvent)
+					is AppEvent.TextEditing -> runtime.windowFor(vEvent.windowId)?.onTextEditingEvent(vEvent)
+					is AppEvent.Drop -> runtime.windowFor(vEvent.windowId)?.onDropEvent(vEvent)
+				}
+			}
+
+			mainDispatcher.drainPending()
+			FrameProfiler.phase("events")
+
+			// ============
+			//  App composition pump - Window()s may appear / disappear here.
+			Snapshot.sendApplyNotifications()
+			appClock.sendFrame(frameClockNanos())
+			yield()
+			runtime.reapDestroyed()
+
+			// Window content can flip window.close() / probes can end the app.
+			for (vW in runtime.windows.toList()) {
+				if (vW.facade.isCloseRequested && !vW.closeDispatched) {
+					vW.closeDispatched = true
+					vW.onCloseRequest()
+				}
+			}
+
+			// Exit when the last window is gone (after at least one existed).
+			if (runtime.hadWindow && runtime.windows.isEmpty()) runtime.exitRequested = true
+			if (runtime.exitRequested) break
+			FrameProfiler.phase("app")
+
+			// ============
+			//  Per-window pump + render.
+			var vAnyRendered = false
+			var vAllVsync = true
+			// Non-vsync fallback cap: the shortest frame interval among the
+			// rendered non-vsync windows' displays (60Hz default). Only used when
+			// no window is vsync-paced (Software renderer / vsync unavailable).
+			var vFallbackDelayMs = 16u
+			val vAppPending = appRecomposer.hasPendingWork
+			for (vW in runtime.windows.toList()) {
+				vW.installGlobals()
+				vW.host.sendAnimationFrame(animationClockNanos())
+				mainDispatcher.drainPending()
+				Snapshot.sendApplyNotifications()
+				vW.frameClock.sendFrame(frameClockNanos())
+				yield()
+				FrameProfiler.phase("pump")
+				if (vW.shouldRender()) {
+					vW.renderFrame()
+					vAnyRendered = true
+					if (!vW.backend.vsyncEnabled) {
+						vAllVsync = false
+						vFallbackDelayMs = minOf(vFallbackDelayMs, displayFrameDelayMs(vW.backend.window))
+					}
+				}
+				FrameProfiler.phase("render")
+			}
+			runtime.reapDestroyed()
+			FrameProfiler.frameDone(vAnyRendered)
+
+			// ============
+			//  Drain deferred native-resource disposals on the MAIN thread -
+			//  textures/surfaces whose owner closed them or whose Cleaner fired
+			//  on a GC worker enqueue here (SDL calls aren't thread-safe). This
+			//  is the ownership path that makes the GC nudge below a mere
+			//  backstop (ROADMAP.md item 1).
+			com.compose.sdl.graphics.NativeReleaseQueue.drain()
+
+			// ============
+			//  Pace / idle-skip.
+			if (vAnyRendered) {
+				SDL_Delay(if (vAllVsync) 1u else vFallbackDelayMs)
+			} else if (!vAppPending) {
+				// Nothing invalidated anywhere: block for events instead of
+				// spinning. A real input/redraw event wakes this immediately; the
+				// timeout only bounds how often async work (dispatcher/timers) is
+				// re-checked while truly idle, so keep it coarse to cut wakeups.
+				SDL_WaitEventTimeout(null, 100)
+				for (vW in runtime.windows) vW.resetFpsWindow()
+			} else {
+				// App composition has pending work but nothing rendered this
+				// iteration - yield briefly instead of spinning at full speed
+				// until the composition settles into a renderable state.
+				SDL_Delay(1u)
+			}
+
+			// ============
+			//  Native-memory nudge. Renderer resources (Skia surfaces / images /
+			//  fonts, SDL textures) are freed by Cleaners that only run when the
+			//  Kotlin/Native GC collects - and a Compose app's Kotlin heap is
+			//  small enough that the allocation-driven scheduler can starve them
+			//  for minutes while the NATIVE heap balloons (issue #2: memory
+			//  "never released" while navigating). Collect periodically, only
+			//  after rendering activity, between frames; costs ~ms at these
+			//  heap sizes and keeps RSS tracking real usage.
+			if (vAnyRendered) vRenderedSinceGc = true
+			val vNowTicks = SDL_GetTicks()
+			if (vRenderedSinceGc && vNowTicks - vGcLastTicks >= 10_000uL) {
+				vGcLastTicks = vNowTicks
+				vRenderedSinceGc = false
+				collectNativeGarbage()
+			}
+		}
+
+		// ============
+		//  Teardown
+		snapshotHandle.dispose()
+		for (vW in runtime.windows.toList()) runtime.scheduleDestroy(vW)
+		runtime.reapDestroyed()
+		com.compose.sdl.graphics.NativeReleaseQueue.drain()
+		appComposition.dispose()
+		appRecomposer.cancel()
+		appRecomposeJob.cancelAndJoin()
+	}
+
+	mainDispatcher.close()
+	@OptIn(ExperimentalCoroutinesApi::class)
+	Dispatchers.resetMain()
+
+	SDL_Quit()
+}
+
+/** Single-window compatibility wrapper - the pre-multi-window entry point.
+   Closing the window exits the app, exactly as before. */
+fun nativeComposeWindow(
+	title: String = "ComposeNativeSDL3",
+	width: Int = 800,
+	height: Int = 600,
+	gpu: GpuMode = GpuMode.Auto,
+	icon: AppWindowIcon? = null,
+	undecorated: Boolean = false,
+	transparent: Boolean = false,
+	resizable: Boolean = true,
+	enabled: Boolean = true,
+	focusable: Boolean = true,
+	alwaysOnTop: Boolean = false,
+	onPreviewKeyEvent: (KeyEvent) -> Boolean = { false },
+	onKeyEvent: (KeyEvent) -> Boolean = { false },
+	onFrame: ((backend: RenderBackend, frameIndex: Int) -> Boolean)? = null,
+	content: @Composable ComposeWindowScope.() -> Unit,
+) {
+	nativeComposeApp {
+		Window(
+			onCloseRequest = { exitApplication() },
+			title = title,
+			width = width,
+			height = height,
+			gpu = gpu,
+			icon = icon,
+			undecorated = undecorated,
+			transparent = transparent,
+			resizable = resizable,
+			enabled = enabled,
+			focusable = focusable,
+			alwaysOnTop = alwaysOnTop,
+			onPreviewKeyEvent = onPreviewKeyEvent,
+			onKeyEvent = onKeyEvent,
+			onFrame = onFrame,
+			content = content,
+		)
+	}
+}
@@ -18,56 +18,56 @@ import sdl3.SDL_GetTicks
@OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
 internal object FrameProfiler {
 	// null until first checked; then true/false for the run's lifetime.
-	private var fEnabled: Boolean? = null
+	private var mEnabled: Boolean? = null
 	// Output file - resolved once from CDN_PROFILE. Writing to a file (not
 	// stdout) lets GUI-subsystem apps (the demo links --subsystem,windows, so
 	// it has no console) be profiled too. CDN_PROFILE=1 → "cdn_profile.log" in
 	// the cwd; CDN_PROFILE=<path> → that path.
-	private var fPath: String = "cdn_profile.log"
+	private var mPath: String = "cdn_profile.log"
 	val enabled: Boolean
-		get() = fEnabled ?: run {
+		get() = mEnabled ?: run {
 			val vEnv = platform.posix.getenv("CDN_PROFILE")?.toKString()
-			if (vEnv != null && vEnv != "1" && vEnv.isNotEmpty()) fPath = vEnv
-			(vEnv != null).also { fEnabled = it }
+			if (vEnv != null && vEnv != "1" && vEnv.isNotEmpty()) mPath = vEnv
+			(vEnv != null).also { mEnabled = it }
 		}

-	private val fFreq = SDL_GetPerformanceFrequency().toDouble()
+	private val mFreq = SDL_GetPerformanceFrequency().toDouble()
 	// Insertion-ordered so the printed line follows the call order.
-	private val fSum = LinkedHashMap<String, Double>()
-	private val fMax = LinkedHashMap<String, Double>()
-	private var fFrames = 0
-	private var fLastPrintMs = SDL_GetTicks()
-	private var fMark = 0uL
+	private val mSum = LinkedHashMap<String, Double>()
+	private val mMax = LinkedHashMap<String, Double>()
+	private var mFrames = 0
+	private var mLastPrintMs = SDL_GetTicks()
+	private var mMark = 0uL

-	fun mark() { if (enabled) fMark = SDL_GetPerformanceCounter() }
+	fun mark() { if (enabled) mMark = SDL_GetPerformanceCounter() }

 	fun phase(inName: String) {
 		if (!enabled) return
 		val vNow = SDL_GetPerformanceCounter()
-		val vMs = (vNow - fMark).toDouble() * 1000.0 / fFreq
-		fSum[inName] = (fSum[inName] ?: 0.0) + vMs
-		if (vMs > (fMax[inName] ?: 0.0)) fMax[inName] = vMs
-		fMark = vNow
+		val vMs = (vNow - mMark).toDouble() * 1000.0 / mFreq
+		mSum[inName] = (mSum[inName] ?: 0.0) + vMs
+		if (vMs > (mMax[inName] ?: 0.0)) mMax[inName] = vMs
+		mMark = vNow
 	}

 	fun frameDone(inRendered: Boolean) {
 		if (!enabled) return
-		if (inRendered) fFrames++
+		if (inRendered) mFrames++
 		val vNowMs = SDL_GetTicks()
-		if (vNowMs - fLastPrintMs >= 2000u && fFrames > 0) {
-			val vParts = fSum.keys.map { vName ->
-				val vAvg = (fSum[vName] ?: 0.0) / fFrames
-				"$vName=${(vAvg * 100).toInt() / 100.0}/${((fMax[vName] ?: 0.0) * 100).toInt() / 100.0}ms"
+		if (vNowMs - mLastPrintMs >= 2000u && mFrames > 0) {
+			val vParts = mSum.keys.map { vName ->
+				val vAvg = (mSum[vName] ?: 0.0) / mFrames
+				"$vName=${(vAvg * 100).toInt() / 100.0}/${((mMax[vName] ?: 0.0) * 100).toInt() / 100.0}ms"
 			}
-			val vLine = "[profile] frames=$fFrames avg/max " + vParts.joinToString(" ") + "\n"
-			val vFile = platform.posix.fopen(fPath, "a")
+			val vLine = "[profile] frames=$mFrames avg/max " + vParts.joinToString(" ") + "\n"
+			val vFile = platform.posix.fopen(mPath, "a")
 			if (vFile != null) {
 				platform.posix.fputs(vLine, vFile)
 				platform.posix.fclose(vFile)
 			}
-			fSum.clear(); fMax.clear()
-			fFrames = 0
-			fLastPrintMs = vNowMs
+			mSum.clear(); mMax.clear()
+			mFrames = 0
+			mLastPrintMs = vNowMs
 		}
 	}
 }
@@ -0,0 +1,83 @@
+@file:OptIn(
+	androidx.compose.ui.InternalComposeUiApi::class,
+	androidx.compose.runtime.InternalComposeApi::class,
+)
+
+package com.compose.sdl
+
+import kotlinx.cinterop.COpaquePointer
+import kotlinx.cinterop.reinterpret
+import kotlinx.cinterop.pointed
+import kotlinx.coroutines.CancellationException
+import sdl3.SDL_GetCurrentDisplayMode
+import sdl3.SDL_GetDisplayForWindow
+import sdl3.SDL_GetTicks
+import sdl3.SDL_GetTicksNS
+
+// ==================
+// MARK: Deterministic frame timing + probe/screenshot support
+// ==================
+
+/** Set BEFORE nativeComposeApp/nativeComposeWindow: every window's composition then runs
+   under an InfiniteAnimationPolicy that CANCELS infinite animations, so
+   rememberInfiniteTransition & co. freeze at their initial value - the same mechanism
+   upstream's test rules use. Screenshot/parity runs enable it so looping screens can
+   reach quiescence and capture deterministically. */
+var disableInfiniteAnimations: Boolean = false
+
+/** The cancelling policy: a coroutine that ends in CancellationException counts as
+   cancelled (not failed), so only the animation coroutine stops - nothing propagates. */
+internal object CancelInfiniteAnimationsPolicy : androidx.compose.ui.platform.InfiniteAnimationPolicy {
+	override suspend fun <R> onInfiniteOperation(block: suspend () -> R): R =
+		throw CancellationException("infinite animations are disabled (disableInfiniteAnimations)")
+}
+
+/** Set BEFORE nativeComposeApp/nativeComposeWindow: the composition + animation frame
+   clocks advance a VIRTUAL 16.6ms per main-loop iteration instead of reading SDL's
+   real-time ticks - the native mirror of the JVM parity leg's render(nanos) stepping.
+   Animations then progress by exact per-frame deltas, so anything time-raced (e.g. a
+   bring-into-view scroll interrupted mid-flight) resolves identically on every run and
+   screenshots become deterministic. Input timestamps and FPS stay on real time. */
+var useVirtualFrameTime: Boolean = false
+
+private var virtualFrameNanos = 0L
+
+internal fun advanceVirtualFrame() {
+	if (useVirtualFrameTime) virtualFrameNanos += 16_666_667L
+}
+
+// Timestamp for the composition frame clocks (recomposer + withFrameNanos animations).
+internal fun frameClockNanos(): Long =
+	if (useVirtualFrameTime) virtualFrameNanos else SDL_GetTicksNS().toLong()
+
+// Timestamp for the owner's node-animation clock - real path keeps the pre-existing
+// ms-resolution SDL_GetTicks base so non-screenshot behaviour is bit-for-bit unchanged.
+internal fun animationClockNanos(): Long =
+	if (useVirtualFrameTime) virtualFrameNanos else SDL_GetTicks().toLong() * 1_000_000L
+
+// The window currently inside renderFrame - the loop is single-threaded, so a plain
+// var is enough for onFrame probes to address "the window I'm being called for".
+internal var renderingWindow: WindowInstance? = null
+
+/** From inside an onFrame callback: true while the just-rendered window still has pending
+   work (recomposition, layout/draw invalidation, or an animation awaiting the next frame).
+   Screenshot probes capture once this stays false for a few consecutive frames instead of
+   at a fixed frame count. Outside onFrame it answers false. */
+fun windowHasInvalidations(): Boolean = renderingWindow?.hasInvalidations() ?: false
+
+/** Trigger a Kotlin/Native GC so Cleaner-managed renderer resources release
+   their native memory (see the main loop's native-memory nudge). */
+@OptIn(kotlin.native.runtime.NativeRuntimeApi::class)
+internal fun collectNativeGarbage() = kotlin.native.runtime.GC.collect()
+
+/** Frame interval (ms) of the window's current display, for the non-vsync
+   fallback pacing (SDL_Delay). Falls back to 16ms (~60Hz) when the mode can't
+   be read, so a 144Hz panel on a non-vsync path isn't capped to 60. */
+@OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
+internal fun displayFrameDelayMs(window: COpaquePointer?): UInt {
+	val vWindow = window ?: return 16u
+	val vDisplay = SDL_GetDisplayForWindow(vWindow.reinterpret())
+	val vMode = SDL_GetCurrentDisplayMode(vDisplay) ?: return 16u
+	val vHz = vMode.pointed.refresh_rate
+	return if (vHz > 0f) (1000f / vHz).toUInt().coerceAtLeast(1u) else 16u
+}
@@ -20,7 +20,7 @@ import sdl3.SDL_GetTicksNS

   Both come from delegating to the runtime's BroadcastFrameClock, which is
   exactly upstream's dispatch structure. */
-internal class SDL3FrameClock : MonotonicFrameClock {
+internal class Sdl3FrameClock : MonotonicFrameClock {
 	private val broadcast = BroadcastFrameClock()

 	override suspend fun <R> withFrameNanos(onFrame: (Long) -> R): R =
@@ -36,16 +36,16 @@ import sdl3.SDL_GetCurrentThreadID
   writes land at the loop's drainPending(), observable on the same frame. */
 internal class Sdl3MainDispatcher : MainCoroutineDispatcher() {

-	private val fQueue = Channel<Runnable>(Channel.UNLIMITED)
+	private val mQueue = Channel<Runnable>(Channel.UNLIMITED)

 	// The SDL main thread - the dispatcher is constructed by nativeComposeApp
 	// on the thread that then runs the loop.
-	private val fMainThreadId = SDL_GetCurrentThreadID()
+	private val mMainThreadId = SDL_GetCurrentThreadID()

 	override val immediate: MainCoroutineDispatcher = ImmediateDispatcher()

 	override fun dispatch(context: CoroutineContext, block: Runnable) {
-		fQueue.trySend(block)
+		mQueue.trySend(block)
 	}

 	/** Drains all pending tasks. Called from the SDL3 main loop once per
@@ -54,7 +54,7 @@ internal class Sdl3MainDispatcher : MainCoroutineDispatcher() {
 	   composition. */
 	fun drainPending() {
 		while (true) {
-			val vTask = fQueue.tryReceive().getOrNull() ?: break
+			val vTask = mQueue.tryReceive().getOrNull() ?: break
 			runCatching { vTask.run() }.onFailure { vErr ->
 				println("Sdl3MainDispatcher: dispatched task threw: ${vErr.message}")
 			}
@@ -64,7 +64,7 @@ internal class Sdl3MainDispatcher : MainCoroutineDispatcher() {
 	/** Closes the queue. After this, dispatch() drops new posts silently.
 	   Called from nativeComposeWindow as part of shutdown. */
 	fun close() {
-		fQueue.close()
+		mQueue.close()
 	}

 	override fun toString(): String = "Sdl3MainDispatcher"
@@ -75,10 +75,10 @@ internal class Sdl3MainDispatcher : MainCoroutineDispatcher() {
 		override val immediate: MainCoroutineDispatcher get() = this

 		override fun isDispatchNeeded(context: CoroutineContext): Boolean =
-			SDL_GetCurrentThreadID() != fMainThreadId
+			SDL_GetCurrentThreadID() != mMainThreadId

 		override fun dispatch(context: CoroutineContext, block: Runnable) {
-			fQueue.trySend(block)
+			mQueue.trySend(block)
 		}

 		override fun toString(): String = "Sdl3MainDispatcher.immediate"
@@ -0,0 +1,31 @@
+package com.compose.sdl
+
+// ==================
+// MARK: WindowAttributes
+// ==================
+
+/**
+ The Compose Desktop `Window()` attributes this port supports, bundled so they
+ travel as one value from the composable down to [WindowInstance] instead of as
+ six positional booleans.
+
+ [transparent] is creation-only: SDL needs "SDL_WINDOW_TRANSPARENT" at
+ "SDL_CreateWindow" time and offers no setter, so changing it after the window
+ exists has no effect. The rest are re-applied whenever "Window()" recomposes
+ with a new value.
+ */
+internal data class WindowAttributes(
+	/** Hides the title bar and border (`SDL_WINDOW_BORDERLESS`). */
+	val undecorated: Boolean = false,
+	/** Per-pixel alpha for the window surface. CREATION-ONLY - see above. */
+	val transparent: Boolean = false,
+	/** Whether the user can resize the window. */
+	val resizable: Boolean = true,
+	/** False drops input (pointer / key / text / wheel / drop) while the window
+	   keeps rendering - Compose Desktop's `enabled = false` behaviour. */
+	val enabled: Boolean = true,
+	/** False stops the window taking keyboard focus when clicked or raised. */
+	val focusable: Boolean = true,
+	/** Keeps the window above other windows. */
+	val alwaysOnTop: Boolean = false,
+)
@@ -7,19 +7,14 @@ package com.compose.sdl

 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.runtime.AbstractApplier
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.Composition
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.Recomposer
-import androidx.compose.runtime.SideEffect
-import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.snapshots.Snapshot
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.input.key.key
-import androidx.compose.ui.input.key.type
+import androidx.compose.ui.input.key.KeyEvent
 import androidx.compose.ui.input.pointer.PointerButton
 import androidx.compose.ui.input.pointer.PointerEventType
 import com.compose.sdl.node.ComposeRootHost
@@ -27,454 +22,14 @@ import com.compose.sdl.res.currentImageLoader
 import com.compose.sdl.window.LocalPopupHost
 import com.compose.sdl.window.PopupLayer
 import com.compose.sdl.window.createPopupHostState
-import kotlinx.coroutines.*
-import kotlinx.coroutines.test.resetMain
-import kotlinx.coroutines.test.setMain
-import kotlinx.cinterop.toKString
-import kotlinx.cinterop.reinterpret
 import kotlinx.cinterop.alloc
 import kotlinx.cinterop.ptr
-import kotlinx.cinterop.COpaquePointer
-import kotlinx.cinterop.pointed
-import sdl3.SDL_Delay
-import sdl3.SDL_GetCurrentDisplayMode
-import sdl3.SDL_GetDisplayForWindow
-import sdl3.SDL_GetPerformanceCounter
-import sdl3.SDL_GetPerformanceFrequency
+import kotlinx.cinterop.reinterpret
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
 import sdl3.SDL_GetTicks
-import sdl3.SDL_GetTicksNS
-import sdl3.SDL_Quit
 import sdl3.SDL_SetWindowTitle
-import sdl3.SDL_WaitEventTimeout
-
-// ==================
-// MARK: Application entry - nativeComposeApp + Window()
-// ==================
-
-/**
- Multi-window entry point, shaped like Compose Desktop's `application {}`:
-
-     nativeComposeApp {
-         var showTools by remember { mutableStateOf(false) }
-         Window(onCloseRequest = ::exitApplication, title = "Main") { MainUi(onTools = { showTools = true }) }
-         if (showTools) Window(onCloseRequest = { showTools = false }, title = "Tools") { ToolsUi() }
-     }
-
- The app CONTENT is itself a composition (no UI tree - a Unit applier): each
- `Window(...)` call materialises an SDL window + renderer + root host + its own
- recomposer/composition, and leaving the composition (state flips to false)
- tears the window down. One main loop pumps the shared SDL event queue and
- routes events per SDL window id.
-
- Per-window pumping order matters: the render-bridge globals
- (currentImageLoader / viewport) are per-renderer, so the
- loop installs a window's globals before recomposing / laying out / drawing it.
-
- `nativeComposeWindow(...)` remains as the single-window wrapper (all demo
- probes and apidemo ride it unchanged).
-*/
-
-interface ApplicationScope {
-	/** Requests the main loop to exit after the current iteration (all windows
-	   are torn down on the way out). */
-	fun exitApplication()
-}
-
-/** Declares one native window for as long as this composable stays in the app
-   composition. `onCloseRequest` fires when the user asks the window to close
-   (OS close button, or `window.close()` from content) - remove the state that
-   composes this Window to actually close it, or call exitApplication(). */
-@Composable
-fun ApplicationScope.Window(
-	onCloseRequest: () -> Unit,
-	title: String = "ComposeNativeSDL3",
-	width: Int = 800,
-	height: Int = 600,
-	gpu: GpuMode = GpuMode.Auto,
-	icon: AppWindowIcon? = null,
-	onFrame: ((backend: RenderBackend, frameIndex: Int) -> Boolean)? = null,
-	content: @Composable ComposeWindowScope.() -> Unit,
-) {
-	val vScope = this as? ApplicationScopeImpl
-		?: error("Window() must be called inside nativeComposeApp { ... }")
-	val vContent = rememberUpdatedState(content)
-	val vClose = rememberUpdatedState(onCloseRequest)
-	val vWindow = remember {
-		vScope.runtime.createWindow(
-			inTitle = title,
-			inWidth = width,
-			inHeight = height,
-			inGpu = gpu,
-			inIcon = icon,
-			inOnFrame = onFrame,
-			// The window composition reads the holder each recomposition, so
-			// updated content lambdas propagate without recreating the window.
-			inContent = { vContent.value },
-		).also { it.onCloseRequest = { vClose.value.invoke() } }
-	}
-	SideEffect {
-		if (vWindow.facade.title != title) vWindow.facade.setTitle(title)
-	}
-	DisposableEffect(Unit) {
-		onDispose { vScope.runtime.scheduleDestroy(vWindow) }
-	}
-}
-
-/** Boots SDL + the Compose runtime, runs `content` as the application
-   composition, and drives every declared Window until exitApplication() or
-   the last window closes. */
-fun nativeComposeApp(content: @Composable ApplicationScope.() -> Unit) {
-	// Install the Main dispatcher BEFORE any window/owner exists: ComposeOwner
-	// captures Dispatchers.Main eagerly for its per-node coroutine scopes.
-	val mainDispatcher = Sdl3MainDispatcher()
-	@OptIn(ExperimentalCoroutinesApi::class)
-	Dispatchers.setMain(mainDispatcher)
-
-	val runtime = AppRuntime()
-
-	runBlocking {
-		runtime.scope = this
-
-		// App-level composition: no UI tree - it only declares Window()s.
-		val appClock = SDL3FrameClock()
-		val appRecomposer = Recomposer(coroutineContext + appClock)
-		// The clock must be in the collector's context - runRecomposeAndApplyChanges
-		// awaits parent frames through it.
-		val appRecomposeJob = launch(appClock) { appRecomposer.runRecomposeAndApplyChanges() }
-		val appComposition = Composition(UnitApplier(), appRecomposer)
-		val appScope = ApplicationScopeImpl(runtime)
-
-		val snapshotHandle = Snapshot.registerGlobalWriteObserver {
-			// Only SCHEDULE a frame here; the apply is coalesced to once per loop
-			// iteration (top of loop + before each pump + before layout in
-			// renderFrame) instead of walking every snapshot observer on every
-			// individual state write. Mirrors upstream GlobalSnapshotManager,
-			// which schedules rather than applying inline.
-			runtime.markAllNeedFrame()
-		}
-
-		appComposition.setContent { appScope.content() }
-		// Compose the initial Window() declarations before entering the loop.
-		appClock.sendFrame(frameClockNanos())
-		yield()
-
-		// ============
-		//  Main loop
-		var vGcLastTicks = SDL_GetTicks()
-		var vRenderedSinceGc = false
-		while (!runtime.exitRequested) {
-			FrameProfiler.mark()
-			// One virtual 16.6ms tick per loop iteration (no-op unless useVirtualFrameTime) -
-			// all windows' clocks share the same timestamp this iteration.
-			advanceVirtualFrame()
-			Snapshot.sendApplyNotifications()
-
-			// ============
-			//  Events - one shared SDL queue, routed by window id.
-			val vEvents = pollEvents()
-			for (vEvent in vEvents) {
-				when (vEvent) {
-					is AppEvent.Quit -> {
-						// Platform quit = close request on every window; any
-						// veto (setOnCloseRequest returning false) keeps the
-						// app alive. No windows at all → plain exit.
-						if (runtime.windows.isEmpty()) runtime.exitRequested = true
-						else for (vW in runtime.windows.toList()) vW.requestClose()
-					}
-					is AppEvent.WindowClose -> runtime.windowFor(vEvent.windowId)?.requestClose()
-					is AppEvent.WindowResized -> runtime.windowFor(vEvent.windowId)?.onResizedEvent()
-					is AppEvent.RedrawNeeded -> runtime.windowFor(vEvent.windowId)?.let { it.needsFrame = true }
-					is AppEvent.SystemThemeChanged -> for (vW in runtime.windows) vW.onSystemThemeChanged()
-					is AppEvent.WindowActivation -> runtime.windowFor(vEvent.windowId)?.onActivationEvent(vEvent)
-					is AppEvent.Pointer -> runtime.windowFor(vEvent.windowId)?.onPointerEvent(vEvent)
-					is AppEvent.PointerExit -> runtime.windowFor(vEvent.windowId)?.onPointerExit()
-					is AppEvent.MouseWheel -> runtime.windowFor(vEvent.windowId)?.onWheelEvent(vEvent)
-					is AppEvent.Key -> runtime.windowFor(vEvent.windowId)?.onKeyEvent(vEvent)
-					is AppEvent.TextInput -> runtime.windowFor(vEvent.windowId)?.onTextInputEvent(vEvent)
-					is AppEvent.TextEditing -> runtime.windowFor(vEvent.windowId)?.onTextEditingEvent(vEvent)
-					is AppEvent.Drop -> runtime.windowFor(vEvent.windowId)?.onDropEvent(vEvent)
-				}
-			}
-
-			mainDispatcher.drainPending()
-			FrameProfiler.phase("events")
-
-			// ============
-			//  App composition pump - Window()s may appear / disappear here.
-			Snapshot.sendApplyNotifications()
-			appClock.sendFrame(frameClockNanos())
-			yield()
-			runtime.reapDestroyed()
-
-			// Window content can flip window.close() / probes can end the app.
-			for (vW in runtime.windows.toList()) {
-				if (vW.facade.isCloseRequested && !vW.closeDispatched) {
-					vW.closeDispatched = true
-					vW.onCloseRequest()
-				}
-			}
-
-			// Exit when the last window is gone (after at least one existed).
-			if (runtime.hadWindow && runtime.windows.isEmpty()) runtime.exitRequested = true
-			if (runtime.exitRequested) break
-			FrameProfiler.phase("app")
-
-			// ============
-			//  Per-window pump + render.
-			var vAnyRendered = false
-			var vAllVsync = true
-			// Non-vsync fallback cap: the shortest frame interval among the
-			// rendered non-vsync windows' displays (60Hz default). Only used when
-			// no window is vsync-paced (Software renderer / vsync unavailable).
-			var vFallbackDelayMs = 16u
-			val vAppPending = appRecomposer.hasPendingWork
-			for (vW in runtime.windows.toList()) {
-				vW.installGlobals()
-				vW.host.sendAnimationFrame(animationClockNanos())
-				mainDispatcher.drainPending()
-				Snapshot.sendApplyNotifications()
-				vW.frameClock.sendFrame(frameClockNanos())
-				yield()
-				FrameProfiler.phase("pump")
-				if (vW.shouldRender()) {
-					vW.renderFrame()
-					vAnyRendered = true
-					if (!vW.backend.vsyncEnabled) {
-						vAllVsync = false
-						vFallbackDelayMs = minOf(vFallbackDelayMs, displayFrameDelayMs(vW.backend.window))
-					}
-				}
-				FrameProfiler.phase("render")
-			}
-			runtime.reapDestroyed()
-			FrameProfiler.frameDone(vAnyRendered)
-
-			// ============
-			//  Drain deferred native-resource disposals on the MAIN thread -
-			//  textures/surfaces whose owner closed them or whose Cleaner fired
-			//  on a GC worker enqueue here (SDL calls aren't thread-safe). This
-			//  is the ownership path that makes the GC nudge below a mere
-			//  backstop (ROADMAP.md item 1).
-			com.compose.sdl.graphics.NativeReleaseQueue.drain()
-
-			// ============
-			//  Pace / idle-skip.
-			if (vAnyRendered) {
-				SDL_Delay(if (vAllVsync) 1u else vFallbackDelayMs)
-			} else if (!vAppPending) {
-				// Nothing invalidated anywhere: block for events instead of
-				// spinning. A real input/redraw event wakes this immediately; the
-				// timeout only bounds how often async work (dispatcher/timers) is
-				// re-checked while truly idle, so keep it coarse to cut wakeups.
-				SDL_WaitEventTimeout(null, 100)
-				for (vW in runtime.windows) vW.resetFpsWindow()
-			} else {
-				// App composition has pending work but nothing rendered this
-				// iteration - yield briefly instead of spinning at full speed
-				// until the composition settles into a renderable state.
-				SDL_Delay(1u)
-			}
-
-			// ============
-			//  Native-memory nudge. Renderer resources (Skia surfaces / images /
-			//  fonts, SDL textures) are freed by Cleaners that only run when the
-			//  Kotlin/Native GC collects - and a Compose app's Kotlin heap is
-			//  small enough that the allocation-driven scheduler can starve them
-			//  for minutes while the NATIVE heap balloons (issue #2: memory
-			//  "never released" while navigating). Collect periodically, only
-			//  after rendering activity, between frames; costs ~ms at these
-			//  heap sizes and keeps RSS tracking real usage.
-			if (vAnyRendered) vRenderedSinceGc = true
-			val vNowTicks = SDL_GetTicks()
-			if (vRenderedSinceGc && vNowTicks - vGcLastTicks >= 10_000uL) {
-				vGcLastTicks = vNowTicks
-				vRenderedSinceGc = false
-				collectNativeGarbage()
-			}
-		}
-
-		// ============
-		//  Teardown
-		snapshotHandle.dispose()
-		for (vW in runtime.windows.toList()) runtime.scheduleDestroy(vW)
-		runtime.reapDestroyed()
-		com.compose.sdl.graphics.NativeReleaseQueue.drain()
-		appComposition.dispose()
-		appRecomposer.cancel()
-		appRecomposeJob.cancelAndJoin()
-	}
-
-	mainDispatcher.close()
-	@OptIn(ExperimentalCoroutinesApi::class)
-	Dispatchers.resetMain()
-
-	SDL_Quit()
-}
-
-// ==================
-// MARK: Probe / screenshot support (render-to-quiescence)
-// ==================
-
-/** Set BEFORE nativeComposeApp/nativeComposeWindow: every window's composition then runs
-   under an InfiniteAnimationPolicy that CANCELS infinite animations, so
-   rememberInfiniteTransition & co. freeze at their initial value - the same mechanism
-   upstream's test rules use. Screenshot/parity runs enable it so looping screens can
-   reach quiescence and capture deterministically. */
-var disableInfiniteAnimations: Boolean = false
-
-/** The cancelling policy: a coroutine that ends in CancellationException counts as
-   cancelled (not failed), so only the animation coroutine stops - nothing propagates. */
-private object CancelInfiniteAnimationsPolicy : androidx.compose.ui.platform.InfiniteAnimationPolicy {
-	override suspend fun <R> onInfiniteOperation(block: suspend () -> R): R =
-		throw CancellationException("infinite animations are disabled (disableInfiniteAnimations)")
-}
-
-/** Set BEFORE nativeComposeApp/nativeComposeWindow: the composition + animation frame
-   clocks advance a VIRTUAL 16.6ms per main-loop iteration instead of reading SDL's
-   real-time ticks - the native mirror of the JVM parity leg's render(nanos) stepping.
-   Animations then progress by exact per-frame deltas, so anything time-raced (e.g. a
-   bring-into-view scroll interrupted mid-flight) resolves identically on every run and
-   screenshots become deterministic. Input timestamps and FPS stay on real time. */
-var useVirtualFrameTime: Boolean = false
-
-private var virtualFrameNanos = 0L
-
-private fun advanceVirtualFrame() {
-	if (useVirtualFrameTime) virtualFrameNanos += 16_666_667L
-}
-
-// Timestamp for the composition frame clocks (recomposer + withFrameNanos animations).
-private fun frameClockNanos(): Long =
-	if (useVirtualFrameTime) virtualFrameNanos else SDL_GetTicksNS().toLong()
-
-// Timestamp for the owner's node-animation clock - real path keeps the pre-existing
-// ms-resolution SDL_GetTicks base so non-screenshot behaviour is bit-for-bit unchanged.
-private fun animationClockNanos(): Long =
-	if (useVirtualFrameTime) virtualFrameNanos else SDL_GetTicks().toLong() * 1_000_000L
-
-// The window currently inside renderFrame - the loop is single-threaded, so a plain
-// var is enough for onFrame probes to address "the window I'm being called for".
-private var renderingWindow: WindowInstance? = null
-
-/** From inside an onFrame callback: true while the just-rendered window still has pending
-   work (recomposition, layout/draw invalidation, or an animation awaiting the next frame).
-   Screenshot probes capture once this stays false for a few consecutive frames instead of
-   at a fixed frame count. Outside onFrame it answers false. */
-fun windowHasInvalidations(): Boolean = renderingWindow?.hasInvalidations() ?: false
-
-/** Trigger a Kotlin/Native GC so Cleaner-managed renderer resources release
-   their native memory (see the main loop's native-memory nudge). */
-@OptIn(kotlin.native.runtime.NativeRuntimeApi::class)
-private fun collectNativeGarbage() = kotlin.native.runtime.GC.collect()
-
-/** Frame interval (ms) of the window's current display, for the non-vsync
-   fallback pacing (SDL_Delay). Falls back to 16ms (~60Hz) when the mode can't
-   be read, so a 144Hz panel on a non-vsync path isn't capped to 60. */
-@OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
-private fun displayFrameDelayMs(window: COpaquePointer?): UInt {
-	val vWindow = window ?: return 16u
-	val vDisplay = SDL_GetDisplayForWindow(vWindow.reinterpret())
-	val vMode = SDL_GetCurrentDisplayMode(vDisplay) ?: return 16u
-	val vHz = vMode.pointed.refresh_rate
-	return if (vHz > 0f) (1000f / vHz).toUInt().coerceAtLeast(1u) else 16u
-}
-
-/** Single-window compatibility wrapper - the pre-multi-window entry point.
-   Closing the window exits the app, exactly as before. */
-fun nativeComposeWindow(
-	title: String = "ComposeNativeSDL3",
-	width: Int = 800,
-	height: Int = 600,
-	gpu: GpuMode = GpuMode.Auto,
-	icon: AppWindowIcon? = null,
-	onFrame: ((backend: RenderBackend, frameIndex: Int) -> Boolean)? = null,
-	content: @Composable ComposeWindowScope.() -> Unit,
-) {
-	nativeComposeApp {
-		Window(
-			onCloseRequest = { exitApplication() },
-			title = title,
-			width = width,
-			height = height,
-			gpu = gpu,
-			icon = icon,
-			onFrame = onFrame,
-			content = content,
-		)
-	}
-}
-
-// ==================
-// MARK: App runtime internals
-// ==================
-
-internal class ApplicationScopeImpl(val runtime: AppRuntime) : ApplicationScope {
-	override fun exitApplication() { runtime.exitRequested = true }
-}
-
-/** Registry + lifecycle for the live windows. Windows are created by the app
-   composition (Window()'s remember) and destroyed by the LOOP - DisposableEffect
-   onDispose only schedules, because teardown disposes a composition and that
-   must not run re-entrantly inside another composition's apply pass. */
-internal class AppRuntime {
-	lateinit var scope: CoroutineScope
-	val windows = mutableListOf<WindowInstance>()
-	private val destroyQueue = mutableListOf<WindowInstance>()
-	var exitRequested = false
-	var hadWindow = false
-
-	fun windowFor(inId: UInt): WindowInstance? =
-		if (inId == 0u) windows.firstOrNull()
-		else windows.firstOrNull { it.backend.windowId == inId } ?: windows.firstOrNull()
-
-	fun markAllNeedFrame() {
-		for (vW in windows) vW.needsFrame = true
-	}
-
-	fun createWindow(
-		inTitle: String,
-		inWidth: Int,
-		inHeight: Int,
-		inGpu: GpuMode,
-		inIcon: AppWindowIcon?,
-		inOnFrame: ((RenderBackend, Int) -> Boolean)?,
-		inContent: () -> (@Composable ComposeWindowScope.() -> Unit),
-	): WindowInstance {
-		val vWindow = WindowInstance(inTitle, inWidth, inHeight, inGpu, inIcon, inOnFrame, inContent)
-		// A Window() was declared either way - the "exit when the last window
-		// is gone" rule must also fire when every declared window failed to
-		// initialise (otherwise the loop would spin forever with none).
-		hadWindow = true
-		if (vWindow.init(scope)) {
-			windows.add(vWindow)
-		} else {
-			println("nativeComposeApp: window '$inTitle' failed to initialise")
-		}
-		return vWindow
-	}
-
-	fun scheduleDestroy(inWindow: WindowInstance) {
-		if (inWindow in windows && inWindow !in destroyQueue) destroyQueue.add(inWindow)
-	}
-
-	fun reapDestroyed() {
-		while (destroyQueue.isNotEmpty()) {
-			val vW = destroyQueue.removeLast()
-			windows.remove(vW)
-			vW.destroy()
-		}
-	}
-}
-
-// No-op applier for the app-level composition - it emits no UI nodes, only
-// side effects (each Window() manages a native window).
-private class UnitApplier : AbstractApplier<Unit>(Unit) {
-	override fun insertTopDown(index: Int, instance: Unit) {}
-	override fun insertBottomUp(index: Int, instance: Unit) {}
-	override fun remove(index: Int, count: Int) {}
-	override fun move(from: Int, to: Int, count: Int) {}
-	override fun onClear() {}
-}

 // ==================
 // MARK: WindowInstance - one SDL window + renderer + composition
@@ -486,7 +41,12 @@ internal class WindowInstance(
 	inHeight: Int,
 	inGpu: GpuMode,
 	inIcon: AppWindowIcon?,
+	private val attrs: WindowAttributes,
 	private val onFrame: ((RenderBackend, Int) -> Boolean)?,
+	// Window-level key handlers, read through holders so Window() recompositions
+	// with new lambdas take effect without recreating the window.
+	private val previewKeyHandler: () -> ((KeyEvent) -> Boolean),
+	private val keyHandler: () -> ((KeyEvent) -> Boolean),
 	private val contentHolder: () -> (@Composable ComposeWindowScope.() -> Unit),
 ) {
 	// Resolved renderer mode. `var` so init() can fall back GPU → CPU raster when
@@ -496,7 +56,7 @@ internal class WindowInstance(
 	private val initialHeight = inHeight
 	private val icon = inIcon
 	// Assigned by init() from the first backend that comes up (see makeBackend()).
-	lateinit var backend: SDL3Backend
+	lateinit var backend: Sdl3Backend
 		private set
 	private var renderBackend: RenderBackend? = null
 	lateinit var host: ComposeRootHost
@@ -505,7 +65,7 @@ internal class WindowInstance(
 		private set
 	private var popupHost: com.compose.sdl.window.PopupHostState? = null

-	val frameClock = SDL3FrameClock()
+	val frameClock = Sdl3FrameClock()
 	private var recomposer: Recomposer? = null
 	private var recomposeJob: Job? = null
 	private var composition: Composition? = null
@@ -568,14 +128,19 @@ internal class WindowInstance(
 		needsFrame = true
 	}

-	// Creates + initialises an SDL3Backend for [mode] and its RenderBackend. On
+	// Creates + initialises an Sdl3Backend for [mode] and its RenderBackend. On
 	// success commits `backend` and returns the renderer; else tears everything
 	// down and returns null so the caller can retry with a different mode.
 	private fun makeBackend(mode: GpuMode): RenderBackend? {
-		val vBackend = SDL3Backend(
+		val vBackend = Sdl3Backend(
 			initialTitle, initialWidth, initialHeight, gpuMode = mode,
 			iconLightResourcePaths = icon?.light ?: emptyList(),
 			iconDarkResourcePaths = icon?.dark ?: emptyList(),
+			undecorated = attrs.undecorated,
+			transparent = attrs.transparent,
+			resizable = attrs.resizable,
+			alwaysOnTop = attrs.alwaysOnTop,
+			focusable = attrs.focusable,
 		)
 		if (!vBackend.init()) {
 			vBackend.destroy(inQuitSdl = false)
@@ -597,9 +162,9 @@ internal class WindowInstance(
 		// can't come up (RDP / headless / missing GL driver), fall back once to
 		// CPU raster (Software) so the window still opens instead of failing.
 		var vRender = makeBackend(gpuMode)
-		if (vRender == null && gpuMode is GpuMode.Skia) {
+		if (vRender == null && gpuMode.isGpuAccelerated) {
 			println("GPU renderer ($gpuMode) unavailable - falling back to CPU raster (Software)")
-			gpuMode = GpuMode.Software
+			gpuMode = GpuMode.CpuRaster
 			vRender = makeBackend(gpuMode)
 		}
 		if (vRender == null) {
@@ -615,6 +180,9 @@ internal class WindowInstance(
 		// need this so a draw-only state change still repaints.
 		host.setInvalidationCallback { needsFrame = true }
 		facade = ComposeNativeWindow(backend, gpuMode, initialTitle)
+		// Mirror the creation flags into the facade so isResizable & co. read true
+		// from the start and a later Window() update only fires on a real change.
+		applyAttributes(attrs)
 		navigationEventOwner.navigationEventDispatcher.addInput(backNavigationInput)

 		// The render-bridge globals must point at THIS window's renderer while
@@ -748,14 +316,15 @@ internal class WindowInstance(
 	//  Event handling (loop-routed, per window)

 	fun onPointerEvent(inEvent: AppEvent.Pointer) {
+		if (!facade.isEnabled) return
 		needsFrame = true
 		installGlobals()
-		val vType = when (inEvent.event.type) {
+		val vType = when (inEvent.type) {
 			PointerEventType.Press -> 1
 			PointerEventType.Release -> 2
 			else -> 0
 		}
-		val vBtn = when (inEvent.event.button) {
+		val vBtn = when (inEvent.button) {
 			PointerButton.Secondary -> 1
 			PointerButton.Tertiary -> 2
 			else -> 0
@@ -763,9 +332,9 @@ internal class WindowInstance(
 		// SDL3 delivers mouse coords in logical points on HiDPI - multiply by
 		// DPR so hit-testing lands in the pixel space layout uses.
 		val vDpr = backend.pixelDensity
-		val vPx = inEvent.event.x * vDpr
-		val vPy = inEvent.event.y * vDpr
-		if (inEvent.event.type == PointerEventType.Press) {
+		val vPx = inEvent.x * vDpr
+		val vPy = inEvent.y * vDpr
+		if (inEvent.type == PointerEventType.Press) {
 			popupHost?.notifyOutsidePress(vPx.toInt(), vPy.toInt())
 		}
 		host.onPointerRaw(vPx, vPy, vType, vBtn, SDL_GetTicks().toLong())
@@ -778,6 +347,7 @@ internal class WindowInstance(
 	   synthetic hover re-dispatch and fire one Exit at the last position so a
 	   hovered widget clears its highlight instead of sticking forever. */
 	fun onPointerExit() {
+		if (!facade.isEnabled) return
 		needsFrame = true
 		if (hasMousePos) {
 			host.onPointerRaw(lastMouseX, lastMouseY, 3, 0, SDL_GetTicks().toLong())
@@ -786,6 +356,7 @@ internal class WindowInstance(
 	}

 	fun onWheelEvent(inEvent: AppEvent.MouseWheel) {
+		if (!facade.isEnabled) return
 		needsFrame = true
 		installGlobals()
 		val vDpr = backend.pixelDensity
@@ -793,15 +364,31 @@ internal class WindowInstance(
 	}

 	fun onKeyEvent(inEvent: AppEvent.Key) {
+		if (!facade.isEnabled) return
 		needsFrame = true
 		installGlobals()
-		// Focused chain → window-level shortcuts → back navigation (Escape).
-		if (!host.dispatchKeyEvent(inEvent.event) && !facade.dispatchKeyShortcut(inEvent.event)) {
+		// Compose Desktop's order: window preview → focused content → window
+		// onKeyEvent → app shortcut handler → back navigation (Escape).
+		if (previewKeyHandler().invoke(inEvent.event)) return
+		if (host.dispatchKeyEvent(inEvent.event)) return
+		if (keyHandler().invoke(inEvent.event)) return
+		if (!facade.dispatchKeyShortcut(inEvent.event)) {
 			backNavigationInput.onKeyEvent(inEvent.event)
 		}
 	}

+	/** Applies the mutable window attributes. Called at init from the creation
+	   flags and again whenever Window() sees one of them change. */
+	fun applyAttributes(inAttrs: WindowAttributes) {
+		facade.setUndecorated(inAttrs.undecorated)
+		facade.setResizable(inAttrs.resizable)
+		facade.setAlwaysOnTop(inAttrs.alwaysOnTop)
+		facade.setFocusable(inAttrs.focusable)
+		facade.setEnabled(inAttrs.enabled)
+	}
+
 	fun onTextInputEvent(inEvent: AppEvent.TextInput) {
+		if (!facade.isEnabled) return
 		needsFrame = true
 		installGlobals()
 		// A focused text field runs an IME session (ComposeOwner.textInputSession):
@@ -815,6 +402,7 @@ internal class WindowInstance(
 	}

 	fun onTextEditingEvent(inEvent: AppEvent.TextEditing) {
+		if (!facade.isEnabled) return
 		needsFrame = true
 		installGlobals()
 		// IME preedit: show the composing (underlined) region in the focused field.
@@ -844,6 +432,7 @@ internal class WindowInstance(
 	}

 	fun onDropEvent(inEvent: AppEvent.Drop) {
+		if (!facade.isEnabled) return
 		needsFrame = true
 		installGlobals()
 		// SDL fires drop coords in logical points at DPR-1; scale to the pixel
@@ -984,6 +573,3 @@ internal class WindowInstance(
 		backend.destroy(inQuitSdl = false)
 	}
 }
-
-// WindowArchitectureOwner -> WindowArchitectureOwner.kt
-// BackNavigationInput / dispatchTypedText -> WindowInputHelpers.kt
@@ -27,7 +27,7 @@ kotlin {
 		commonMain {
 			dependencies {
 				// foundation.layout.* only needs ui (+ runtime/collection transitively).
-				api(project(":ui"))
+				api(project(":compose:ui:ui"))
 			}
 			kotlin.srcDir("src/vendor/common/kotlin")
 		}
@@ -778,6 +778,17 @@ abstract interface androidx.compose.foundation.text/TextAutoSize { // androidx.c
    }
 }

+abstract interface androidx.compose.foundation.v2/ScrollbarAdapter { // androidx.compose.foundation.v2/ScrollbarAdapter|null[0]
+    abstract val contentSize // androidx.compose.foundation.v2/ScrollbarAdapter.contentSize|{}contentSize[0]
+        abstract fun <get-contentSize>(): kotlin/Double // androidx.compose.foundation.v2/ScrollbarAdapter.contentSize.<get-contentSize>|<get-contentSize>(){}[0]
+    abstract val scrollOffset // androidx.compose.foundation.v2/ScrollbarAdapter.scrollOffset|{}scrollOffset[0]
+        abstract fun <get-scrollOffset>(): kotlin/Double // androidx.compose.foundation.v2/ScrollbarAdapter.scrollOffset.<get-scrollOffset>|<get-scrollOffset>(){}[0]
+    abstract val viewportSize // androidx.compose.foundation.v2/ScrollbarAdapter.viewportSize|{}viewportSize[0]
+        abstract fun <get-viewportSize>(): kotlin/Double // androidx.compose.foundation.v2/ScrollbarAdapter.viewportSize.<get-viewportSize>|<get-viewportSize>(){}[0]
+
+    abstract suspend fun scrollTo(kotlin/Double) // androidx.compose.foundation.v2/ScrollbarAdapter.scrollTo|scrollTo(kotlin.Double){}[0]
+}
+
 abstract interface androidx.compose.foundation/BasicTooltipState { // androidx.compose.foundation/BasicTooltipState|null[0]
    abstract val isPersistent // androidx.compose.foundation/BasicTooltipState.isPersistent|{}isPersistent[0]
        abstract fun <get-isPersistent>(): kotlin/Boolean // androidx.compose.foundation/BasicTooltipState.isPersistent.<get-isPersistent>|<get-isPersistent>(){}[0]
@@ -830,15 +841,12 @@ abstract interface androidx.compose.foundation/ScrollIndicatorState { // android
        abstract fun <get-viewportSize>(): kotlin/Int // androidx.compose.foundation/ScrollIndicatorState.viewportSize.<get-viewportSize>|<get-viewportSize>(){}[0]
 }

-abstract interface com.compose.sdl.scrollbar/ScrollbarAdapter { // com.compose.sdl.scrollbar/ScrollbarAdapter|null[0]
-    abstract val contentSize // com.compose.sdl.scrollbar/ScrollbarAdapter.contentSize|{}contentSize[0]
-        abstract fun <get-contentSize>(): kotlin/Double // com.compose.sdl.scrollbar/ScrollbarAdapter.contentSize.<get-contentSize>|<get-contentSize>(){}[0]
-    abstract val scrollOffset // com.compose.sdl.scrollbar/ScrollbarAdapter.scrollOffset|{}scrollOffset[0]
-        abstract fun <get-scrollOffset>(): kotlin/Double // com.compose.sdl.scrollbar/ScrollbarAdapter.scrollOffset.<get-scrollOffset>|<get-scrollOffset>(){}[0]
-    abstract val viewportSize // com.compose.sdl.scrollbar/ScrollbarAdapter.viewportSize|{}viewportSize[0]
-        abstract fun <get-viewportSize>(): kotlin/Double // com.compose.sdl.scrollbar/ScrollbarAdapter.viewportSize.<get-viewportSize>|<get-viewportSize>(){}[0]
+abstract interface androidx.compose.foundation/ScrollbarAdapter { // androidx.compose.foundation/ScrollbarAdapter|null[0]
+    abstract val scrollOffset // androidx.compose.foundation/ScrollbarAdapter.scrollOffset|{}scrollOffset[0]
+        abstract fun <get-scrollOffset>(): kotlin/Float // androidx.compose.foundation/ScrollbarAdapter.scrollOffset.<get-scrollOffset>|<get-scrollOffset>(){}[0]

-    abstract suspend fun scrollTo(kotlin/Double) // com.compose.sdl.scrollbar/ScrollbarAdapter.scrollTo|scrollTo(kotlin.Double){}[0]
+    abstract fun maxScrollOffset(kotlin/Int): kotlin/Float // androidx.compose.foundation/ScrollbarAdapter.maxScrollOffset|maxScrollOffset(kotlin.Int){}[0]
+    abstract suspend fun scrollTo(kotlin/Int, kotlin/Float) // androidx.compose.foundation/ScrollbarAdapter.scrollTo|scrollTo(kotlin.Int;kotlin.Float){}[0]
 }

 sealed interface <#A: out kotlin/Any?> androidx.compose.foundation.lazy.layout/IntervalList { // androidx.compose.foundation.lazy.layout/IntervalList|null[0]
@@ -1829,21 +1837,32 @@ final class androidx.compose.foundation/ScrollState : androidx.compose.foundatio
    }
 }

-final class com.compose.sdl.scrollbar/ScrollbarStyle { // com.compose.sdl.scrollbar/ScrollbarStyle|null[0]
-    constructor <init>(androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.ui.graphics/Shape, kotlin/Int, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color) // com.compose.sdl.scrollbar/ScrollbarStyle.<init>|<init>(androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.ui.graphics.Shape;kotlin.Int;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color){}[0]
+final class androidx.compose.foundation/ScrollbarStyle { // androidx.compose.foundation/ScrollbarStyle|null[0]
+    constructor <init>(androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.ui.graphics/Shape, kotlin/Int, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color) // androidx.compose.foundation/ScrollbarStyle.<init>|<init>(androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.ui.graphics.Shape;kotlin.Int;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color){}[0]

-    final val hoverColor // com.compose.sdl.scrollbar/ScrollbarStyle.hoverColor|{}hoverColor[0]
-        final fun <get-hoverColor>(): androidx.compose.ui.graphics/Color // com.compose.sdl.scrollbar/ScrollbarStyle.hoverColor.<get-hoverColor>|<get-hoverColor>(){}[0]
-    final val hoverDurationMillis // com.compose.sdl.scrollbar/ScrollbarStyle.hoverDurationMillis|{}hoverDurationMillis[0]
-        final fun <get-hoverDurationMillis>(): kotlin/Int // com.compose.sdl.scrollbar/ScrollbarStyle.hoverDurationMillis.<get-hoverDurationMillis>|<get-hoverDurationMillis>(){}[0]
-    final val minimalHeight // com.compose.sdl.scrollbar/ScrollbarStyle.minimalHeight|{}minimalHeight[0]
-        final fun <get-minimalHeight>(): androidx.compose.ui.unit/Dp // com.compose.sdl.scrollbar/ScrollbarStyle.minimalHeight.<get-minimalHeight>|<get-minimalHeight>(){}[0]
-    final val shape // com.compose.sdl.scrollbar/ScrollbarStyle.shape|{}shape[0]
-        final fun <get-shape>(): androidx.compose.ui.graphics/Shape // com.compose.sdl.scrollbar/ScrollbarStyle.shape.<get-shape>|<get-shape>(){}[0]
-    final val thickness // com.compose.sdl.scrollbar/ScrollbarStyle.thickness|{}thickness[0]
-        final fun <get-thickness>(): androidx.compose.ui.unit/Dp // com.compose.sdl.scrollbar/ScrollbarStyle.thickness.<get-thickness>|<get-thickness>(){}[0]
-    final val unhoverColor // com.compose.sdl.scrollbar/ScrollbarStyle.unhoverColor|{}unhoverColor[0]
-        final fun <get-unhoverColor>(): androidx.compose.ui.graphics/Color // com.compose.sdl.scrollbar/ScrollbarStyle.unhoverColor.<get-unhoverColor>|<get-unhoverColor>(){}[0]
+    final val hoverColor // androidx.compose.foundation/ScrollbarStyle.hoverColor|{}hoverColor[0]
+        final fun <get-hoverColor>(): androidx.compose.ui.graphics/Color // androidx.compose.foundation/ScrollbarStyle.hoverColor.<get-hoverColor>|<get-hoverColor>(){}[0]
+    final val hoverDurationMillis // androidx.compose.foundation/ScrollbarStyle.hoverDurationMillis|{}hoverDurationMillis[0]
+        final fun <get-hoverDurationMillis>(): kotlin/Int // androidx.compose.foundation/ScrollbarStyle.hoverDurationMillis.<get-hoverDurationMillis>|<get-hoverDurationMillis>(){}[0]
+    final val minimalHeight // androidx.compose.foundation/ScrollbarStyle.minimalHeight|{}minimalHeight[0]
+        final fun <get-minimalHeight>(): androidx.compose.ui.unit/Dp // androidx.compose.foundation/ScrollbarStyle.minimalHeight.<get-minimalHeight>|<get-minimalHeight>(){}[0]
+    final val shape // androidx.compose.foundation/ScrollbarStyle.shape|{}shape[0]
+        final fun <get-shape>(): androidx.compose.ui.graphics/Shape // androidx.compose.foundation/ScrollbarStyle.shape.<get-shape>|<get-shape>(){}[0]
+    final val thickness // androidx.compose.foundation/ScrollbarStyle.thickness|{}thickness[0]
+        final fun <get-thickness>(): androidx.compose.ui.unit/Dp // androidx.compose.foundation/ScrollbarStyle.thickness.<get-thickness>|<get-thickness>(){}[0]
+    final val unhoverColor // androidx.compose.foundation/ScrollbarStyle.unhoverColor|{}unhoverColor[0]
+        final fun <get-unhoverColor>(): androidx.compose.ui.graphics/Color // androidx.compose.foundation/ScrollbarStyle.unhoverColor.<get-unhoverColor>|<get-unhoverColor>(){}[0]
+
+    final fun component1(): androidx.compose.ui.unit/Dp // androidx.compose.foundation/ScrollbarStyle.component1|component1(){}[0]
+    final fun component2(): androidx.compose.ui.unit/Dp // androidx.compose.foundation/ScrollbarStyle.component2|component2(){}[0]
+    final fun component3(): androidx.compose.ui.graphics/Shape // androidx.compose.foundation/ScrollbarStyle.component3|component3(){}[0]
+    final fun component4(): kotlin/Int // androidx.compose.foundation/ScrollbarStyle.component4|component4(){}[0]
+    final fun component5(): androidx.compose.ui.graphics/Color // androidx.compose.foundation/ScrollbarStyle.component5|component5(){}[0]
+    final fun component6(): androidx.compose.ui.graphics/Color // androidx.compose.foundation/ScrollbarStyle.component6|component6(){}[0]
+    final fun copy(androidx.compose.ui.unit/Dp = ..., androidx.compose.ui.unit/Dp = ..., androidx.compose.ui.graphics/Shape = ..., kotlin/Int = ..., androidx.compose.ui.graphics/Color = ..., androidx.compose.ui.graphics/Color = ...): androidx.compose.foundation/ScrollbarStyle // androidx.compose.foundation/ScrollbarStyle.copy|copy(androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.ui.graphics.Shape;kotlin.Int;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.foundation/ScrollbarStyle.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.foundation/ScrollbarStyle.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.foundation/ScrollbarStyle.toString|toString(){}[0]
 }

 final value class androidx.compose.foundation.lazy.grid/GridItemSpan { // androidx.compose.foundation.lazy.grid/GridItemSpan|null[0]
@@ -2071,13 +2090,6 @@ final object androidx.compose.foundation/MarqueeDefaults { // androidx.compose.f
        final fun <get-Velocity>(): androidx.compose.ui.unit/Dp // androidx.compose.foundation/MarqueeDefaults.Velocity.<get-Velocity>|<get-Velocity>(){}[0]
 }

-final object com.compose.sdl.icons/IconDefaults { // com.compose.sdl.icons/IconDefaults|null[0]
-    final val DefaultIconSize // com.compose.sdl.icons/IconDefaults.DefaultIconSize|{}DefaultIconSize[0]
-        final fun <get-DefaultIconSize>(): androidx.compose.ui.unit/Dp // com.compose.sdl.icons/IconDefaults.DefaultIconSize.<get-DefaultIconSize>|<get-DefaultIconSize>(){}[0]
-    final val LocalContentColor // com.compose.sdl.icons/IconDefaults.LocalContentColor|{}LocalContentColor[0]
-        final fun <get-LocalContentColor>(): androidx.compose.ui.graphics/Color // com.compose.sdl.icons/IconDefaults.LocalContentColor.<get-LocalContentColor>|<get-LocalContentColor>(){}[0]
-}
-
 final object com.compose.sdl.widgets/SplitPaneDefaults { // com.compose.sdl.widgets/SplitPaneDefaults|null[0]
    final val DividerThickness // com.compose.sdl.widgets/SplitPaneDefaults.DividerThickness|{}DividerThickness[0]
        final fun <get-DividerThickness>(): androidx.compose.ui.unit/Dp // com.compose.sdl.widgets/SplitPaneDefaults.DividerThickness.<get-DividerThickness>|<get-DividerThickness>(){}[0]
@@ -2197,10 +2209,15 @@ final val androidx.compose.foundation.text/androidx_compose_foundation_text_Keyb
 final val androidx.compose.foundation.text/androidx_compose_foundation_text_KeyboardOptions$stableprop // androidx.compose.foundation.text/androidx_compose_foundation_text_KeyboardOptions$stableprop|#static{}androidx_compose_foundation_text_KeyboardOptions$stableprop[0]
 final val androidx.compose.foundation.text/androidx_compose_foundation_text_TextAutoSizeDefaults$stableprop // androidx.compose.foundation.text/androidx_compose_foundation_text_TextAutoSizeDefaults$stableprop|#static{}androidx_compose_foundation_text_TextAutoSizeDefaults$stableprop[0]
 final val androidx.compose.foundation.text/androidx_compose_foundation_text_TextFieldScrollState$stableprop // androidx.compose.foundation.text/androidx_compose_foundation_text_TextFieldScrollState$stableprop|#static{}androidx_compose_foundation_text_TextFieldScrollState$stableprop[0]
+final val androidx.compose.foundation.v2/androidx_compose_foundation_v2_LazyLineContentAdapter_VisibleLine$stableprop // androidx.compose.foundation.v2/androidx_compose_foundation_v2_LazyLineContentAdapter_VisibleLine$stableprop|#static{}androidx_compose_foundation_v2_LazyLineContentAdapter_VisibleLine$stableprop[0]
+final val androidx.compose.foundation.v2/maxScrollOffset // androidx.compose.foundation.v2/maxScrollOffset|@androidx.compose.foundation.v2.ScrollbarAdapter{}maxScrollOffset[0]
+    final fun (androidx.compose.foundation.v2/ScrollbarAdapter).<get-maxScrollOffset>(): kotlin/Double // androidx.compose.foundation.v2/maxScrollOffset.<get-maxScrollOffset>|<get-maxScrollOffset>@androidx.compose.foundation.v2.ScrollbarAdapter(){}[0]
 final val androidx.compose.foundation/LocalIndication // androidx.compose.foundation/LocalIndication|{}LocalIndication[0]
    final fun <get-LocalIndication>(): androidx.compose.runtime/ProvidableCompositionLocal<androidx.compose.foundation/Indication> // androidx.compose.foundation/LocalIndication.<get-LocalIndication>|<get-LocalIndication>(){}[0]
 final val androidx.compose.foundation/LocalOverscrollFactory // androidx.compose.foundation/LocalOverscrollFactory|{}LocalOverscrollFactory[0]
    final fun <get-LocalOverscrollFactory>(): androidx.compose.runtime/ProvidableCompositionLocal<androidx.compose.foundation/OverscrollFactory?> // androidx.compose.foundation/LocalOverscrollFactory.<get-LocalOverscrollFactory>|<get-LocalOverscrollFactory>(){}[0]
+final val androidx.compose.foundation/LocalScrollbarStyle // androidx.compose.foundation/LocalScrollbarStyle|{}LocalScrollbarStyle[0]
+    final fun <get-LocalScrollbarStyle>(): androidx.compose.runtime/ProvidableCompositionLocal<androidx.compose.foundation/ScrollbarStyle> // androidx.compose.foundation/LocalScrollbarStyle.<get-LocalScrollbarStyle>|<get-LocalScrollbarStyle>(){}[0]
 final val androidx.compose.foundation/androidx_compose_foundation_BasicTooltipDefaults$stableprop // androidx.compose.foundation/androidx_compose_foundation_BasicTooltipDefaults$stableprop|#static{}androidx_compose_foundation_BasicTooltipDefaults$stableprop[0]
 final val androidx.compose.foundation/androidx_compose_foundation_BorderStroke$stableprop // androidx.compose.foundation/androidx_compose_foundation_BorderStroke$stableprop|#static{}androidx_compose_foundation_BorderStroke$stableprop[0]
 final val androidx.compose.foundation/androidx_compose_foundation_CombinedClickableNode_DoubleKeyClickState$stableprop // androidx.compose.foundation/androidx_compose_foundation_CombinedClickableNode_DoubleKeyClickState$stableprop|#static{}androidx_compose_foundation_CombinedClickableNode_DoubleKeyClickState$stableprop[0]
@@ -2208,10 +2225,7 @@ final val androidx.compose.foundation/androidx_compose_foundation_ComposeFoundat
 final val androidx.compose.foundation/androidx_compose_foundation_MarqueeDefaults$stableprop // androidx.compose.foundation/androidx_compose_foundation_MarqueeDefaults$stableprop|#static{}androidx_compose_foundation_MarqueeDefaults$stableprop[0]
 final val androidx.compose.foundation/androidx_compose_foundation_MutatorMutex$stableprop // androidx.compose.foundation/androidx_compose_foundation_MutatorMutex$stableprop|#static{}androidx_compose_foundation_MutatorMutex$stableprop[0]
 final val androidx.compose.foundation/androidx_compose_foundation_ScrollState$stableprop // androidx.compose.foundation/androidx_compose_foundation_ScrollState$stableprop|#static{}androidx_compose_foundation_ScrollState$stableprop[0]
-final val com.compose.sdl.icons/com_compose_sdl_icons_IconDefaults$stableprop // com.compose.sdl.icons/com_compose_sdl_icons_IconDefaults$stableprop|#static{}com_compose_sdl_icons_IconDefaults$stableprop[0]
-final val com.compose.sdl.scrollbar/LocalScrollbarStyle // com.compose.sdl.scrollbar/LocalScrollbarStyle|{}LocalScrollbarStyle[0]
-    final fun <get-LocalScrollbarStyle>(): androidx.compose.runtime/ProvidableCompositionLocal<com.compose.sdl.scrollbar/ScrollbarStyle> // com.compose.sdl.scrollbar/LocalScrollbarStyle.<get-LocalScrollbarStyle>|<get-LocalScrollbarStyle>(){}[0]
-final val com.compose.sdl.scrollbar/com_compose_sdl_scrollbar_ScrollbarStyle$stableprop // com.compose.sdl.scrollbar/com_compose_sdl_scrollbar_ScrollbarStyle$stableprop|#static{}com_compose_sdl_scrollbar_ScrollbarStyle$stableprop[0]
+final val androidx.compose.foundation/androidx_compose_foundation_ScrollbarStyle$stableprop // androidx.compose.foundation/androidx_compose_foundation_ScrollbarStyle$stableprop|#static{}androidx_compose_foundation_ScrollbarStyle$stableprop[0]
 final val com.compose.sdl.widgets/com_compose_sdl_widgets_SplitPaneDefaults$stableprop // com.compose.sdl.widgets/com_compose_sdl_widgets_SplitPaneDefaults$stableprop|#static{}com_compose_sdl_widgets_SplitPaneDefaults$stableprop[0]

 final fun (androidx.compose.foundation.content/TransferableContent).androidx.compose.foundation.content/hasMediaType(androidx.compose.foundation.content/MediaType): kotlin/Boolean // androidx.compose.foundation.content/hasMediaType|hasMediaType@androidx.compose.foundation.content.TransferableContent(androidx.compose.foundation.content.MediaType){}[0]
@@ -2585,18 +2599,29 @@ final fun androidx.compose.foundation.text/androidx_compose_foundation_text_Text
 final fun androidx.compose.foundation.text/rememberTextFieldHorizontalScrollState(kotlin/Int, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.foundation.text/TextFieldScrollState // androidx.compose.foundation.text/rememberTextFieldHorizontalScrollState|rememberTextFieldHorizontalScrollState(kotlin.Int;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation.text/rememberTextFieldScrollState(androidx.compose.foundation.gestures/Orientation, kotlin/Int, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.foundation.text/TextFieldScrollState // androidx.compose.foundation.text/rememberTextFieldScrollState|rememberTextFieldScrollState(androidx.compose.foundation.gestures.Orientation;kotlin.Int;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation.text/rememberTextFieldVerticalScrollState(kotlin/Int, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.foundation.text/TextFieldScrollState // androidx.compose.foundation.text/rememberTextFieldVerticalScrollState|rememberTextFieldVerticalScrollState(kotlin.Int;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.foundation.v2/androidx_compose_foundation_v2_LazyLineContentAdapter_VisibleLine$stableprop_getter(): kotlin/Int // androidx.compose.foundation.v2/androidx_compose_foundation_v2_LazyLineContentAdapter_VisibleLine$stableprop_getter|androidx_compose_foundation_v2_LazyLineContentAdapter_VisibleLine$stableprop_getter(){}[0]
 final fun androidx.compose.foundation/BasicTooltipBox(androidx.compose.ui.window/PopupPositionProvider, kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.foundation/BasicTooltipState, androidx.compose.ui/Modifier?, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/BasicTooltipBox|BasicTooltipBox(androidx.compose.ui.window.PopupPositionProvider;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.foundation.BasicTooltipState;androidx.compose.ui.Modifier?;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/BasicTooltipBox(androidx.compose.ui.window/PopupPositionProvider, kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.foundation/BasicTooltipState, androidx.compose.ui/Modifier?, kotlin/Boolean, kotlin/Boolean, kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/BasicTooltipBox|BasicTooltipBox(androidx.compose.ui.window.PopupPositionProvider;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.foundation.BasicTooltipState;androidx.compose.ui.Modifier?;kotlin.Boolean;kotlin.Boolean;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/BasicTooltipState(kotlin/Boolean = ..., kotlin/Boolean = ..., androidx.compose.foundation/MutatorMutex = ...): androidx.compose.foundation/BasicTooltipState // androidx.compose.foundation/BasicTooltipState|BasicTooltipState(kotlin.Boolean;kotlin.Boolean;androidx.compose.foundation.MutatorMutex){}[0]
 final fun androidx.compose.foundation/BorderStroke(androidx.compose.ui.unit/Dp, androidx.compose.ui.graphics/Color): androidx.compose.foundation/BorderStroke // androidx.compose.foundation/BorderStroke|BorderStroke(androidx.compose.ui.unit.Dp;androidx.compose.ui.graphics.Color){}[0]
 final fun androidx.compose.foundation/Canvas(androidx.compose.ui/Modifier, kotlin/Function1<androidx.compose.ui.graphics.drawscope/DrawScope, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int) // androidx.compose.foundation/Canvas|Canvas(androidx.compose.ui.Modifier;kotlin.Function1<androidx.compose.ui.graphics.drawscope.DrawScope,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
 final fun androidx.compose.foundation/Canvas(androidx.compose.ui/Modifier, kotlin/String, kotlin/Function1<androidx.compose.ui.graphics.drawscope/DrawScope, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int) // androidx.compose.foundation/Canvas|Canvas(androidx.compose.ui.Modifier;kotlin.String;kotlin.Function1<androidx.compose.ui.graphics.drawscope.DrawScope,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun androidx.compose.foundation/HorizontalScrollbar(androidx.compose.foundation.v2/ScrollbarAdapter, androidx.compose.ui/Modifier?, kotlin/Boolean, androidx.compose.foundation/ScrollbarStyle?, androidx.compose.foundation.interaction/MutableInteractionSource?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/HorizontalScrollbar|HorizontalScrollbar(androidx.compose.foundation.v2.ScrollbarAdapter;androidx.compose.ui.Modifier?;kotlin.Boolean;androidx.compose.foundation.ScrollbarStyle?;androidx.compose.foundation.interaction.MutableInteractionSource?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.foundation/HorizontalScrollbar(androidx.compose.foundation/ScrollbarAdapter, androidx.compose.ui/Modifier?, kotlin/Boolean, androidx.compose.foundation/ScrollbarStyle?, androidx.compose.foundation.interaction/MutableInteractionSource?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/HorizontalScrollbar|HorizontalScrollbar(androidx.compose.foundation.ScrollbarAdapter;androidx.compose.ui.Modifier?;kotlin.Boolean;androidx.compose.foundation.ScrollbarStyle?;androidx.compose.foundation.interaction.MutableInteractionSource?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/Image(androidx.compose.ui.graphics.painter/Painter, kotlin/String?, androidx.compose.ui/Modifier?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/Image|Image(androidx.compose.ui.graphics.painter.Painter;kotlin.String?;androidx.compose.ui.Modifier?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/Image(androidx.compose.ui.graphics.vector/ImageVector, kotlin/String?, androidx.compose.ui/Modifier?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/Image|Image(androidx.compose.ui.graphics.vector.ImageVector;kotlin.String?;androidx.compose.ui.Modifier?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/Image(androidx.compose.ui.graphics/ImageBitmap, kotlin/String?, androidx.compose.ui/Modifier?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/Image|Image(androidx.compose.ui.graphics.ImageBitmap;kotlin.String?;androidx.compose.ui.Modifier?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/Image(androidx.compose.ui.graphics/ImageBitmap, kotlin/String?, androidx.compose.ui/Modifier?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/Image|Image(androidx.compose.ui.graphics.ImageBitmap;kotlin.String?;androidx.compose.ui.Modifier?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/Image(androidx.compose.ui.graphics/ImageBitmap, kotlin/String?, androidx.compose.ui/Modifier?, androidx.compose.ui/Alignment?, androidx.compose.ui.layout/ContentScale?, kotlin/Float, androidx.compose.ui.graphics/ColorFilter?, androidx.compose.ui.graphics/FilterQuality?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/Image|Image(androidx.compose.ui.graphics.ImageBitmap;kotlin.String?;androidx.compose.ui.Modifier?;androidx.compose.ui.Alignment?;androidx.compose.ui.layout.ContentScale?;kotlin.Float;androidx.compose.ui.graphics.ColorFilter?;androidx.compose.ui.graphics.FilterQuality?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/MarqueeSpacing(androidx.compose.ui.unit/Dp): androidx.compose.foundation/MarqueeSpacing // androidx.compose.foundation/MarqueeSpacing|MarqueeSpacing(androidx.compose.ui.unit.Dp){}[0]
+final fun androidx.compose.foundation/OldScrollbarAdapter(androidx.compose.foundation.lazy/LazyListState): androidx.compose.foundation/ScrollbarAdapter // androidx.compose.foundation/OldScrollbarAdapter|OldScrollbarAdapter(androidx.compose.foundation.lazy.LazyListState){}[0]
+final fun androidx.compose.foundation/OldScrollbarAdapter(androidx.compose.foundation/ScrollState): androidx.compose.foundation/ScrollbarAdapter // androidx.compose.foundation/OldScrollbarAdapter|OldScrollbarAdapter(androidx.compose.foundation.ScrollState){}[0]
+final fun androidx.compose.foundation/ScrollbarAdapter(androidx.compose.foundation.lazy.grid/LazyGridState): androidx.compose.foundation.v2/ScrollbarAdapter // androidx.compose.foundation/ScrollbarAdapter|ScrollbarAdapter(androidx.compose.foundation.lazy.grid.LazyGridState){}[0]
+final fun androidx.compose.foundation/ScrollbarAdapter(androidx.compose.foundation.lazy/LazyListState): androidx.compose.foundation.v2/ScrollbarAdapter // androidx.compose.foundation/ScrollbarAdapter|ScrollbarAdapter(androidx.compose.foundation.lazy.LazyListState){}[0]
+final fun androidx.compose.foundation/ScrollbarAdapter(androidx.compose.foundation.text/TextFieldScrollState): androidx.compose.foundation.v2/ScrollbarAdapter // androidx.compose.foundation/ScrollbarAdapter|ScrollbarAdapter(androidx.compose.foundation.text.TextFieldScrollState){}[0]
+final fun androidx.compose.foundation/ScrollbarAdapter(androidx.compose.foundation/ScrollState): androidx.compose.foundation.v2/ScrollbarAdapter // androidx.compose.foundation/ScrollbarAdapter|ScrollbarAdapter(androidx.compose.foundation.ScrollState){}[0]
+final fun androidx.compose.foundation/VerticalScrollbar(androidx.compose.foundation.v2/ScrollbarAdapter, androidx.compose.ui/Modifier?, kotlin/Boolean, androidx.compose.foundation/ScrollbarStyle?, androidx.compose.foundation.interaction/MutableInteractionSource?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/VerticalScrollbar|VerticalScrollbar(androidx.compose.foundation.v2.ScrollbarAdapter;androidx.compose.ui.Modifier?;kotlin.Boolean;androidx.compose.foundation.ScrollbarStyle?;androidx.compose.foundation.interaction.MutableInteractionSource?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.foundation/VerticalScrollbar(androidx.compose.foundation/ScrollbarAdapter, androidx.compose.ui/Modifier?, kotlin/Boolean, androidx.compose.foundation/ScrollbarStyle?, androidx.compose.foundation.interaction/MutableInteractionSource?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.foundation/VerticalScrollbar|VerticalScrollbar(androidx.compose.foundation.ScrollbarAdapter;androidx.compose.ui.Modifier?;kotlin.Boolean;androidx.compose.foundation.ScrollbarStyle?;androidx.compose.foundation.interaction.MutableInteractionSource?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun androidx.compose.foundation/androidx_compose_foundation_BasicTooltipDefaults$stableprop_getter(): kotlin/Int // androidx.compose.foundation/androidx_compose_foundation_BasicTooltipDefaults$stableprop_getter|androidx_compose_foundation_BasicTooltipDefaults$stableprop_getter(){}[0]
 final fun androidx.compose.foundation/androidx_compose_foundation_BorderStroke$stableprop_getter(): kotlin/Int // androidx.compose.foundation/androidx_compose_foundation_BorderStroke$stableprop_getter|androidx_compose_foundation_BorderStroke$stableprop_getter(){}[0]
 final fun androidx.compose.foundation/androidx_compose_foundation_CombinedClickableNode_DoubleKeyClickState$stableprop_getter(): kotlin/Int // androidx.compose.foundation/androidx_compose_foundation_CombinedClickableNode_DoubleKeyClickState$stableprop_getter|androidx_compose_foundation_CombinedClickableNode_DoubleKeyClickState$stableprop_getter(){}[0]
@@ -2604,20 +2629,21 @@ final fun androidx.compose.foundation/androidx_compose_foundation_ComposeFoundat
 final fun androidx.compose.foundation/androidx_compose_foundation_MarqueeDefaults$stableprop_getter(): kotlin/Int // androidx.compose.foundation/androidx_compose_foundation_MarqueeDefaults$stableprop_getter|androidx_compose_foundation_MarqueeDefaults$stableprop_getter(){}[0]
 final fun androidx.compose.foundation/androidx_compose_foundation_MutatorMutex$stableprop_getter(): kotlin/Int // androidx.compose.foundation/androidx_compose_foundation_MutatorMutex$stableprop_getter|androidx_compose_foundation_MutatorMutex$stableprop_getter(){}[0]
 final fun androidx.compose.foundation/androidx_compose_foundation_ScrollState$stableprop_getter(): kotlin/Int // androidx.compose.foundation/androidx_compose_foundation_ScrollState$stableprop_getter|androidx_compose_foundation_ScrollState$stableprop_getter(){}[0]
+final fun androidx.compose.foundation/androidx_compose_foundation_ScrollbarStyle$stableprop_getter(): kotlin/Int // androidx.compose.foundation/androidx_compose_foundation_ScrollbarStyle$stableprop_getter|androidx_compose_foundation_ScrollbarStyle$stableprop_getter(){}[0]
 final fun androidx.compose.foundation/checkScrollableContainerConstraints(androidx.compose.ui.unit/Constraints, androidx.compose.foundation.gestures/Orientation) // androidx.compose.foundation/checkScrollableContainerConstraints|checkScrollableContainerConstraints(androidx.compose.ui.unit.Constraints;androidx.compose.foundation.gestures.Orientation){}[0]
+final fun androidx.compose.foundation/defaultScrollbarStyle(): androidx.compose.foundation/ScrollbarStyle // androidx.compose.foundation/defaultScrollbarStyle|defaultScrollbarStyle(){}[0]
 final fun androidx.compose.foundation/isSystemInDarkTheme(androidx.compose.runtime/Composer?, kotlin/Int): kotlin/Boolean // androidx.compose.foundation/isSystemInDarkTheme|isSystemInDarkTheme(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
 final fun androidx.compose.foundation/rememberBasicTooltipState(kotlin/Boolean, kotlin/Boolean, androidx.compose.foundation/MutatorMutex?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.foundation/BasicTooltipState // androidx.compose.foundation/rememberBasicTooltipState|rememberBasicTooltipState(kotlin.Boolean;kotlin.Boolean;androidx.compose.foundation.MutatorMutex?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.foundation/rememberOldScrollbarAdapter(androidx.compose.foundation.lazy/LazyListState, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.foundation/ScrollbarAdapter // androidx.compose.foundation/rememberOldScrollbarAdapter|rememberOldScrollbarAdapter(androidx.compose.foundation.lazy.LazyListState;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun androidx.compose.foundation/rememberOldScrollbarAdapter(androidx.compose.foundation/ScrollState, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.foundation/ScrollbarAdapter // androidx.compose.foundation/rememberOldScrollbarAdapter|rememberOldScrollbarAdapter(androidx.compose.foundation.ScrollState;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
 final fun androidx.compose.foundation/rememberOverscrollEffect(androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.foundation/OverscrollEffect? // androidx.compose.foundation/rememberOverscrollEffect|rememberOverscrollEffect(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
 final fun androidx.compose.foundation/rememberScrollState(kotlin/Int, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.foundation/ScrollState // androidx.compose.foundation/rememberScrollState|rememberScrollState(kotlin.Int;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.foundation/rememberScrollbarAdapter(androidx.compose.foundation.lazy.grid/LazyGridState, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.foundation.v2/ScrollbarAdapter // androidx.compose.foundation/rememberScrollbarAdapter|rememberScrollbarAdapter(androidx.compose.foundation.lazy.grid.LazyGridState;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun androidx.compose.foundation/rememberScrollbarAdapter(androidx.compose.foundation.lazy/LazyListState, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.foundation.v2/ScrollbarAdapter // androidx.compose.foundation/rememberScrollbarAdapter|rememberScrollbarAdapter(androidx.compose.foundation.lazy.LazyListState;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun androidx.compose.foundation/rememberScrollbarAdapter(androidx.compose.foundation.text/TextFieldScrollState, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.foundation.v2/ScrollbarAdapter // androidx.compose.foundation/rememberScrollbarAdapter|rememberScrollbarAdapter(androidx.compose.foundation.text.TextFieldScrollState;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun androidx.compose.foundation/rememberScrollbarAdapter(androidx.compose.foundation/ScrollState, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.foundation.v2/ScrollbarAdapter // androidx.compose.foundation/rememberScrollbarAdapter|rememberScrollbarAdapter(androidx.compose.foundation.ScrollState;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
 final fun com.compose.sdl.icons/IconFontIcon(kotlin/Int, kotlin/String, kotlin/String?, androidx.compose.ui/Modifier?, androidx.compose.ui.graphics/Color, androidx.compose.ui.unit/Dp, kotlin.collections/List<androidx.compose.ui.text.font/FontVariation.Setting>?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // com.compose.sdl.icons/IconFontIcon|IconFontIcon(kotlin.Int;kotlin.String;kotlin.String?;androidx.compose.ui.Modifier?;androidx.compose.ui.graphics.Color;androidx.compose.ui.unit.Dp;kotlin.collections.List<androidx.compose.ui.text.font.FontVariation.Setting>?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
-final fun com.compose.sdl.icons/com_compose_sdl_icons_IconDefaults$stableprop_getter(): kotlin/Int // com.compose.sdl.icons/com_compose_sdl_icons_IconDefaults$stableprop_getter|com_compose_sdl_icons_IconDefaults$stableprop_getter(){}[0]
 final fun com.compose.sdl.modifier/rememberMutableInteractionSource(androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.foundation.interaction/MutableInteractionSource // com.compose.sdl.modifier/rememberMutableInteractionSource|rememberMutableInteractionSource(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
-final fun com.compose.sdl.scrollbar/HorizontalScrollbar(com.compose.sdl.scrollbar/ScrollbarAdapter, androidx.compose.ui/Modifier?, kotlin/Boolean, com.compose.sdl.scrollbar/ScrollbarStyle?, androidx.compose.foundation.interaction/MutableInteractionSource?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // com.compose.sdl.scrollbar/HorizontalScrollbar|HorizontalScrollbar(com.compose.sdl.scrollbar.ScrollbarAdapter;androidx.compose.ui.Modifier?;kotlin.Boolean;com.compose.sdl.scrollbar.ScrollbarStyle?;androidx.compose.foundation.interaction.MutableInteractionSource?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
-final fun com.compose.sdl.scrollbar/VerticalScrollbar(com.compose.sdl.scrollbar/ScrollbarAdapter, androidx.compose.ui/Modifier?, kotlin/Boolean, com.compose.sdl.scrollbar/ScrollbarStyle?, androidx.compose.foundation.interaction/MutableInteractionSource?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // com.compose.sdl.scrollbar/VerticalScrollbar|VerticalScrollbar(com.compose.sdl.scrollbar.ScrollbarAdapter;androidx.compose.ui.Modifier?;kotlin.Boolean;com.compose.sdl.scrollbar.ScrollbarStyle?;androidx.compose.foundation.interaction.MutableInteractionSource?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
-final fun com.compose.sdl.scrollbar/com_compose_sdl_scrollbar_ScrollbarStyle$stableprop_getter(): kotlin/Int // com.compose.sdl.scrollbar/com_compose_sdl_scrollbar_ScrollbarStyle$stableprop_getter|com_compose_sdl_scrollbar_ScrollbarStyle$stableprop_getter(){}[0]
-final fun com.compose.sdl.scrollbar/defaultScrollbarStyle(): com.compose.sdl.scrollbar/ScrollbarStyle // com.compose.sdl.scrollbar/defaultScrollbarStyle|defaultScrollbarStyle(){}[0]
-final fun com.compose.sdl.scrollbar/rememberScrollbarAdapter(androidx.compose.foundation.lazy/LazyListState, androidx.compose.runtime/Composer?, kotlin/Int): com.compose.sdl.scrollbar/ScrollbarAdapter // com.compose.sdl.scrollbar/rememberScrollbarAdapter|rememberScrollbarAdapter(androidx.compose.foundation.lazy.LazyListState;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
-final fun com.compose.sdl.scrollbar/rememberScrollbarAdapter(androidx.compose.foundation/ScrollState, androidx.compose.runtime/Composer?, kotlin/Int): com.compose.sdl.scrollbar/ScrollbarAdapter // com.compose.sdl.scrollbar/rememberScrollbarAdapter|rememberScrollbarAdapter(androidx.compose.foundation.ScrollState;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
 final fun com.compose.sdl.text/IconText(kotlin/String, kotlin/String, androidx.compose.ui/Modifier?, androidx.compose.ui.graphics/Color, androidx.compose.ui.unit/TextUnit, androidx.compose.ui.text.style/TextAlign, kotlin.collections/List<androidx.compose.ui.text.font/FontVariation.Setting>?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // com.compose.sdl.text/IconText|IconText(kotlin.String;kotlin.String;androidx.compose.ui.Modifier?;androidx.compose.ui.graphics.Color;androidx.compose.ui.unit.TextUnit;androidx.compose.ui.text.style.TextAlign;kotlin.collections.List<androidx.compose.ui.text.font.FontVariation.Setting>?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun com.compose.sdl.text/IconText(kotlin/String, kotlin/String, androidx.compose.ui/Modifier?, androidx.compose.ui.graphics/Color, androidx.compose.ui.unit/TextUnit, androidx.compose.ui.text.style/TextAlign?, kotlin.collections/List<androidx.compose.ui.text.font/FontVariation.Setting>?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // com.compose.sdl.text/IconText|IconText(kotlin.String;kotlin.String;androidx.compose.ui.Modifier?;androidx.compose.ui.graphics.Color;androidx.compose.ui.unit.TextUnit;androidx.compose.ui.text.style.TextAlign?;kotlin.collections.List<androidx.compose.ui.text.font.FontVariation.Setting>?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
 final fun com.compose.sdl.widgets/HorizontalSplitPane(androidx.compose.ui/Modifier?, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color, kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // com.compose.sdl.widgets/HorizontalSplitPane|HorizontalSplitPane(androidx.compose.ui.Modifier?;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
@@ -48,10 +48,10 @@ kotlin {
        commonMain {
            kotlin.srcDir("src/vendor/common/kotlin")
            dependencies {
-                api(project(":ui"))
-                api(project(":animation-core"))
-                api(project(":animation"))
-                api(project(":foundation-layout"))
+                api(project(":compose:ui:ui"))
+                api(project(":compose:animation:animation-core"))
+                api(project(":compose:animation:animation"))
+                api(project(":compose:foundation:foundation-layout"))
            }
        }
        nativeMain {
@@ -356,7 +356,6 @@ commonMain/kotlin/ -> src/vendor/common/kotlin/
 #     | commonMain/kotlin/androidx/compose/foundation/text/selection/TextPreparedSelection.kt -> src/vendor/common/kotlin/androidx/compose/foundation/text/selection/TextPreparedSelection.kt
 #     | commonMain/kotlin/androidx/compose/foundation/text/selection/TextSelectionColors.kt -> src/vendor/common/kotlin/androidx/compose/foundation/text/selection/TextSelectionColors.kt
 #     | commonMain/kotlin/androidx/compose/foundation/text/selection/TextSelectionDelegate.kt -> src/vendor/common/kotlin/androidx/compose/foundation/text/selection/TextSelectionDelegate.kt
-!commonMain/kotlin/androidx/compose/foundation/text/selection/SelectionLayout.kt

 macosMain/kotlin/androidx/compose/foundation/text/selection/DefaultTextSelectionColors.macos.kt -> src/vendor/native/kotlin/androidx/compose/foundation/text/selection/DefaultTextSelectionColors.native.kt

@@ -1,810 +0,0 @@
-@file:Suppress("OPTIONAL_DECLARATION_USAGE_IN_NON_COMMON_SOURCE", "LESS_VISIBLE_TYPE_ACCESS_IN_INLINE")
-
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// MANUAL VENDOR of upstream compose/foundation/foundation/src/commonMain/kotlin/
-// androidx/compose/foundation/text/selection/SelectionLayout.kt.
-// VENDOR-BASE: compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/text/selection/SelectionLayout.kt @ v1.12.0-beta03+dev4483
-//
-// Change vs upstream: MultiSelectionLayout.crossStatus and slotToIndex clamp their
-// infoList index to the valid range. Upstream assumes that if the drag position never
-// resolves ON or BEFORE any selectable, at least one slot is anchored on a text (odd).
-// That assumption breaks when a mouse-down starts a NEW selection AFTER every selectable
-// in the container - both slots stay UNASSIGNED and get defaulted to lastSlot = 2N by
-// SelectionLayoutBuilder.build(), so startSlot / 2 == infoList.size (OOB). Repro:
-// apidemo response viewer, drag-select in the empty area below the last body block.
-
-package androidx.compose.foundation.text.selection
-
-import androidx.collection.LongIntMap
-import androidx.collection.LongObjectMap
-import androidx.collection.MutableLongIntMap
-import androidx.collection.buildLongObjectMap
-import androidx.collection.emptyLongObjectMap
-import androidx.collection.longObjectMapOf
-import androidx.collection.mutableLongIntMapOf
-import androidx.collection.mutableLongObjectMapOf
-import androidx.compose.foundation.internal.checkPrecondition
-import androidx.compose.foundation.text.selection.Direction.AFTER
-import androidx.compose.foundation.text.selection.Direction.BEFORE
-import androidx.compose.foundation.text.selection.Direction.ON
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.layout.LayoutCoordinates
-import androidx.compose.ui.text.TextLayoutResult
-import androidx.compose.ui.text.TextRange
-import androidx.compose.ui.util.fastForEach
-import androidx.compose.ui.util.fastForEachIndexed
-
-/**
- * Selection data around how the pointer relates to the actual positions of the Text components.
- *
- * # Explanation of Slots
- *
- * The Slot value is meant to sit either *on* an index or *between* indices. The former means the
- * pointer is on a `Text` (like slot value `1` and index `0` below). The latter means the pointer is
- * not on a `Text`, but between `Text`s (like slot value `0` or `2` below). So a slot value of `2`
- * means that the pointer is between the `Text`s at index `0` and `1`, perhaps in padding or a
- * non-selectable `Text`.
- *
- * ```
- * slot value  0  1  2  3  4  5  6  7  8  9  10
- * info index     0     1     2     3     4
- * ```
- *
- * ## Mappings:
- * The `X` represents an impossible slot assignment The `|`, `/`, and `\` represent a slot mapping.
- *
- * ### Mapping minimum slot:
- * ```
- * slot value  0  1  2  3  4  5  6  7  8  9  10
- *              \ |   \ |   \ |   \ |   \ | X
- * info index     0     1     2     3     4
- *
- * min-slot index = slot / 2
- * ```
- *
- * Minimum slot cannot be after the final `Text` (index `4`).
- *
- * ### Mapping maximum slot:
- * ```
- * slot value  0  1  2  3  4  5  6  7  8  9  10
- *              X | /   | /   | /   | /   | /
- * info index     0     1     2     3     4
- * max-slot index = (slot - 1) / 2
- * ```
- *
- * Maximum slot cannot be before the first `Text` (index `0`).
- *
- * ## Assertions
- * * The non-dragging slot should always be directly on a text (odd) because the non-dragging handle
- *   must be anchored somewhere.
- *     * Because of this, we can determine that if `startSlot == endSlot` then it also follows that
- *       `startSlot` and `endSlot` are even.
- */
-internal interface SelectionLayout {
-    /** The number of [SelectableInfo]s in this [SelectionLayout]. */
-    val size: Int
-
-    /** The slot of the start anchor. */
-    val startSlot: Int
-
-    /** The slot of the end anchor. */
-    val endSlot: Int
-
-    /** The [CrossStatus] of this layout as determined by the slot/offsets. */
-    val crossStatus: CrossStatus
-
-    /** The [SelectableInfo] that the start is on. */
-    val startInfo: SelectableInfo
-
-    /** The [SelectableInfo] that the end is on. */
-    val endInfo: SelectableInfo
-
-    /** The [SelectableInfo] that the start/end is on as determined by [isStartHandle]. */
-    val currentInfo: SelectableInfo
-
-    /** The [SelectableInfo] for the first selectable on the screen. */
-    val firstInfo: SelectableInfo
-
-    /** The [SelectableInfo] for the last selectable on the screen. */
-    val lastInfo: SelectableInfo
-
-    /**
-     * Run a function on every [SelectableInfo] between [firstInfo] and [lastInfo] (not including
-     * [firstInfo]/[lastInfo]).
-     */
-    fun forEachMiddleInfo(block: (SelectableInfo) -> Unit)
-
-    /** Whether the start or end anchor is currently being moved. */
-    val isStartHandle: Boolean
-
-    /** The previous [Selection] that we are modifying. */
-    val previousSelection: Selection?
-
-    /** Returns the [SelectableInfo] of the selectable with the given id. */
-    fun infoForSelectable(selectableId: Long): SelectableInfo?
-
-    /**
-     * Whether this layout, compared to another layout, has any relevant changes that would require
-     * recomputing selection.
-     *
-     * @param other the selection layout to check for changes compared to this one
-     */
-    fun shouldRecomputeSelection(other: SelectionLayout?): Boolean
-
-    /**
-     * Splits a selection into a Map of selectable ID to Selections limited to that selectable ID.
-     *
-     * @param selection The selection to turn into subSelections
-     */
-    fun createSubSelections(selection: Selection): LongObjectMap<Selection>
-}
-
-private class MultiSelectionLayout(
-    val selectableIdToInfoListIndex: LongIntMap,
-    val infoList: List<SelectableInfo>,
-    override val startSlot: Int,
-    override val endSlot: Int,
-    override val isStartHandle: Boolean,
-    override val previousSelection: Selection?,
-) : SelectionLayout {
-    init {
-        checkPrecondition(infoList.size > 1) {
-            "MultiSelectionLayout requires an infoList size greater than 1, was ${infoList.size}."
-        }
-    }
-
-    private var _infoBySelectableId: LongObjectMap<SelectableInfo>? = null
-    private val infoBySelectableId: LongObjectMap<SelectableInfo>
-        get() {
-            var result = _infoBySelectableId
-            if (result == null) {
-                result = buildLongObjectMap { infoList.fastForEach { put(it.selectableId, it) } }
-                _infoBySelectableId = result
-            }
-            return result
-        }
-
-    // Most of these properties are unused unless shouldRecomputeSelection returns true,
-    // hence why getters are used everywhere.
-
-    override val size
-        get() = infoList.size
-
-    override val crossStatus: CrossStatus
-        get() =
-            when {
-                startSlot < endSlot -> CrossStatus.NOT_CROSSED
-                startSlot > endSlot -> CrossStatus.CROSSED
-                // FORK CHANGE: clamp when the gesture starts past every selectable, both slots
-                // default to lastSlot = 2 * infoList.size, so slot / 2 would be out of bounds.
-                else -> infoList[(startSlot / 2).coerceAtMost(infoList.lastIndex)].rawCrossStatus
-            }
-
-    override val startInfo: SelectableInfo
-        get() = infoList[startOrEndSlotToIndex(startSlot, isStartSlot = true)]
-
-    override val endInfo: SelectableInfo
-        get() = infoList[startOrEndSlotToIndex(endSlot, isStartSlot = false)]
-
-    override val currentInfo: SelectableInfo
-        get() = if (isStartHandle) startInfo else endInfo
-
-    override val firstInfo: SelectableInfo
-        get() = if (crossStatus == CrossStatus.CROSSED) endInfo else startInfo
-
-    override val lastInfo: SelectableInfo
-        get() = if (crossStatus == CrossStatus.CROSSED) startInfo else endInfo
-
-    override fun forEachMiddleInfo(block: (SelectableInfo) -> Unit) {
-        val minIndex = getInfoListIndexBySelectableId(firstInfo.selectableId)
-        val maxIndex = getInfoListIndexBySelectableId(lastInfo.selectableId)
-        if (minIndex + 1 >= maxIndex) {
-            return
-        }
-
-        for (i in minIndex + 1 until maxIndex) {
-            block(infoList[i])
-        }
-    }
-
-    override fun infoForSelectable(selectableId: Long): SelectableInfo? {
-        return infoBySelectableId[selectableId]
-    }
-
-    override fun shouldRecomputeSelection(other: SelectionLayout?): Boolean =
-        previousSelection == null ||
-            other == null ||
-            other !is MultiSelectionLayout ||
-            isStartHandle != other.isStartHandle ||
-            startSlot != other.startSlot ||
-            endSlot != other.endSlot ||
-            shouldAnyInfoRecomputeSelection(other)
-
-    private fun shouldAnyInfoRecomputeSelection(other: MultiSelectionLayout): Boolean {
-        if (size != other.size) return true
-        for (i in infoList.indices) {
-            val thisInfo = infoList[i]
-            val otherInfo = other.infoList[i]
-            if (thisInfo.shouldRecomputeSelection(otherInfo)) {
-                return true
-            }
-        }
-        return false
-    }
-
-    override fun createSubSelections(selection: Selection): LongObjectMap<Selection> =
-        createSubSelections(
-            selection = selection,
-            sortedItems = infoList,
-            getId = { it.selectableId },
-            getSelectAll = { info, _ ->
-                if (selection.handlesCrossed) {
-                    info.makeSingleLayoutSelection(info.textLength, 0)
-                } else {
-                    info.makeSingleLayoutSelection(0, info.textLength)
-                }
-            },
-            createBoundarySelection = { info, isStart, offset, _ ->
-                val isCrossed = selection.handlesCrossed
-                if (isStart) {
-                    if (isCrossed) {
-                        info.makeSingleLayoutSelection(start = offset, end = 0)
-                    } else {
-                        info.makeSingleLayoutSelection(start = offset, end = info.textLength)
-                    }
-                } else {
-                    if (isCrossed) {
-                        info.makeSingleLayoutSelection(start = info.textLength, end = offset)
-                    } else {
-                        info.makeSingleLayoutSelection(start = 0, end = offset)
-                    }
-                }
-            },
-        )
-
-    override fun toString(): String =
-        "MultiSelectionLayout(isStartHandle=$isStartHandle, " +
-            "startPosition=${(startSlot + 1).toFloat() / 2}, " +
-            "endPosition=${(endSlot + 1).toFloat() / 2}, " +
-            "crossed=$crossStatus, " +
-            "infos=${
-            buildString {
-                append("[\n\t")
-                var first = true
-                infoList
-                    .fastForEachIndexed { index, info ->
-                        if (first) {
-                            first = false
-                        } else {
-                            append(",\n\t")
-                        }
-                        append("${(index + 1)} -> $info")
-                    }
-                append("\n]")
-            }
-        })"
-
-    private fun startOrEndSlotToIndex(slot: Int, isStartSlot: Boolean): Int =
-        slotToIndex(
-            slot = slot,
-            isMinimumSlot =
-                when (crossStatus) {
-                    // collapsed: doesn't matter whether true or false, it will result in the same
-                    // index
-                    CrossStatus.COLLAPSED -> true
-                    CrossStatus.NOT_CROSSED -> isStartSlot
-                    CrossStatus.CROSSED -> !isStartSlot
-                },
-        )
-
-    private fun slotToIndex(slot: Int, isMinimumSlot: Boolean): Int {
-        val slotAdjustment = if (isMinimumSlot) 0 else 1
-        // FORK CHANGE: clamp when the gesture starts past every selectable, slots default
-        // to lastSlot = 2 * infoList.size, so slot / 2 would be out of bounds.
-        return ((slot - slotAdjustment) / 2).coerceIn(0, infoList.lastIndex)
-    }
-
-    private fun getInfoListIndexBySelectableId(id: Long): Int =
-        try {
-            selectableIdToInfoListIndex[id]
-        } catch (e: NoSuchElementException) {
-            throw IllegalStateException("Invalid selectableId: $id", e)
-        }
-}
-
-/**
- * Create a selection layout that has only one slot.
- *
- * @param isStartHandle whether this is the start or end anchor
- * @param previousSelection the previous selection
- * @param info the single [SelectableInfo]
- */
-private class SingleSelectionLayout(
-    override val isStartHandle: Boolean,
-    override val startSlot: Int,
-    override val endSlot: Int,
-    override val previousSelection: Selection?,
-    private val info: SelectableInfo,
-) : SelectionLayout {
-    companion object {
-        const val DEFAULT_SLOT = 1
-        const val DEFAULT_SELECTABLE_ID = 1L
-    }
-
-    override val size
-        get() = 1
-
-    override val crossStatus: CrossStatus
-        get() =
-            when {
-                startSlot < endSlot -> CrossStatus.NOT_CROSSED
-                startSlot > endSlot -> CrossStatus.CROSSED
-                else -> info.rawCrossStatus
-            }
-
-    override val startInfo: SelectableInfo
-        get() = info
-
-    override val endInfo: SelectableInfo
-        get() = info
-
-    override val currentInfo: SelectableInfo
-        get() = info
-
-    override val firstInfo: SelectableInfo
-        get() = info
-
-    override val lastInfo: SelectableInfo
-        get() = info
-
-    override fun forEachMiddleInfo(block: (SelectableInfo) -> Unit) {
-        // there are no middle infos, so do nothing
-    }
-
-    override fun infoForSelectable(selectableId: Long): SelectableInfo? {
-        return if (selectableId == info.selectableId) info else null
-    }
-
-    override fun shouldRecomputeSelection(other: SelectionLayout?): Boolean =
-        previousSelection == null ||
-            other == null ||
-            other !is SingleSelectionLayout ||
-            startSlot != other.startSlot ||
-            endSlot != other.endSlot ||
-            isStartHandle != other.isStartHandle ||
-            info.shouldRecomputeSelection(other.info)
-
-    override fun createSubSelections(selection: Selection): LongObjectMap<Selection> {
-        val finalSelection =
-            selection.run {
-                // uncross handles if necessary
-                if (
-                    (!handlesCrossed && start.offset > end.offset) ||
-                        (handlesCrossed && start.offset <= end.offset)
-                ) {
-                    copy(handlesCrossed = !handlesCrossed)
-                } else {
-                    this
-                }
-            }
-        return longObjectMapOf(info.selectableId, finalSelection)
-    }
-
-    override fun toString(): String =
-        "SingleSelectionLayout(isStartHandle=$isStartHandle, crossed=$crossStatus, info=\n\t$info)"
-}
-
-/**
- * Create a selection layout that has only one slot.
- *
- * This is intended for TextField, where multiple selectables is of no concern.
- *
- * @param layoutResult the [TextLayoutResult] for the text field
- * @param rawStartHandleOffset the index of the start handle
- * @param rawEndHandleOffset the index of the end handle
- * @param rawPreviousHandleOffset the previous handle offset based on [isStartHandle], or
- *   [UNASSIGNED_SLOT] if none
- * @param previousSelectionRange the previous selection
- * @param isStartOfSelection whether this is the start of a selection gesture (no previous context)
- * @param isStartHandle whether this is the start or end anchor
- */
-internal fun getTextFieldSelectionLayout(
-    layoutResult: TextLayoutResult,
-    rawStartHandleOffset: Int,
-    rawEndHandleOffset: Int,
-    rawPreviousHandleOffset: Int,
-    previousSelectionRange: TextRange,
-    isStartOfSelection: Boolean,
-    isStartHandle: Boolean,
-): SelectionLayout =
-    SingleSelectionLayout(
-        isStartHandle = isStartHandle,
-        startSlot = SingleSelectionLayout.DEFAULT_SLOT,
-        endSlot = SingleSelectionLayout.DEFAULT_SLOT,
-        previousSelection =
-            if (isStartOfSelection) null
-            else
-                Selection(
-                    start =
-                        Selection.AnchorInfo(
-                            layoutResult.getTextDirectionForOffset(previousSelectionRange.start),
-                            previousSelectionRange.start,
-                            SingleSelectionLayout.DEFAULT_SELECTABLE_ID,
-                        ),
-                    end =
-                        Selection.AnchorInfo(
-                            layoutResult.getTextDirectionForOffset(previousSelectionRange.end),
-                            previousSelectionRange.end,
-                            SingleSelectionLayout.DEFAULT_SELECTABLE_ID,
-                        ),
-                    handlesCrossed = previousSelectionRange.reversed,
-                ),
-        info =
-            SelectableInfo(
-                selectableId = SingleSelectionLayout.DEFAULT_SELECTABLE_ID,
-                slot = SingleSelectionLayout.DEFAULT_SLOT,
-                rawStartHandleOffset = rawStartHandleOffset,
-                rawEndHandleOffset = rawEndHandleOffset,
-                textLayoutResult = layoutResult,
-                rawPreviousHandleOffset = rawPreviousHandleOffset,
-            ),
-    )
-
-/** Whether something is crossed as determined by the position of the start/end. */
-internal enum class CrossStatus {
-    /** The start comes after the end. */
-    CROSSED,
-
-    /** The start comes before the end. */
-    NOT_CROSSED,
-
-    /** The start is the same as the end. */
-    COLLAPSED,
-}
-
-/** Slot has not been assigned yet */
-internal const val UNASSIGNED_SLOT = -1
-
-/**
- * A builder for [SelectionLayout] that ensures the data structures and slots are properly
- * constructed.
- *
- * @param previousHandlePosition the previous handle position matching the handle directed to by
- *   [isStartHandle]
- * @param containerCoordinates the coordinates of the [SelectionContainer] for converting
- *   [SelectionContainer] coordinates to their respective [Selectable] coordinates
- * @param isStartHandle whether the currently pressed/clicked handle is the start
- * @param previousLayout The [SelectionLayout] created when [currentPosition] was
- *   [previousHandlePosition]. When non-null, it is used to obtain
- *   [SelectableInfo.rawPreviousHandleOffset] instead of re-computing it from
- *   [previousHandlePosition]. Note that this is not just an optimization. When selectables are
- *   moved (due to drag-to-scroll, for example) inside the selection container, it becomes
- *   impossible to correctly deduce [SelectableInfo.rawPreviousHandleOffset] from
- *   [previousHandlePosition] (because to do that, the "previous" layout coordinates are needed, but
- *   are not available).
- * @param selectableIdOrderingComparator determines the ordering of selectables by their IDs
- * @param allowSelectionBetweenSelectables whether selection in the "empty" area where there are no
- *   selectables is allowed.
- */
-internal class SelectionLayoutBuilder(
-    val currentPosition: Offset,
-    val previousHandlePosition: Offset,
-    val containerCoordinates: LayoutCoordinates,
-    val isStartHandle: Boolean,
-    val previousSelection: Selection?,
-    val previousLayout: SelectionLayout?,
-    val selectableIdOrderingComparator: Comparator<Long>,
-    val allowSelectionBetweenSelectables: Boolean = false,
-) {
-    private val selectableIdToInfoListIndex: MutableLongIntMap = mutableLongIntMapOf()
-    private val infoList: MutableList<SelectableInfo> = mutableListOf()
-    private var startSlot: Int = UNASSIGNED_SLOT
-    private var endSlot: Int = UNASSIGNED_SLOT
-    private var currentSlot: Int = UNASSIGNED_SLOT
-
-    /**
-     * Finishes building the [SelectionLayout] and returns it.
-     *
-     * @return the [SelectionLayout] or null if no [SelectableInfo]s were added.
-     */
-    fun build(): SelectionLayout? {
-        val lastSlot = currentSlot + 1
-        return when (infoList.size) {
-            0 -> {
-                null
-            }
-            1 -> {
-                SingleSelectionLayout(
-                    info = infoList.single(),
-                    startSlot = if (startSlot == UNASSIGNED_SLOT) lastSlot else startSlot,
-                    endSlot = if (endSlot == UNASSIGNED_SLOT) lastSlot else endSlot,
-                    previousSelection = previousSelection,
-                    isStartHandle = isStartHandle,
-                )
-            }
-            else -> {
-                MultiSelectionLayout(
-                    selectableIdToInfoListIndex = selectableIdToInfoListIndex,
-                    infoList = infoList,
-                    startSlot = if (startSlot == UNASSIGNED_SLOT) lastSlot else startSlot,
-                    endSlot = if (endSlot == UNASSIGNED_SLOT) lastSlot else endSlot,
-                    isStartHandle = isStartHandle,
-                    previousSelection = previousSelection,
-                )
-            }
-        }
-    }
-
-    /** Appends a selection info to this builder. */
-    fun appendInfo(
-        selectableId: Long,
-        rawStartHandleOffset: Int,
-        startXHandleDirection: Direction,
-        startYHandleDirection: Direction,
-        rawEndHandleOffset: Int,
-        endXHandleDirection: Direction,
-        endYHandleDirection: Direction,
-        rawPreviousHandleOffset: Int,
-        textLayoutResult: TextLayoutResult,
-    ): SelectableInfo {
-        // We need currentSlot to equal the slot of the "last" info when getLayout is called,
-        // so increment this before adding the info and leave the correct slot in place at the end.
-        currentSlot += 2
-
-        val selectableInfo =
-            SelectableInfo(
-                selectableId = selectableId,
-                slot = currentSlot,
-                rawStartHandleOffset = rawStartHandleOffset,
-                rawEndHandleOffset = rawEndHandleOffset,
-                rawPreviousHandleOffset = rawPreviousHandleOffset,
-                textLayoutResult = textLayoutResult,
-            )
-
-        startSlot = updateSlot(startSlot, startXHandleDirection, startYHandleDirection)
-        endSlot = updateSlot(endSlot, endXHandleDirection, endYHandleDirection)
-        selectableIdToInfoListIndex[selectableId] = infoList.size
-        infoList += selectableInfo
-        return selectableInfo
-    }
-
-    /**
-     * Find the slot for a selectable given the current position's directions from the selectable.
-     *
-     * The selectables must be ordered in the order in which they would be selected, and then this
-     * function should be called for each of those selectables.
-     *
-     * It is expected that the input [slot] is also assigned the result of this function.
-     *
-     * This function is stateful.
-     *
-     * @param slot the current value of this slot.
-     * @param xPositionDirection Where the x-position is relative to the selectable
-     * @param yPositionDirection Where the y-position is relative to the selectable
-     */
-    private fun updateSlot(
-        slot: Int,
-        xPositionDirection: Direction,
-        yPositionDirection: Direction,
-    ): Int {
-        if (slot != UNASSIGNED_SLOT) {
-            // don't overwrite if the slot has already been determined
-            return slot
-        }
-
-        // slot has not been determined yet,
-        // see if we are on or past the selectable we are looking for
-        return when (resolve2dDirection(xPositionDirection, yPositionDirection)) {
-            // If we get here, that means we never found a selectable that contains our gesture
-            // position. This is the first selectable that is after the position,
-            // so our slot must be between the previous and current selectables.
-            BEFORE -> currentSlot - 1
-
-            // The gesture position is directly on this selectable, so use this one.
-            ON -> currentSlot
-
-            // keep looking
-            AFTER -> slot
-        }
-    }
-}
-
-/** Where the position of a cursor/press is compared to a selectable. */
-internal enum class Direction {
-    /** The cursor/press is before the selectable */
-    BEFORE,
-
-    /** The cursor/press is on the selectable */
-    ON,
-
-    /** The cursor/press is after the selectable */
-    AFTER,
-}
-
-/**
- * Determine direction based on an x/y direction.
- *
- * This will use the [y] direction unless it is [ON], in which case it will use the [x] direction.
- */
-internal fun resolve2dDirection(x: Direction, y: Direction): Direction =
-    when (y) {
-        BEFORE -> BEFORE
-        ON ->
-            when (x) {
-                BEFORE -> BEFORE
-                ON -> ON
-                AFTER -> AFTER
-            }
-        AFTER -> AFTER
-    }
-
-/** Data about a specific selectable within a [SelectionLayout]. */
-internal class SelectableInfo(
-    val selectableId: Long,
-    val slot: Int,
-    val rawStartHandleOffset: Int,
-    val rawEndHandleOffset: Int,
-    val rawPreviousHandleOffset: Int,
-    val textLayoutResult: TextLayoutResult,
-) {
-
-    /** The [String] in the selectable. */
-    val inputText: String
-        get() = textLayoutResult.layoutInput.text.text
-
-    /** The length of the [String] in the selectable. */
-    val textLength: Int
-        get() = inputText.length
-
-    /** Whether the raw offsets of this info are crossed. */
-    val rawCrossStatus: CrossStatus
-        get() =
-            when {
-                rawStartHandleOffset < rawEndHandleOffset -> CrossStatus.NOT_CROSSED
-                rawStartHandleOffset > rawEndHandleOffset -> CrossStatus.CROSSED
-                else -> CrossStatus.COLLAPSED
-            }
-
-    private val startRunDirection
-        get() = textLayoutResult.getTextDirectionForOffset(rawStartHandleOffset)
-
-    private val endRunDirection
-        get() = textLayoutResult.getTextDirectionForOffset(rawEndHandleOffset)
-
-    /**
-     * Whether this info, compared to another info, has any relevant changes that would require
-     * recomputing selection.
-     *
-     * @param other the selectable info to check for changes compared to this one
-     */
-    fun shouldRecomputeSelection(other: SelectableInfo): Boolean =
-        selectableId != other.selectableId ||
-            rawStartHandleOffset != other.rawStartHandleOffset ||
-            rawEndHandleOffset != other.rawEndHandleOffset
-
-    /** Get a [Selection.AnchorInfo] for this [SelectableInfo] at the given [offset]. */
-    fun anchorForOffset(offset: Int): Selection.AnchorInfo =
-        Selection.AnchorInfo(
-            direction = textLayoutResult.getTextDirectionForOffset(offset),
-            offset = offset,
-            selectableId = selectableId,
-        )
-
-    /**
-     * Get a [Selection] within the selectable represented by this [SelectableInfo] for the given
-     * [start] and [end] offsets.
-     */
-    fun makeSingleLayoutSelection(start: Int, end: Int): Selection =
-        Selection(
-            start = anchorForOffset(start),
-            end = anchorForOffset(end),
-            handlesCrossed = start > end,
-        )
-
-    override fun toString(): String =
-        "SelectionInfo(id=$selectableId, " +
-            "range=($rawStartHandleOffset-$startRunDirection,$rawEndHandleOffset-$endRunDirection), " +
-            "prevOffset=$rawPreviousHandleOffset)"
-}
-
-/**
- * Verify that the selection is truly collapsed.
- *
- * If the selection is contained within one selectable, this simply checks if the offsets are equal.
- *
- * If the Selection spans multiple selectables, then this will verify that every selected selectable
- * contains a zero-width selection.
- */
-internal fun Selection?.isCollapsed(layout: SelectionLayout?): Boolean {
-    this ?: return true
-    layout ?: return true
-
-    // Selection is within one selectable, simply check if the offsets are the same.
-    if (start.selectableId == end.selectableId) {
-        return start.offset == end.offset
-    }
-
-    // check that maxAnchor offset is 0, else the selection cannot be collapsed.
-    val maxAnchor = if (handlesCrossed) start else end
-    if (maxAnchor.offset != 0) {
-        return false
-    }
-
-    // check that the minAnchor offset is equal to the length of the text,
-    // else the selection is not collapsed
-    val minAnchor = if (handlesCrossed) end else start
-    if (layout.firstInfo.textLength != minAnchor.offset) {
-        return false
-    }
-
-    // Every selectable between the min and max must have empty text,
-    // else there is some text selected.
-    var allTextsEmpty = true
-    layout.forEachMiddleInfo {
-        if (it.inputText.isNotEmpty()) {
-            allTextsEmpty = false
-        }
-    }
-
-    return allTextsEmpty
-}
-
-internal fun <T> createSubSelections(
-    selection: Selection,
-    sortedItems: List<T>,
-    getId: (T) -> Long,
-    getSelectAll: (T, handlesCrossed: Boolean) -> Selection?,
-    createBoundarySelection:
-        (item: T, isStart: Boolean, offset: Int, handlesCrossed: Boolean) -> Selection?,
-): LongObjectMap<Selection> {
-    val startId = selection.start.selectableId
-    val endId = selection.end.selectableId
-
-    if (startId == endId) {
-        return longObjectMapOf(startId, selection)
-    }
-
-    val startIndex = sortedItems.indexOfFirst { getId(it) == startId }
-    val endIndex = sortedItems.indexOfFirst { getId(it) == endId }
-
-    if (startIndex == -1 || endIndex == -1) {
-        return emptyLongObjectMap()
-    }
-
-    val firstIndex = minOf(startIndex, endIndex)
-    val lastIndex = maxOf(startIndex, endIndex)
-    val handlesCrossed = startIndex > endIndex
-
-    val result = mutableLongObjectMapOf<Selection>()
-
-    for (i in firstIndex..lastIndex) {
-        val item = sortedItems[i]
-        val id = getId(item)
-
-        val subSelection =
-            when (id) {
-                startId ->
-                    createBoundarySelection(item, true, selection.start.offset, handlesCrossed)
-                endId -> createBoundarySelection(item, false, selection.end.offset, handlesCrossed)
-                else -> getSelectAll(item, handlesCrossed)
-            }
-        subSelection?.let { result[id] = it }
-    }
-
-    return result
-}
@@ -1,3 +1,9 @@
+// VENDOR-REIMPL: compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/Clickable.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 androidx.compose.foundation

 import androidx.compose.ui.node.DelegatableNode
@@ -1,3 +1,9 @@
+// VENDOR-REIMPL: compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/DarkTheme.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 androidx.compose.foundation

 import androidx.compose.runtime.Composable
@@ -1,4 +1,4 @@
-// VENDOR-BASE: compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/Scrollbar.skiko.kt @ v1.12.0-beta03+dev4483
+// VENDOR-BASE: compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/Scrollbar.skiko.kt @ v1.12.1
 // MANUAL VENDOR: refused in compose-fork.txt (flat native source set). Only edit vs base is the
 // K2 @file:Suppress below - identical to what sync.py injects into src/vendor .kt (this file lives
 // in src/nativeMain so sync doesn't regenerate it). Needed so compileNativeMainKotlinMetadata (the
@@ -14,6 +14,12 @@
 * limitations under the License.
 */

+// VENDOR-REIMPL: compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/draganddrop/DragAndDropSource.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 androidx.compose.foundation.draganddrop

 import androidx.compose.foundation.gestures.detectDragGestures
@@ -1,3 +1,9 @@
+// VENDOR-REIMPL: compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/text/StringHelpers.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 androidx.compose.foundation.text

 // ==================
@@ -1,4 +1,4 @@
-// VENDOR-BASE: compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/v2/Scrollbar.skiko.kt @ v1.12.0-beta03+dev4483
+// VENDOR-BASE: compose/foundation/foundation/src/skikoMain/kotlin/androidx/compose/foundation/v2/Scrollbar.skiko.kt @ v1.12.1
 // MANUAL VENDOR: expect fun runBlockingIfPossible inlined to runBlocking (flat native source set can't hold expect+actual together).
 // Also carries the K2 @file:Suppress below (same as sync.py injects into src/vendor) so the native metadata compile / Windows publish accepts the orphaned JVM annotation.
 /*
@@ -2,7 +2,9 @@ package com.compose.sdl.icons

 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.wrapContentSize
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontVariation
@@ -36,9 +38,21 @@ fun IconFontIcon(
 	size: Dp = IconDefaults.DefaultIconSize,
 	fontVariationSettings: List<FontVariation.Setting>? = null,
 ) {
-	Box(modifier = modifier.size(size)) {
+	// CENTER the glyph in the icon box. The glyph's natural text box is TALLER than
+	// `size` - its height is the font's ascent+descent, and Material Symbols' em box
+	// overshoots the nominal icon size - so the glyph used to render ~13% of the icon
+	// size too LOW. This mirrors the JVM actual's explicit baseline math
+	// (`y = height/2 - (ascent+descent)/2` in MaterialSymbolsIcon.jvm.kt): IconText
+	// sets no lineHeight, so its box height IS ascent+descent and centering that box
+	// centers the same span the JVM centers.
+	//
+	// `wrapContentSize(unbounded = true)` is load-bearing: Modifier.size() hands the
+	// child FIXED constraints, so without it the text is measured at exactly `size`,
+	// nothing overflows, and contentAlignment has nothing to align.
+	Box(modifier = modifier.size(size), contentAlignment = Alignment.Center) {
 		com.compose.sdl.text.IconText(
 			text = codepointToString(codepoint),
+			modifier = Modifier.wrapContentSize(Alignment.Center, unbounded = true),
 			fontFamily = fontFamily,
 			color = tint,
 			fontSize = size.value.sp,
@@ -47,7 +61,7 @@ fun IconFontIcon(
 	}
 }

-object IconDefaults {
+internal object IconDefaults {
 	val DefaultIconSize: Dp = 24.dp
 	/** STATIC fallback tint for direct IconFontIcon use - :foundation cannot
 	   read material3's LocalContentColor (module layering, same as upstream).
@@ -28,8 +28,8 @@ kotlin {
 			dependencies {
 				// ripple imports androidx.compose.foundation.* (Indication) and
 				// androidx.compose.animation.core.* (RippleAnimation); ui/runtime arrive transitively.
-				api(project(":foundation"))
-				api(project(":animation-core"))
+				api(project(":compose:foundation:foundation"))
+				api(project(":compose:animation:animation-core"))
 			}
 			kotlin.srcDir("src/vendor/common/kotlin")
 		}
@@ -0,0 +1,658 @@
+// 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.material3.adaptive:adaptive-layout>
+final enum class androidx.compose.material3.adaptive.layout/DockedEdge : kotlin/Enum<androidx.compose.material3.adaptive.layout/DockedEdge> { // androidx.compose.material3.adaptive.layout/DockedEdge|null[0]
+    enum entry Bottom // androidx.compose.material3.adaptive.layout/DockedEdge.Bottom|null[0]
+    enum entry End // androidx.compose.material3.adaptive.layout/DockedEdge.End|null[0]
+    enum entry Start // androidx.compose.material3.adaptive.layout/DockedEdge.Start|null[0]
+    enum entry Top // androidx.compose.material3.adaptive.layout/DockedEdge.Top|null[0]
+
+    final val entries // androidx.compose.material3.adaptive.layout/DockedEdge.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<androidx.compose.material3.adaptive.layout/DockedEdge> // androidx.compose.material3.adaptive.layout/DockedEdge.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): androidx.compose.material3.adaptive.layout/DockedEdge // androidx.compose.material3.adaptive.layout/DockedEdge.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<androidx.compose.material3.adaptive.layout/DockedEdge> // androidx.compose.material3.adaptive.layout/DockedEdge.values|values#static(){}[0]
+}
+
+final enum class androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole : androidx.compose.material3.adaptive.layout/PaneScaffoldRole, kotlin/Enum<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole> { // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole|null[0]
+    enum entry Primary // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole.Primary|null[0]
+    enum entry Secondary // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole.Secondary|null[0]
+    enum entry Tertiary // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole.Tertiary|null[0]
+
+    final val entries // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole> // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole.entries.<get-entries>|<get-entries>#static(){}[0]
+
+    final fun valueOf(kotlin/String): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole> // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole.values|values#static(){}[0]
+}
+
+abstract interface androidx.compose.material3.adaptive.layout/AnimatedPaneOverride { // androidx.compose.material3.adaptive.layout/AnimatedPaneOverride|null[0]
+    abstract fun <#A1: androidx.compose.material3.adaptive.layout/PaneScaffoldRole, #B1: androidx.compose.material3.adaptive.layout/PaneScaffoldValue<#A1>> (androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope<#A1, #B1>).AnimatedPane(androidx.compose.runtime/Composer?, kotlin/Int) // androidx.compose.material3.adaptive.layout/AnimatedPaneOverride.AnimatedPane|AnimatedPane@androidx.compose.material3.adaptive.layout.AnimatedPaneOverrideScope<0:0,0:1>(androidx.compose.runtime.Composer?;kotlin.Int){0§<androidx.compose.material3.adaptive.layout.PaneScaffoldRole>;1§<androidx.compose.material3.adaptive.layout.PaneScaffoldValue<0:0>>}[0]
+}
+
+abstract interface androidx.compose.material3.adaptive.layout/PaneScaffoldRole // androidx.compose.material3.adaptive.layout/PaneScaffoldRole|null[0]
+
+abstract interface androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverride { // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverride|null[0]
+    abstract fun (androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope).ThreePaneScaffold(androidx.compose.runtime/Composer?, kotlin/Int) // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverride.ThreePaneScaffold|ThreePaneScaffold@androidx.compose.material3.adaptive.layout.ThreePaneScaffoldOverrideScope(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+}
+
+sealed interface <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole, #B: androidx.compose.material3.adaptive.layout/PaneScaffoldValue<#A>> androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldPaneScope : androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldScope<#A, #B>, androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope<#A> // androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldPaneScope|null[0]
+
+sealed interface <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole, #B: androidx.compose.material3.adaptive.layout/PaneScaffoldValue<#A>> androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldScope : androidx.compose.material3.adaptive.layout/PaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope<#A, #B>, androidx.compose.ui.layout/LookaheadScope { // androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldScope|null[0]
+    abstract val focusRequesters // androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldScope.focusRequesters|{}focusRequesters[0]
+        abstract fun <get-focusRequesters>(): kotlin.collections/Map<#A, androidx.compose.ui.focus/FocusRequester> // androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldScope.focusRequesters.<get-focusRequesters>|<get-focusRequesters>(){}[0]
+}
+
+sealed interface <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole, #B: androidx.compose.material3.adaptive.layout/PaneScaffoldValue<#A>> androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope { // androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope|null[0]
+    abstract val motionDataProvider // androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope.motionDataProvider|{}motionDataProvider[0]
+        abstract fun <get-motionDataProvider>(): androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider<#A> // androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope.motionDataProvider.<get-motionDataProvider>|<get-motionDataProvider>(){}[0]
+    abstract val motionProgress // androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope.motionProgress|{}motionProgress[0]
+        abstract fun <get-motionProgress>(): kotlin/Float // androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope.motionProgress.<get-motionProgress>|<get-motionProgress>(){}[0]
+    abstract val scaffoldStateTransition // androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope.scaffoldStateTransition|{}scaffoldStateTransition[0]
+        abstract fun <get-scaffoldStateTransition>(): androidx.compose.animation.core/Transition<#B> // androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope.scaffoldStateTransition.<get-scaffoldStateTransition>|<get-scaffoldStateTransition>(){}[0]
+}
+
+sealed interface <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole> androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder { // androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder|null[0]
+    abstract val size // androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder.size|{}size[0]
+        abstract fun <get-size>(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder.size.<get-size>|<get-size>(){}[0]
+
+    abstract fun forEach(kotlin/Function1<#A, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder.forEach|forEach(kotlin.Function1<1:0,kotlin.Unit>){}[0]
+    abstract fun forEachIndexed(kotlin/Function2<kotlin/Int, #A, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder.forEachIndexed|forEachIndexed(kotlin.Function2<kotlin.Int,1:0,kotlin.Unit>){}[0]
+    abstract fun forEachIndexedReversed(kotlin/Function2<kotlin/Int, #A, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder.forEachIndexedReversed|forEachIndexedReversed(kotlin.Function2<kotlin.Int,1:0,kotlin.Unit>){}[0]
+    abstract fun indexOf(#A): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder.indexOf|indexOf(1:0){}[0]
+}
+
+sealed interface <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole> androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider { // androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider|null[0]
+    abstract val count // androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider.count|{}count[0]
+        abstract fun <get-count>(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider.count.<get-count>|<get-count>(){}[0]
+    abstract val scaffoldSize // androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider.scaffoldSize|{}scaffoldSize[0]
+        abstract fun <get-scaffoldSize>(): androidx.compose.ui.unit/IntSize // androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider.scaffoldSize.<get-scaffoldSize>|<get-scaffoldSize>(){}[0]
+
+    abstract fun get(#A): androidx.compose.material3.adaptive.layout/PaneMotionData // androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider.get|get(1:0){}[0]
+    abstract fun get(kotlin/Int): androidx.compose.material3.adaptive.layout/PaneMotionData // androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider.get|get(kotlin.Int){}[0]
+    abstract fun getRoleAt(kotlin/Int): #A // androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider.getRoleAt|getRoleAt(kotlin.Int){}[0]
+}
+
+sealed interface <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole> androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope { // androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope|null[0]
+    abstract val isInteractable // androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope.isInteractable|{}isInteractable[0]
+        abstract fun <get-isInteractable>(): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope.isInteractable.<get-isInteractable>|<get-isInteractable>(){}[0]
+    abstract val paneMotion // androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope.paneMotion|{}paneMotion[0]
+        abstract fun <get-paneMotion>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope.paneMotion.<get-paneMotion>|<get-paneMotion>(){}[0]
+    abstract val paneRole // androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope.paneRole|{}paneRole[0]
+        abstract fun <get-paneRole>(): #A // androidx.compose.material3.adaptive.layout/PaneScaffoldPaneScope.paneRole.<get-paneRole>|<get-paneRole>(){}[0]
+}
+
+sealed interface <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole> androidx.compose.material3.adaptive.layout/PaneScaffoldValue { // androidx.compose.material3.adaptive.layout/PaneScaffoldValue|null[0]
+    abstract fun get(#A): androidx.compose.material3.adaptive.layout/PaneAdaptedValue // androidx.compose.material3.adaptive.layout/PaneScaffoldValue.get|get(1:0){}[0]
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/AdaptStrategy { // androidx.compose.material3.adaptive.layout/AdaptStrategy|null[0]
+    open fun adapt(): androidx.compose.material3.adaptive.layout/PaneAdaptedValue // androidx.compose.material3.adaptive.layout/AdaptStrategy.adapt|adapt(){}[0]
+
+    final class Levitate : androidx.compose.material3.adaptive.layout/AdaptStrategy { // androidx.compose.material3.adaptive.layout/AdaptStrategy.Levitate|null[0]
+        constructor <init>(androidx.compose.ui/Alignment = ..., kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? = ...) // androidx.compose.material3.adaptive.layout/AdaptStrategy.Levitate.<init>|<init>(androidx.compose.ui.Alignment;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?){}[0]
+        constructor <init>(androidx.compose.ui/Alignment = ..., kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? = ..., androidx.compose.material3.adaptive.layout/DragToResizeState? = ...) // androidx.compose.material3.adaptive.layout/AdaptStrategy.Levitate.<init>|<init>(androidx.compose.ui.Alignment;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.DragToResizeState?){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/AdaptStrategy.Levitate.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/AdaptStrategy.Levitate.hashCode|hashCode(){}[0]
+        final fun onlyIf(kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.material3.adaptive.layout/AdaptStrategy // androidx.compose.material3.adaptive.layout/AdaptStrategy.Levitate.onlyIf|onlyIf(kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+        final fun onlyIfSinglePane(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.material3.adaptive.layout/AdaptStrategy // androidx.compose.material3.adaptive.layout/AdaptStrategy.Levitate.onlyIfSinglePane|onlyIfSinglePane(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+        final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/AdaptStrategy.Levitate.toString|toString(){}[0]
+    }
+
+    final class Reflow : androidx.compose.material3.adaptive.layout/AdaptStrategy { // androidx.compose.material3.adaptive.layout/AdaptStrategy.Reflow|null[0]
+        constructor <init>(androidx.compose.material3.adaptive.layout/PaneScaffoldRole) // androidx.compose.material3.adaptive.layout/AdaptStrategy.Reflow.<init>|<init>(androidx.compose.material3.adaptive.layout.PaneScaffoldRole){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/AdaptStrategy.Reflow.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/AdaptStrategy.Reflow.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/AdaptStrategy.Reflow.toString|toString(){}[0]
+    }
+
+    final object Companion { // androidx.compose.material3.adaptive.layout/AdaptStrategy.Companion|null[0]
+        final val Hide // androidx.compose.material3.adaptive.layout/AdaptStrategy.Companion.Hide|{}Hide[0]
+            final fun <get-Hide>(): androidx.compose.material3.adaptive.layout/AdaptStrategy // androidx.compose.material3.adaptive.layout/AdaptStrategy.Companion.Hide.<get-Hide>|<get-Hide>(){}[0]
+    }
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/AnimatedPaneScope : androidx.compose.animation/AnimatedVisibilityScope { // androidx.compose.material3.adaptive.layout/AnimatedPaneScope|null[0]
+    final object Companion { // androidx.compose.material3.adaptive.layout/AnimatedPaneScope.Companion|null[0]
+        final fun create(androidx.compose.animation/AnimatedVisibilityScope): androidx.compose.material3.adaptive.layout/AnimatedPaneScope // androidx.compose.material3.adaptive.layout/AnimatedPaneScope.Companion.create|create(androidx.compose.animation.AnimatedVisibilityScope){}[0]
+    }
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/PaneAdaptedValue { // androidx.compose.material3.adaptive.layout/PaneAdaptedValue|null[0]
+    final class Levitated : androidx.compose.material3.adaptive.layout/PaneAdaptedValue { // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Levitated|null[0]
+        constructor <init>(androidx.compose.ui/Alignment, kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? = ...) // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Levitated.<init>|<init>(androidx.compose.ui.Alignment;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?){}[0]
+        constructor <init>(androidx.compose.ui/Alignment, kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? = ..., androidx.compose.material3.adaptive.layout/DragToResizeState? = ...) // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Levitated.<init>|<init>(androidx.compose.ui.Alignment;kotlin.Function2<androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.DragToResizeState?){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Levitated.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Levitated.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Levitated.toString|toString(){}[0]
+    }
+
+    final class Reflowed : androidx.compose.material3.adaptive.layout/PaneAdaptedValue { // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Reflowed|null[0]
+        constructor <init>(androidx.compose.material3.adaptive.layout/PaneScaffoldRole) // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Reflowed.<init>|<init>(androidx.compose.material3.adaptive.layout.PaneScaffoldRole){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Reflowed.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Reflowed.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Reflowed.toString|toString(){}[0]
+    }
+
+    final object Companion { // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Companion|null[0]
+        final val Expanded // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Companion.Expanded|{}Expanded[0]
+            final fun <get-Expanded>(): androidx.compose.material3.adaptive.layout/PaneAdaptedValue // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Companion.Expanded.<get-Expanded>|<get-Expanded>(){}[0]
+        final val Hidden // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Companion.Hidden|{}Hidden[0]
+            final fun <get-Hidden>(): androidx.compose.material3.adaptive.layout/PaneAdaptedValue // androidx.compose.material3.adaptive.layout/PaneAdaptedValue.Companion.Hidden.<get-Hidden>|<get-Hidden>(){}[0]
+    }
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/PaneExpansionStateKey { // androidx.compose.material3.adaptive.layout/PaneExpansionStateKey|null[0]
+    final object Companion { // androidx.compose.material3.adaptive.layout/PaneExpansionStateKey.Companion|null[0]
+        final val Default // androidx.compose.material3.adaptive.layout/PaneExpansionStateKey.Companion.Default|{}Default[0]
+            final fun <get-Default>(): androidx.compose.material3.adaptive.layout/PaneExpansionStateKey // androidx.compose.material3.adaptive.layout/PaneExpansionStateKey.Companion.Default.<get-Default>|<get-Default>(){}[0]
+    }
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/PaneExpansionStateKeyProvider { // androidx.compose.material3.adaptive.layout/PaneExpansionStateKeyProvider|null[0]
+    abstract val paneExpansionStateKey // androidx.compose.material3.adaptive.layout/PaneExpansionStateKeyProvider.paneExpansionStateKey|{}paneExpansionStateKey[0]
+        abstract fun <get-paneExpansionStateKey>(): androidx.compose.material3.adaptive.layout/PaneExpansionStateKey // androidx.compose.material3.adaptive.layout/PaneExpansionStateKeyProvider.paneExpansionStateKey.<get-paneExpansionStateKey>|<get-paneExpansionStateKey>(){}[0]
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/PaneMargins { // androidx.compose.material3.adaptive.layout/PaneMargins|null[0]
+    open fun (androidx.compose.ui.layout/Placeable.PlacementScope).getPaneBottom(kotlin/Int, kotlin/Int): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneMargins.getPaneBottom|getPaneBottom@androidx.compose.ui.layout.Placeable.PlacementScope(kotlin.Int;kotlin.Int){}[0]
+    open fun (androidx.compose.ui.layout/Placeable.PlacementScope).getPaneLeft(kotlin/Int): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneMargins.getPaneLeft|getPaneLeft@androidx.compose.ui.layout.Placeable.PlacementScope(kotlin.Int){}[0]
+    open fun (androidx.compose.ui.layout/Placeable.PlacementScope).getPaneRight(kotlin/Int, kotlin/Int): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneMargins.getPaneRight|getPaneRight@androidx.compose.ui.layout.Placeable.PlacementScope(kotlin.Int;kotlin.Int){}[0]
+    open fun (androidx.compose.ui.layout/Placeable.PlacementScope).getPaneTop(kotlin/Int): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneMargins.getPaneTop|getPaneTop@androidx.compose.ui.layout.Placeable.PlacementScope(kotlin.Int){}[0]
+
+    final object Companion { // androidx.compose.material3.adaptive.layout/PaneMargins.Companion|null[0]
+        final val Unspecified // androidx.compose.material3.adaptive.layout/PaneMargins.Companion.Unspecified|{}Unspecified[0]
+            final fun <get-Unspecified>(): androidx.compose.material3.adaptive.layout/PaneMargins // androidx.compose.material3.adaptive.layout/PaneMargins.Companion.Unspecified.<get-Unspecified>|<get-Unspecified>(){}[0]
+    }
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/PaneMotion { // androidx.compose.material3.adaptive.layout/PaneMotion|null[0]
+    abstract val type // androidx.compose.material3.adaptive.layout/PaneMotion.type|{}type[0]
+        abstract fun <get-type>(): androidx.compose.material3.adaptive.layout/PaneMotion.Type // androidx.compose.material3.adaptive.layout/PaneMotion.type.<get-type>|<get-type>(){}[0]
+
+    final value class Type { // androidx.compose.material3.adaptive.layout/PaneMotion.Type|null[0]
+        final val value // androidx.compose.material3.adaptive.layout/PaneMotion.Type.value|{}value[0]
+            final fun <get-value>(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneMotion.Type.value.<get-value>|<get-value>(){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneMotion.Type.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneMotion.Type.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/PaneMotion.Type.toString|toString(){}[0]
+
+        final object Companion { // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion|null[0]
+            final val Entering // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.Entering|{}Entering[0]
+                final fun <get-Entering>(): androidx.compose.material3.adaptive.layout/PaneMotion.Type // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.Entering.<get-Entering>|<get-Entering>(){}[0]
+            final val EnteringModal // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.EnteringModal|{}EnteringModal[0]
+                final fun <get-EnteringModal>(): androidx.compose.material3.adaptive.layout/PaneMotion.Type // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.EnteringModal.<get-EnteringModal>|<get-EnteringModal>(){}[0]
+            final val Exiting // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.Exiting|{}Exiting[0]
+                final fun <get-Exiting>(): androidx.compose.material3.adaptive.layout/PaneMotion.Type // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.Exiting.<get-Exiting>|<get-Exiting>(){}[0]
+            final val ExitingModal // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.ExitingModal|{}ExitingModal[0]
+                final fun <get-ExitingModal>(): androidx.compose.material3.adaptive.layout/PaneMotion.Type // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.ExitingModal.<get-ExitingModal>|<get-ExitingModal>(){}[0]
+            final val Hidden // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.Hidden|{}Hidden[0]
+                final fun <get-Hidden>(): androidx.compose.material3.adaptive.layout/PaneMotion.Type // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.Hidden.<get-Hidden>|<get-Hidden>(){}[0]
+            final val Shown // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.Shown|{}Shown[0]
+                final fun <get-Shown>(): androidx.compose.material3.adaptive.layout/PaneMotion.Type // androidx.compose.material3.adaptive.layout/PaneMotion.Type.Companion.Shown.<get-Shown>|<get-Shown>(){}[0]
+        }
+    }
+
+    final object Companion { // androidx.compose.material3.adaptive.layout/PaneMotion.Companion|null[0]
+        final val AnimateBounds // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.AnimateBounds|{}AnimateBounds[0]
+            final fun <get-AnimateBounds>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.AnimateBounds.<get-AnimateBounds>|<get-AnimateBounds>(){}[0]
+        final val EnterAsModal // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterAsModal|{}EnterAsModal[0]
+            final fun <get-EnterAsModal>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterAsModal.<get-EnterAsModal>|<get-EnterAsModal>(){}[0]
+        final val EnterFromLeft // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterFromLeft|{}EnterFromLeft[0]
+            final fun <get-EnterFromLeft>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterFromLeft.<get-EnterFromLeft>|<get-EnterFromLeft>(){}[0]
+        final val EnterFromLeftDelayed // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterFromLeftDelayed|{}EnterFromLeftDelayed[0]
+            final fun <get-EnterFromLeftDelayed>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterFromLeftDelayed.<get-EnterFromLeftDelayed>|<get-EnterFromLeftDelayed>(){}[0]
+        final val EnterFromRight // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterFromRight|{}EnterFromRight[0]
+            final fun <get-EnterFromRight>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterFromRight.<get-EnterFromRight>|<get-EnterFromRight>(){}[0]
+        final val EnterFromRightDelayed // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterFromRightDelayed|{}EnterFromRightDelayed[0]
+            final fun <get-EnterFromRightDelayed>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterFromRightDelayed.<get-EnterFromRightDelayed>|<get-EnterFromRightDelayed>(){}[0]
+        final val EnterWithExpand // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterWithExpand|{}EnterWithExpand[0]
+            final fun <get-EnterWithExpand>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.EnterWithExpand.<get-EnterWithExpand>|<get-EnterWithExpand>(){}[0]
+        final val ExitAsModal // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.ExitAsModal|{}ExitAsModal[0]
+            final fun <get-ExitAsModal>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.ExitAsModal.<get-ExitAsModal>|<get-ExitAsModal>(){}[0]
+        final val ExitToLeft // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.ExitToLeft|{}ExitToLeft[0]
+            final fun <get-ExitToLeft>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.ExitToLeft.<get-ExitToLeft>|<get-ExitToLeft>(){}[0]
+        final val ExitToRight // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.ExitToRight|{}ExitToRight[0]
+            final fun <get-ExitToRight>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.ExitToRight.<get-ExitToRight>|<get-ExitToRight>(){}[0]
+        final val ExitWithShrink // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.ExitWithShrink|{}ExitWithShrink[0]
+            final fun <get-ExitWithShrink>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.ExitWithShrink.<get-ExitWithShrink>|<get-ExitWithShrink>(){}[0]
+        final val NoMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.NoMotion|{}NoMotion[0]
+            final fun <get-NoMotion>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotion.Companion.NoMotion.<get-NoMotion>|<get-NoMotion>(){}[0]
+    }
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/PaneScaffoldParentData { // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData|null[0]
+    abstract val isAnimatedPane // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.isAnimatedPane|{}isAnimatedPane[0]
+        abstract fun <get-isAnimatedPane>(): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.isAnimatedPane.<get-isAnimatedPane>|<get-isAnimatedPane>(){}[0]
+    abstract val minTouchTargetSize // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.minTouchTargetSize|{}minTouchTargetSize[0]
+        abstract fun <get-minTouchTargetSize>(): androidx.compose.ui.unit/Dp // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.minTouchTargetSize.<get-minTouchTargetSize>|<get-minTouchTargetSize>(){}[0]
+    abstract val paneMargins // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.paneMargins|{}paneMargins[0]
+        abstract fun <get-paneMargins>(): androidx.compose.material3.adaptive.layout/PaneMargins // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.paneMargins.<get-paneMargins>|<get-paneMargins>(){}[0]
+    abstract val preferredHeight // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.preferredHeight|{}preferredHeight[0]
+        abstract fun <get-preferredHeight>(): androidx.compose.ui.unit/Dp // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.preferredHeight.<get-preferredHeight>|<get-preferredHeight>(){}[0]
+    abstract val preferredHeightInProportion // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.preferredHeightInProportion|{}preferredHeightInProportion[0]
+        abstract fun <get-preferredHeightInProportion>(): kotlin/Float // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.preferredHeightInProportion.<get-preferredHeightInProportion>|<get-preferredHeightInProportion>(){}[0]
+    abstract val preferredWidth // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.preferredWidth|{}preferredWidth[0]
+        abstract fun <get-preferredWidth>(): androidx.compose.ui.unit/Dp // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.preferredWidth.<get-preferredWidth>|<get-preferredWidth>(){}[0]
+    abstract val preferredWidthInProportion // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.preferredWidthInProportion|{}preferredWidthInProportion[0]
+        abstract fun <get-preferredWidthInProportion>(): kotlin/Float // androidx.compose.material3.adaptive.layout/PaneScaffoldParentData.preferredWidthInProportion.<get-preferredWidthInProportion>|<get-preferredWidthInProportion>(){}[0]
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/PaneScaffoldScope { // androidx.compose.material3.adaptive.layout/PaneScaffoldScope|null[0]
+    abstract val saveableStateHolder // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.saveableStateHolder|{}saveableStateHolder[0]
+        abstract fun <get-saveableStateHolder>(): androidx.compose.runtime.saveable/SaveableStateHolder // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.saveableStateHolder.<get-saveableStateHolder>|<get-saveableStateHolder>(){}[0]
+
+    abstract fun (androidx.compose.ui/Modifier).paneExpansionDraggable(androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.ui.unit/Dp, androidx.compose.foundation.interaction/MutableInteractionSource, kotlin/Function1<androidx.compose.ui.semantics/SemanticsPropertyReceiver, kotlin/Unit>? = ...): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.paneExpansionDraggable|paneExpansionDraggable@androidx.compose.ui.Modifier(androidx.compose.material3.adaptive.layout.PaneExpansionState;androidx.compose.ui.unit.Dp;androidx.compose.foundation.interaction.MutableInteractionSource;kotlin.Function1<androidx.compose.ui.semantics.SemanticsPropertyReceiver,kotlin.Unit>?){}[0]
+    abstract fun (androidx.compose.ui/Modifier).paneMargins(androidx.compose.foundation.layout/PaddingValues, kotlin/Array<out androidx.compose.ui.layout/RectRulers>..., androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.paneMargins|paneMargins@androidx.compose.ui.Modifier(androidx.compose.foundation.layout.PaddingValues;kotlin.Array<out|androidx.compose.ui.layout.RectRulers>...;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+    abstract fun (androidx.compose.ui/Modifier).paneMargins(kotlin/Array<out androidx.compose.ui.layout/RectRulers>..., androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.paneMargins|paneMargins@androidx.compose.ui.Modifier(kotlin.Array<out|androidx.compose.ui.layout.RectRulers>...;androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+    abstract fun (androidx.compose.ui/Modifier).preferredHeight(androidx.compose.ui.unit/Dp): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.preferredHeight|preferredHeight@androidx.compose.ui.Modifier(androidx.compose.ui.unit.Dp){}[0]
+    abstract fun (androidx.compose.ui/Modifier).preferredHeight(kotlin/Float): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.preferredHeight|preferredHeight@androidx.compose.ui.Modifier(kotlin.Float){}[0]
+    abstract fun (androidx.compose.ui/Modifier).preferredWidth(androidx.compose.ui.unit/Dp): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.preferredWidth|preferredWidth@androidx.compose.ui.Modifier(androidx.compose.ui.unit.Dp){}[0]
+    abstract fun (androidx.compose.ui/Modifier).preferredWidth(kotlin/Float): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/PaneScaffoldScope.preferredWidth|preferredWidth@androidx.compose.ui.Modifier(kotlin.Float){}[0]
+}
+
+sealed interface androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope : androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldPaneScope<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue>, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope|null[0]
+
+sealed interface androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope : androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldScope<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue> // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope|null[0]
+
+abstract class androidx.compose.material3.adaptive.layout/DragToResizeState : androidx.compose.foundation.gestures/DraggableState { // androidx.compose.material3.adaptive.layout/DragToResizeState|null[0]
+    open fun dispatchRawDelta(kotlin/Float) // androidx.compose.material3.adaptive.layout/DragToResizeState.dispatchRawDelta|dispatchRawDelta(kotlin.Float){}[0]
+    open suspend fun drag(androidx.compose.foundation/MutatePriority, kotlin.coroutines/SuspendFunction1<androidx.compose.foundation.gestures/DragScope, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/DragToResizeState.drag|drag(androidx.compose.foundation.MutatePriority;kotlin.coroutines.SuspendFunction1<androidx.compose.foundation.gestures.DragScope,kotlin.Unit>){}[0]
+
+    final object Companion // androidx.compose.material3.adaptive.layout/DragToResizeState.Companion|null[0]
+}
+
+final class <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole, #B: androidx.compose.material3.adaptive.layout/PaneScaffoldValue<#A>> androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope { // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope|null[0]
+    final val boundsAnimationSpec // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.boundsAnimationSpec|{}boundsAnimationSpec[0]
+        final fun <get-boundsAnimationSpec>(): androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntRect> // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.boundsAnimationSpec.<get-boundsAnimationSpec>|<get-boundsAnimationSpec>(){}[0]
+    final val content // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.content|{}content[0]
+        final fun <get-content>(): kotlin/Function3<androidx.compose.material3.adaptive.layout/AnimatedPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit> // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.content.<get-content>|<get-content>(){}[0]
+    final val dragToResizeHandle // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.dragToResizeHandle|{}dragToResizeHandle[0]
+        final fun <get-dragToResizeHandle>(): kotlin/Function3<androidx.compose.material3.adaptive.layout/DragToResizeState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.dragToResizeHandle.<get-dragToResizeHandle>|<get-dragToResizeHandle>(){}[0]
+    final val enterTransition // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.enterTransition|{}enterTransition[0]
+        final fun <get-enterTransition>(): androidx.compose.animation/EnterTransition // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.enterTransition.<get-enterTransition>|<get-enterTransition>(){}[0]
+    final val exitTransition // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.exitTransition|{}exitTransition[0]
+        final fun <get-exitTransition>(): androidx.compose.animation/ExitTransition // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.exitTransition.<get-exitTransition>|<get-exitTransition>(){}[0]
+    final val modifier // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.modifier|{}modifier[0]
+        final fun <get-modifier>(): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.modifier.<get-modifier>|<get-modifier>(){}[0]
+    final val scope // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.scope|{}scope[0]
+        final fun <get-scope>(): androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldPaneScope<#A, #B> // androidx.compose.material3.adaptive.layout/AnimatedPaneOverrideScope.scope.<get-scope>|<get-scope>(){}[0]
+}
+
+final class <#A: out kotlin/Any?> androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem { // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem|null[0]
+    constructor <init>(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, #A? = ...) // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem.<init>|<init>(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole;1:0?){}[0]
+
+    final val contentKey // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem.contentKey|{}contentKey[0]
+        final fun <get-contentKey>(): #A? // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem.contentKey.<get-contentKey>|<get-contentKey>(){}[0]
+    final val pane // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem.pane|{}pane[0]
+        final fun <get-pane>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem.pane.<get-pane>|<get-pane>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem.toString|toString(){}[0]
+}
+
+final class androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState : androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState { // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState|null[0]
+    constructor <init>(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue) // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.<init>|<init>(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldValue){}[0]
+
+    final val currentState // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.currentState|{}currentState[0]
+        final fun <get-currentState>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.currentState.<get-currentState>|<get-currentState>(){}[0]
+    final val progressFraction // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.progressFraction|{}progressFraction[0]
+        final fun <get-progressFraction>(): kotlin/Float // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.progressFraction.<get-progressFraction>|<get-progressFraction>(){}[0]
+    final val targetState // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.targetState|{}targetState[0]
+        final fun <get-targetState>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.targetState.<get-targetState>|<get-targetState>(){}[0]
+
+    final var isPredictiveBackInProgress // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.isPredictiveBackInProgress|{}isPredictiveBackInProgress[0]
+        final fun <get-isPredictiveBackInProgress>(): kotlin/Boolean // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.isPredictiveBackInProgress.<get-isPredictiveBackInProgress>|<get-isPredictiveBackInProgress>(){}[0]
+
+    final suspend fun animateTo(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue = ..., androidx.compose.animation.core/FiniteAnimationSpec<kotlin/Float>? = ..., kotlin/Boolean = ...) // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.animateTo|animateTo(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldValue;androidx.compose.animation.core.FiniteAnimationSpec<kotlin.Float>?;kotlin.Boolean){}[0]
+    final suspend fun seekTo(kotlin/Float, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue = ..., kotlin/Boolean = ...) // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.seekTo|seekTo(kotlin.Float;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldValue;kotlin.Boolean){}[0]
+    final suspend fun snapTo(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue) // androidx.compose.material3.adaptive.layout/MutableThreePaneScaffoldState.snapTo|snapTo(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldValue){}[0]
+}
+
+final class androidx.compose.material3.adaptive.layout/PaneExpansionState { // androidx.compose.material3.adaptive.layout/PaneExpansionState|null[0]
+    final var currentAnchor // androidx.compose.material3.adaptive.layout/PaneExpansionState.currentAnchor|{}currentAnchor[0]
+        final fun <get-currentAnchor>(): androidx.compose.material3.adaptive.layout/PaneExpansionAnchor? // androidx.compose.material3.adaptive.layout/PaneExpansionState.currentAnchor.<get-currentAnchor>|<get-currentAnchor>(){}[0]
+
+    final fun clear() // androidx.compose.material3.adaptive.layout/PaneExpansionState.clear|clear(){}[0]
+    final fun isUnspecified(): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneExpansionState.isUnspecified|isUnspecified(){}[0]
+    final fun setFirstPaneProportion(kotlin/Float) // androidx.compose.material3.adaptive.layout/PaneExpansionState.setFirstPaneProportion|setFirstPaneProportion(kotlin.Float){}[0]
+    final fun setFirstPaneWidth(kotlin/Int) // androidx.compose.material3.adaptive.layout/PaneExpansionState.setFirstPaneWidth|setFirstPaneWidth(kotlin.Int){}[0]
+    final suspend fun animateTo(androidx.compose.material3.adaptive.layout/PaneExpansionAnchor, kotlin/Float = ...) // androidx.compose.material3.adaptive.layout/PaneExpansionState.animateTo|animateTo(androidx.compose.material3.adaptive.layout.PaneExpansionAnchor;kotlin.Float){}[0]
+
+    final object Companion { // androidx.compose.material3.adaptive.layout/PaneExpansionState.Companion|null[0]
+        final const val Unspecified // androidx.compose.material3.adaptive.layout/PaneExpansionState.Companion.Unspecified|{}Unspecified[0]
+            final fun <get-Unspecified>(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneExpansionState.Companion.Unspecified.<get-Unspecified>|<get-Unspecified>(){}[0]
+    }
+}
+
+final class androidx.compose.material3.adaptive.layout/PaneMotionData { // androidx.compose.material3.adaptive.layout/PaneMotionData|null[0]
+    final var motion // androidx.compose.material3.adaptive.layout/PaneMotionData.motion|{}motion[0]
+        final fun <get-motion>(): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/PaneMotionData.motion.<get-motion>|<get-motion>(){}[0]
+    final var originPosition // androidx.compose.material3.adaptive.layout/PaneMotionData.originPosition|{}originPosition[0]
+        final fun <get-originPosition>(): androidx.compose.ui.unit/IntOffset // androidx.compose.material3.adaptive.layout/PaneMotionData.originPosition.<get-originPosition>|<get-originPosition>(){}[0]
+    final var originSize // androidx.compose.material3.adaptive.layout/PaneMotionData.originSize|{}originSize[0]
+        final fun <get-originSize>(): androidx.compose.ui.unit/IntSize // androidx.compose.material3.adaptive.layout/PaneMotionData.originSize.<get-originSize>|<get-originSize>(){}[0]
+    final var targetPosition // androidx.compose.material3.adaptive.layout/PaneMotionData.targetPosition|{}targetPosition[0]
+        final fun <get-targetPosition>(): androidx.compose.ui.unit/IntOffset // androidx.compose.material3.adaptive.layout/PaneMotionData.targetPosition.<get-targetPosition>|<get-targetPosition>(){}[0]
+    final var targetSize // androidx.compose.material3.adaptive.layout/PaneMotionData.targetSize|{}targetSize[0]
+        final fun <get-targetSize>(): androidx.compose.ui.unit/IntSize // androidx.compose.material3.adaptive.layout/PaneMotionData.targetSize.<get-targetSize>|<get-targetSize>(){}[0]
+}
+
+final class androidx.compose.material3.adaptive.layout/PaneScaffoldDirective { // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective|null[0]
+    constructor <init>(kotlin/Int, androidx.compose.ui.unit/Dp, kotlin/Int, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, kotlin.collections/List<androidx.compose.ui.geometry/Rect>) // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.<init>|<init>(kotlin.Int;androidx.compose.ui.unit.Dp;kotlin.Int;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;kotlin.collections.List<androidx.compose.ui.geometry.Rect>){}[0]
+    constructor <init>(kotlin/Int, androidx.compose.ui.unit/Dp, kotlin/Int, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, kotlin.collections/List<androidx.compose.ui.geometry/Rect>, kotlin/Boolean) // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.<init>|<init>(kotlin.Int;androidx.compose.ui.unit.Dp;kotlin.Int;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;kotlin.collections.List<androidx.compose.ui.geometry.Rect>;kotlin.Boolean){}[0]
+    constructor <init>(kotlin/Int, androidx.compose.ui.unit/Dp, kotlin/Int, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, kotlin.collections/List<androidx.compose.ui.geometry/Rect>) // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.<init>|<init>(kotlin.Int;androidx.compose.ui.unit.Dp;kotlin.Int;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;kotlin.collections.List<androidx.compose.ui.geometry.Rect>){}[0]
+
+    final val defaultPanePreferredHeight // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.defaultPanePreferredHeight|{}defaultPanePreferredHeight[0]
+        final fun <get-defaultPanePreferredHeight>(): androidx.compose.ui.unit/Dp // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.defaultPanePreferredHeight.<get-defaultPanePreferredHeight>|<get-defaultPanePreferredHeight>(){}[0]
+    final val defaultPanePreferredWidth // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.defaultPanePreferredWidth|{}defaultPanePreferredWidth[0]
+        final fun <get-defaultPanePreferredWidth>(): androidx.compose.ui.unit/Dp // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.defaultPanePreferredWidth.<get-defaultPanePreferredWidth>|<get-defaultPanePreferredWidth>(){}[0]
+    final val excludedBounds // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.excludedBounds|{}excludedBounds[0]
+        final fun <get-excludedBounds>(): kotlin.collections/List<androidx.compose.ui.geometry/Rect> // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.excludedBounds.<get-excludedBounds>|<get-excludedBounds>(){}[0]
+    final val horizontalPartitionSpacerSize // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.horizontalPartitionSpacerSize|{}horizontalPartitionSpacerSize[0]
+        final fun <get-horizontalPartitionSpacerSize>(): androidx.compose.ui.unit/Dp // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.horizontalPartitionSpacerSize.<get-horizontalPartitionSpacerSize>|<get-horizontalPartitionSpacerSize>(){}[0]
+    final val maxHorizontalPartitions // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.maxHorizontalPartitions|{}maxHorizontalPartitions[0]
+        final fun <get-maxHorizontalPartitions>(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.maxHorizontalPartitions.<get-maxHorizontalPartitions>|<get-maxHorizontalPartitions>(){}[0]
+    final val maxVerticalPartitions // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.maxVerticalPartitions|{}maxVerticalPartitions[0]
+        final fun <get-maxVerticalPartitions>(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.maxVerticalPartitions.<get-maxVerticalPartitions>|<get-maxVerticalPartitions>(){}[0]
+    final val shouldAutoFocusCurrentDestination // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.shouldAutoFocusCurrentDestination|{}shouldAutoFocusCurrentDestination[0]
+        final fun <get-shouldAutoFocusCurrentDestination>(): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.shouldAutoFocusCurrentDestination.<get-shouldAutoFocusCurrentDestination>|<get-shouldAutoFocusCurrentDestination>(){}[0]
+    final val verticalPartitionSpacerSize // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.verticalPartitionSpacerSize|{}verticalPartitionSpacerSize[0]
+        final fun <get-verticalPartitionSpacerSize>(): androidx.compose.ui.unit/Dp // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.verticalPartitionSpacerSize.<get-verticalPartitionSpacerSize>|<get-verticalPartitionSpacerSize>(){}[0]
+
+    final fun copy(kotlin/Int = ..., androidx.compose.ui.unit/Dp = ..., kotlin/Int = ..., androidx.compose.ui.unit/Dp = ..., androidx.compose.ui.unit/Dp = ..., kotlin.collections/List<androidx.compose.ui.geometry/Rect> = ...): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.copy|copy(kotlin.Int;androidx.compose.ui.unit.Dp;kotlin.Int;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;kotlin.collections.List<androidx.compose.ui.geometry.Rect>){}[0]
+    final fun copy(kotlin/Int = ..., androidx.compose.ui.unit/Dp = ..., kotlin/Int = ..., androidx.compose.ui.unit/Dp = ..., androidx.compose.ui.unit/Dp = ..., kotlin.collections/List<androidx.compose.ui.geometry/Rect> = ..., androidx.compose.ui.unit/Dp = ...): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.copy|copy(kotlin.Int;androidx.compose.ui.unit.Dp;kotlin.Int;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;kotlin.collections.List<androidx.compose.ui.geometry.Rect>;androidx.compose.ui.unit.Dp){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.toString|toString(){}[0]
+
+    final object Companion { // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.Companion|null[0]
+        final val Default // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.Companion.Default|{}Default[0]
+            final fun <get-Default>(): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.layout/PaneScaffoldDirective.Companion.Default.<get-Default>|<get-Default>(){}[0]
+    }
+}
+
+final class androidx.compose.material3.adaptive.layout/ThreePaneMotion { // androidx.compose.material3.adaptive.layout/ThreePaneMotion|null[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/ThreePaneMotion.equals|equals(kotlin.Any?){}[0]
+    final fun get(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole): androidx.compose.material3.adaptive.layout/PaneMotion // androidx.compose.material3.adaptive.layout/ThreePaneMotion.get|get(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/ThreePaneMotion.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/ThreePaneMotion.toString|toString(){}[0]
+
+    final object Companion { // androidx.compose.material3.adaptive.layout/ThreePaneMotion.Companion|null[0]
+        final val NoMotion // androidx.compose.material3.adaptive.layout/ThreePaneMotion.Companion.NoMotion|{}NoMotion[0]
+            final fun <get-NoMotion>(): androidx.compose.material3.adaptive.layout/ThreePaneMotion // androidx.compose.material3.adaptive.layout/ThreePaneMotion.Companion.NoMotion.<get-NoMotion>|<get-NoMotion>(){}[0]
+    }
+}
+
+final class androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies { // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies|null[0]
+    constructor <init>(androidx.compose.material3.adaptive.layout/AdaptStrategy, androidx.compose.material3.adaptive.layout/AdaptStrategy, androidx.compose.material3.adaptive.layout/AdaptStrategy) // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies.<init>|<init>(androidx.compose.material3.adaptive.layout.AdaptStrategy;androidx.compose.material3.adaptive.layout.AdaptStrategy;androidx.compose.material3.adaptive.layout.AdaptStrategy){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies.equals|equals(kotlin.Any?){}[0]
+    final fun get(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole): androidx.compose.material3.adaptive.layout/AdaptStrategy // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies.get|get(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies.hashCode|hashCode(){}[0]
+}
+
+final class androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder : androidx.compose.material3.adaptive.layout/PaneScaffoldHorizontalOrder<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole> { // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder|null[0]
+    final val size // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.size|{}size[0]
+        final fun <get-size>(): kotlin/Int // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.size.<get-size>|<get-size>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.equals|equals(kotlin.Any?){}[0]
+    final fun forEach(kotlin/Function1<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.forEach|forEach(kotlin.Function1<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole,kotlin.Unit>){}[0]
+    final fun forEachIndexed(kotlin/Function2<kotlin/Int, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.forEachIndexed|forEachIndexed(kotlin.Function2<kotlin.Int,androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole,kotlin.Unit>){}[0]
+    final fun forEachIndexedReversed(kotlin/Function2<kotlin/Int, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.forEachIndexedReversed|forEachIndexedReversed(kotlin.Function2<kotlin.Int,androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole,kotlin.Unit>){}[0]
+    final fun get(kotlin/Int): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.get|get(kotlin.Int){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.hashCode|hashCode(){}[0]
+    final fun indexOf(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole): kotlin/Int // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder.indexOf|indexOf(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole){}[0]
+}
+
+final class androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope { // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope|null[0]
+    final val modifier // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.modifier|{}modifier[0]
+        final fun <get-modifier>(): androidx.compose.ui/Modifier // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.modifier.<get-modifier>|<get-modifier>(){}[0]
+    final val paneExpansionDragHandle // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.paneExpansionDragHandle|{}paneExpansionDragHandle[0]
+        final fun <get-paneExpansionDragHandle>(): kotlin/Function3<androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.paneExpansionDragHandle.<get-paneExpansionDragHandle>|<get-paneExpansionDragHandle>(){}[0]
+    final val paneExpansionState // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.paneExpansionState|{}paneExpansionState[0]
+        final fun <get-paneExpansionState>(): androidx.compose.material3.adaptive.layout/PaneExpansionState // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.paneExpansionState.<get-paneExpansionState>|<get-paneExpansionState>(){}[0]
+    final val paneOrder // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.paneOrder|{}paneOrder[0]
+        final fun <get-paneOrder>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldHorizontalOrder // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.paneOrder.<get-paneOrder>|<get-paneOrder>(){}[0]
+    final val primaryPane // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.primaryPane|{}primaryPane[0]
+        final fun <get-primaryPane>(): kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit> // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.primaryPane.<get-primaryPane>|<get-primaryPane>(){}[0]
+    final val scaffoldDirective // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.scaffoldDirective|{}scaffoldDirective[0]
+        final fun <get-scaffoldDirective>(): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.scaffoldDirective.<get-scaffoldDirective>|<get-scaffoldDirective>(){}[0]
+    final val scaffoldState // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.scaffoldState|{}scaffoldState[0]
+        final fun <get-scaffoldState>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.scaffoldState.<get-scaffoldState>|<get-scaffoldState>(){}[0]
+    final val secondaryPane // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.secondaryPane|{}secondaryPane[0]
+        final fun <get-secondaryPane>(): kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit> // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.secondaryPane.<get-secondaryPane>|<get-secondaryPane>(){}[0]
+    final val tertiaryPane // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.tertiaryPane|{}tertiaryPane[0]
+        final fun <get-tertiaryPane>(): kotlin/Function2<androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverrideScope.tertiaryPane.<get-tertiaryPane>|<get-tertiaryPane>(){}[0]
+}
+
+final class androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue : androidx.compose.material3.adaptive.layout/PaneExpansionStateKeyProvider, androidx.compose.material3.adaptive.layout/PaneScaffoldValue<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole> { // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue|null[0]
+    constructor <init>(androidx.compose.material3.adaptive.layout/PaneAdaptedValue, androidx.compose.material3.adaptive.layout/PaneAdaptedValue, androidx.compose.material3.adaptive.layout/PaneAdaptedValue) // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.<init>|<init>(androidx.compose.material3.adaptive.layout.PaneAdaptedValue;androidx.compose.material3.adaptive.layout.PaneAdaptedValue;androidx.compose.material3.adaptive.layout.PaneAdaptedValue){}[0]
+
+    final val paneExpansionStateKey // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.paneExpansionStateKey|{}paneExpansionStateKey[0]
+        final fun <get-paneExpansionStateKey>(): androidx.compose.material3.adaptive.layout/PaneExpansionStateKey // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.paneExpansionStateKey.<get-paneExpansionStateKey>|<get-paneExpansionStateKey>(){}[0]
+    final val primary // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.primary|{}primary[0]
+        final fun <get-primary>(): androidx.compose.material3.adaptive.layout/PaneAdaptedValue // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.primary.<get-primary>|<get-primary>(){}[0]
+    final val secondary // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.secondary|{}secondary[0]
+        final fun <get-secondary>(): androidx.compose.material3.adaptive.layout/PaneAdaptedValue // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.secondary.<get-secondary>|<get-secondary>(){}[0]
+    final val tertiary // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.tertiary|{}tertiary[0]
+        final fun <get-tertiary>(): androidx.compose.material3.adaptive.layout/PaneAdaptedValue // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.tertiary.<get-tertiary>|<get-tertiary>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.equals|equals(kotlin.Any?){}[0]
+    final fun get(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole): androidx.compose.material3.adaptive.layout/PaneAdaptedValue // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.get|get(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue.toString|toString(){}[0]
+}
+
+final value class androidx.compose.material3.adaptive.layout/HingePolicy { // androidx.compose.material3.adaptive.layout/HingePolicy|null[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/HingePolicy.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/HingePolicy.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/HingePolicy.toString|toString(){}[0]
+
+    final object Companion { // androidx.compose.material3.adaptive.layout/HingePolicy.Companion|null[0]
+        final val AlwaysAvoid // androidx.compose.material3.adaptive.layout/HingePolicy.Companion.AlwaysAvoid|{}AlwaysAvoid[0]
+            final fun <get-AlwaysAvoid>(): androidx.compose.material3.adaptive.layout/HingePolicy // androidx.compose.material3.adaptive.layout/HingePolicy.Companion.AlwaysAvoid.<get-AlwaysAvoid>|<get-AlwaysAvoid>(){}[0]
+        final val AvoidOccluding // androidx.compose.material3.adaptive.layout/HingePolicy.Companion.AvoidOccluding|{}AvoidOccluding[0]
+            final fun <get-AvoidOccluding>(): androidx.compose.material3.adaptive.layout/HingePolicy // androidx.compose.material3.adaptive.layout/HingePolicy.Companion.AvoidOccluding.<get-AvoidOccluding>|<get-AvoidOccluding>(){}[0]
+        final val AvoidSeparating // androidx.compose.material3.adaptive.layout/HingePolicy.Companion.AvoidSeparating|{}AvoidSeparating[0]
+            final fun <get-AvoidSeparating>(): androidx.compose.material3.adaptive.layout/HingePolicy // androidx.compose.material3.adaptive.layout/HingePolicy.Companion.AvoidSeparating.<get-AvoidSeparating>|<get-AvoidSeparating>(){}[0]
+        final val NeverAvoid // androidx.compose.material3.adaptive.layout/HingePolicy.Companion.NeverAvoid|{}NeverAvoid[0]
+            final fun <get-NeverAvoid>(): androidx.compose.material3.adaptive.layout/HingePolicy // androidx.compose.material3.adaptive.layout/HingePolicy.Companion.NeverAvoid.<get-NeverAvoid>|<get-NeverAvoid>(){}[0]
+    }
+}
+
+sealed class androidx.compose.material3.adaptive.layout/PaneExpansionAnchor { // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor|null[0]
+    abstract val description // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.description|{}description[0]
+        abstract fun <get-description>(androidx.compose.runtime/Composer?, kotlin/Int): kotlin/String // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.description.<get-description>|<get-description>(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+
+    abstract class Offset : androidx.compose.material3.adaptive.layout/PaneExpansionAnchor { // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset|null[0]
+        final val direction // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.direction|{}direction[0]
+            final fun <get-direction>(): androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.direction.<get-direction>|<get-direction>(){}[0]
+        final val offset // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.offset|{}offset[0]
+            final fun <get-offset>(): androidx.compose.ui.unit/Dp // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.offset.<get-offset>|<get-offset>(){}[0]
+
+        open fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.equals|equals(kotlin.Any?){}[0]
+        open fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.hashCode|hashCode(){}[0]
+        open fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.toString|toString(){}[0]
+
+        final value class Direction { // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction|null[0]
+            final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction.equals|equals(kotlin.Any?){}[0]
+            final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction.hashCode|hashCode(){}[0]
+            final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction.toString|toString(){}[0]
+
+            final object Companion { // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction.Companion|null[0]
+                final val FromEnd // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction.Companion.FromEnd|{}FromEnd[0]
+                    final fun <get-FromEnd>(): androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction.Companion.FromEnd.<get-FromEnd>|<get-FromEnd>(){}[0]
+                final val FromStart // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction.Companion.FromStart|{}FromStart[0]
+                    final fun <get-FromStart>(): androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Direction.Companion.FromStart.<get-FromStart>|<get-FromStart>(){}[0]
+            }
+        }
+
+        final object Companion { // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Companion|null[0]
+            final fun fromEnd(androidx.compose.ui.unit/Dp): androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Companion.fromEnd|fromEnd(androidx.compose.ui.unit.Dp){}[0]
+            final fun fromStart(androidx.compose.ui.unit/Dp): androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Offset.Companion.fromStart|fromStart(androidx.compose.ui.unit.Dp){}[0]
+        }
+    }
+
+    final class Proportion : androidx.compose.material3.adaptive.layout/PaneExpansionAnchor { // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion|null[0]
+        constructor <init>(kotlin/Float) // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion.<init>|<init>(kotlin.Float){}[0]
+
+        final val description // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion.description|{}description[0]
+            final fun <get-description>(androidx.compose.runtime/Composer?, kotlin/Int): kotlin/String // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion.description.<get-description>|<get-description>(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+        final val proportion // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion.proportion|{}proportion[0]
+            final fun <get-proportion>(): kotlin/Float // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion.proportion.<get-proportion>|<get-proportion>(){}[0]
+
+        final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion.equals|equals(kotlin.Any?){}[0]
+        final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion.hashCode|hashCode(){}[0]
+        final fun toString(): kotlin/String // androidx.compose.material3.adaptive.layout/PaneExpansionAnchor.Proportion.toString|toString(){}[0]
+    }
+}
+
+sealed class androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState { // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState|null[0]
+    abstract val currentState // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState.currentState|{}currentState[0]
+        abstract fun <get-currentState>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState.currentState.<get-currentState>|<get-currentState>(){}[0]
+    abstract val isPredictiveBackInProgress // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState.isPredictiveBackInProgress|{}isPredictiveBackInProgress[0]
+        abstract fun <get-isPredictiveBackInProgress>(): kotlin/Boolean // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState.isPredictiveBackInProgress.<get-isPredictiveBackInProgress>|<get-isPredictiveBackInProgress>(){}[0]
+    abstract val progressFraction // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState.progressFraction|{}progressFraction[0]
+        abstract fun <get-progressFraction>(): kotlin/Float // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState.progressFraction.<get-progressFraction>|<get-progressFraction>(){}[0]
+    abstract val targetState // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState.targetState|{}targetState[0]
+        abstract fun <get-targetState>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue // androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState.targetState.<get-targetState>|<get-targetState>(){}[0]
+}
+
+final object androidx.compose.material3.adaptive.layout/LevitatedPaneScrimDefaults { // androidx.compose.material3.adaptive.layout/LevitatedPaneScrimDefaults|null[0]
+    final val Color // androidx.compose.material3.adaptive.layout/LevitatedPaneScrimDefaults.Color|{}Color[0]
+        final fun <get-Color>(): androidx.compose.ui.graphics/Color // androidx.compose.material3.adaptive.layout/LevitatedPaneScrimDefaults.Color.<get-Color>|<get-Color>(){}[0]
+}
+
+final object androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldDefaults { // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldDefaults|null[0]
+    final fun adaptStrategies(androidx.compose.material3.adaptive.layout/AdaptStrategy = ..., androidx.compose.material3.adaptive.layout/AdaptStrategy = ..., androidx.compose.material3.adaptive.layout/AdaptStrategy = ...): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldDefaults.adaptStrategies|adaptStrategies(androidx.compose.material3.adaptive.layout.AdaptStrategy;androidx.compose.material3.adaptive.layout.AdaptStrategy;androidx.compose.material3.adaptive.layout.AdaptStrategy){}[0]
+}
+
+final object androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldRole { // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldRole|null[0]
+    final val Detail // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldRole.Detail|{}Detail[0]
+        final fun <get-Detail>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldRole.Detail.<get-Detail>|<get-Detail>(){}[0]
+    final val Extra // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldRole.Extra|{}Extra[0]
+        final fun <get-Extra>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldRole.Extra.<get-Extra>|<get-Extra>(){}[0]
+    final val List // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldRole.List|{}List[0]
+        final fun <get-List>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffoldRole.List.<get-List>|<get-List>(){}[0]
+}
+
+final object androidx.compose.material3.adaptive.layout/PaneMotionDefaults { // androidx.compose.material3.adaptive.layout/PaneMotionDefaults|null[0]
+    final val AnimationSpec // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.AnimationSpec|{}AnimationSpec[0]
+        final fun <get-AnimationSpec>(): androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntRect> // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.AnimationSpec.<get-AnimationSpec>|<get-AnimationSpec>(){}[0]
+    final val DelayedAnimationSpec // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.DelayedAnimationSpec|{}DelayedAnimationSpec[0]
+        final fun <get-DelayedAnimationSpec>(): androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntRect> // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.DelayedAnimationSpec.<get-DelayedAnimationSpec>|<get-DelayedAnimationSpec>(){}[0]
+    final val DelayedOffsetAnimationSpec // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.DelayedOffsetAnimationSpec|{}DelayedOffsetAnimationSpec[0]
+        final fun <get-DelayedOffsetAnimationSpec>(): androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntOffset> // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.DelayedOffsetAnimationSpec.<get-DelayedOffsetAnimationSpec>|<get-DelayedOffsetAnimationSpec>(){}[0]
+    final val DelayedSizeAnimationSpec // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.DelayedSizeAnimationSpec|{}DelayedSizeAnimationSpec[0]
+        final fun <get-DelayedSizeAnimationSpec>(): androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntSize> // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.DelayedSizeAnimationSpec.<get-DelayedSizeAnimationSpec>|<get-DelayedSizeAnimationSpec>(){}[0]
+    final val OffsetAnimationSpec // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.OffsetAnimationSpec|{}OffsetAnimationSpec[0]
+        final fun <get-OffsetAnimationSpec>(): androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntOffset> // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.OffsetAnimationSpec.<get-OffsetAnimationSpec>|<get-OffsetAnimationSpec>(){}[0]
+    final val SizeAnimationSpec // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.SizeAnimationSpec|{}SizeAnimationSpec[0]
+        final fun <get-SizeAnimationSpec>(): androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntSize> // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.SizeAnimationSpec.<get-SizeAnimationSpec>|<get-SizeAnimationSpec>(){}[0]
+    final val VisibilityAnimationSpec // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.VisibilityAnimationSpec|{}VisibilityAnimationSpec[0]
+        final fun <get-VisibilityAnimationSpec>(): androidx.compose.animation.core/FiniteAnimationSpec<kotlin/Float> // androidx.compose.material3.adaptive.layout/PaneMotionDefaults.VisibilityAnimationSpec.<get-VisibilityAnimationSpec>|<get-VisibilityAnimationSpec>(){}[0]
+}
+
+final object androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldDefaults { // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldDefaults|null[0]
+    final fun adaptStrategies(androidx.compose.material3.adaptive.layout/AdaptStrategy = ..., androidx.compose.material3.adaptive.layout/AdaptStrategy = ..., androidx.compose.material3.adaptive.layout/AdaptStrategy = ...): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldDefaults.adaptStrategies|adaptStrategies(androidx.compose.material3.adaptive.layout.AdaptStrategy;androidx.compose.material3.adaptive.layout.AdaptStrategy;androidx.compose.material3.adaptive.layout.AdaptStrategy){}[0]
+}
+
+final object androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldRole { // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldRole|null[0]
+    final val Extra // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldRole.Extra|{}Extra[0]
+        final fun <get-Extra>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldRole.Extra.<get-Extra>|<get-Extra>(){}[0]
+    final val Main // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldRole.Main|{}Main[0]
+        final fun <get-Main>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldRole.Main.<get-Main>|<get-Main>(){}[0]
+    final val Supporting // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldRole.Supporting|{}Supporting[0]
+        final fun <get-Supporting>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole // androidx.compose.material3.adaptive.layout/SupportingPaneScaffoldRole.Supporting.<get-Supporting>|<get-Supporting>(){}[0]
+}
+
+final val androidx.compose.material3.adaptive.layout/LocalAnimatedPaneOverride // androidx.compose.material3.adaptive.layout/LocalAnimatedPaneOverride|{}LocalAnimatedPaneOverride[0]
+    final fun <get-LocalAnimatedPaneOverride>(): androidx.compose.runtime/ProvidableCompositionLocal<androidx.compose.material3.adaptive.layout/AnimatedPaneOverride> // androidx.compose.material3.adaptive.layout/LocalAnimatedPaneOverride.<get-LocalAnimatedPaneOverride>|<get-LocalAnimatedPaneOverride>(){}[0]
+final val androidx.compose.material3.adaptive.layout/LocalThreePaneScaffoldOverride // androidx.compose.material3.adaptive.layout/LocalThreePaneScaffoldOverride|{}LocalThreePaneScaffoldOverride[0]
+    final fun <get-LocalThreePaneScaffoldOverride>(): androidx.compose.runtime/ProvidableCompositionLocal<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldOverride> // androidx.compose.material3.adaptive.layout/LocalThreePaneScaffoldOverride.<get-LocalThreePaneScaffoldOverride>|<get-LocalThreePaneScaffoldOverride>(){}[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AdaptStrategy_Levitate$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AdaptStrategy_Levitate$stableprop|#static{}androidx_compose_material3_adaptive_layout_AdaptStrategy_Levitate$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AdaptStrategy_Reflow$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AdaptStrategy_Reflow$stableprop|#static{}androidx_compose_material3_adaptive_layout_AdaptStrategy_Reflow$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AnimatedPaneOverrideScope$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AnimatedPaneOverrideScope$stableprop|#static{}androidx_compose_material3_adaptive_layout_AnimatedPaneOverrideScope$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_DragToResizeState$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_DragToResizeState$stableprop|#static{}androidx_compose_material3_adaptive_layout_DragToResizeState$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_LevitatedPaneScrimDefaults$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_LevitatedPaneScrimDefaults$stableprop|#static{}androidx_compose_material3_adaptive_layout_LevitatedPaneScrimDefaults$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldDefaults$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldDefaults$stableprop|#static{}androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldDefaults$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldRole$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldRole$stableprop|#static{}androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldRole$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_MutableThreePaneScaffoldState$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_MutableThreePaneScaffoldState$stableprop|#static{}androidx_compose_material3_adaptive_layout_MutableThreePaneScaffoldState$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Levitated$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Levitated$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Levitated$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Reflowed$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Reflowed$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Reflowed$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneExpansionAnchor$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Offset$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Offset$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Offset$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Proportion$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Proportion$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Proportion$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionState$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionState$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneExpansionState$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneMotionData$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneMotionData$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneMotionData$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneMotionDefaults$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneMotionDefaults$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneMotionDefaults$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneScaffoldDirective$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneScaffoldDirective$stableprop|#static{}androidx_compose_material3_adaptive_layout_PaneScaffoldDirective$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldDefaults$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldDefaults$stableprop|#static{}androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldDefaults$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldRole$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldRole$stableprop|#static{}androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldRole$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneMotion$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneMotion$stableprop|#static{}androidx_compose_material3_adaptive_layout_ThreePaneMotion$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldAdaptStrategies$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldAdaptStrategies$stableprop|#static{}androidx_compose_material3_adaptive_layout_ThreePaneScaffoldAdaptStrategies$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldDestinationItem$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldDestinationItem$stableprop|#static{}androidx_compose_material3_adaptive_layout_ThreePaneScaffoldDestinationItem$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldHorizontalOrder$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldHorizontalOrder$stableprop|#static{}androidx_compose_material3_adaptive_layout_ThreePaneScaffoldHorizontalOrder$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldOverrideScope$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldOverrideScope$stableprop|#static{}androidx_compose_material3_adaptive_layout_ThreePaneScaffoldOverrideScope$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldState$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldState$stableprop|#static{}androidx_compose_material3_adaptive_layout_ThreePaneScaffoldState$stableprop[0]
+final val androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldValue$stableprop // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldValue$stableprop|#static{}androidx_compose_material3_adaptive_layout_ThreePaneScaffoldValue$stableprop[0]
+
+final fun (androidx.compose.material3.adaptive.layout/PaneExpansionState).androidx.compose.material3.adaptive.layout/defaultDragHandleSemantics(androidx.compose.runtime/Composer?, kotlin/Int): kotlin/Function1<androidx.compose.ui.semantics/SemanticsPropertyReceiver, kotlin/Unit> // androidx.compose.material3.adaptive.layout/defaultDragHandleSemantics|defaultDragHandleSemantics@androidx.compose.material3.adaptive.layout.PaneExpansionState(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole, #B: androidx.compose.material3.adaptive.layout/PaneScaffoldValue<#A>> (androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldPaneScope<#A, #B>).androidx.compose.material3.adaptive.layout/AnimatedPane(androidx.compose.ui/Modifier?, androidx.compose.animation/EnterTransition?, androidx.compose.animation/ExitTransition?, androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntRect>?, kotlin/Function3<androidx.compose.material3.adaptive.layout/AnimatedPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.material3.adaptive.layout/AnimatedPane|AnimatedPane@androidx.compose.material3.adaptive.layout.ExtendedPaneScaffoldPaneScope<0:0,0:1>(androidx.compose.ui.Modifier?;androidx.compose.animation.EnterTransition?;androidx.compose.animation.ExitTransition?;androidx.compose.animation.core.FiniteAnimationSpec<androidx.compose.ui.unit.IntRect>?;kotlin.Function3<androidx.compose.material3.adaptive.layout.AnimatedPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){0§<androidx.compose.material3.adaptive.layout.PaneScaffoldRole>;1§<androidx.compose.material3.adaptive.layout.PaneScaffoldValue<0:0>>}[0]
+final fun <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole, #B: androidx.compose.material3.adaptive.layout/PaneScaffoldValue<#A>> (androidx.compose.material3.adaptive.layout/ExtendedPaneScaffoldPaneScope<#A, #B>).androidx.compose.material3.adaptive.layout/AnimatedPane(androidx.compose.ui/Modifier?, androidx.compose.animation/EnterTransition?, androidx.compose.animation/ExitTransition?, androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntRect>?, kotlin/Function3<androidx.compose.material3.adaptive.layout/DragToResizeState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function3<androidx.compose.material3.adaptive.layout/AnimatedPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.material3.adaptive.layout/AnimatedPane|AnimatedPane@androidx.compose.material3.adaptive.layout.ExtendedPaneScaffoldPaneScope<0:0,0:1>(androidx.compose.ui.Modifier?;androidx.compose.animation.EnterTransition?;androidx.compose.animation.ExitTransition?;androidx.compose.animation.core.FiniteAnimationSpec<androidx.compose.ui.unit.IntRect>?;kotlin.Function3<androidx.compose.material3.adaptive.layout.DragToResizeState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function3<androidx.compose.material3.adaptive.layout.AnimatedPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){0§<androidx.compose.material3.adaptive.layout.PaneScaffoldRole>;1§<androidx.compose.material3.adaptive.layout.PaneScaffoldValue<0:0>>}[0]
+final fun <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole> (androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider<#A>).androidx.compose.material3.adaptive.layout/calculateDefaultEnterTransition(#A): androidx.compose.animation/EnterTransition // androidx.compose.material3.adaptive.layout/calculateDefaultEnterTransition|calculateDefaultEnterTransition@androidx.compose.material3.adaptive.layout.PaneScaffoldMotionDataProvider<0:0>(0:0){0§<androidx.compose.material3.adaptive.layout.PaneScaffoldRole>}[0]
+final fun <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole> (androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider<#A>).androidx.compose.material3.adaptive.layout/calculateDefaultExitTransition(#A): androidx.compose.animation/ExitTransition // androidx.compose.material3.adaptive.layout/calculateDefaultExitTransition|calculateDefaultExitTransition@androidx.compose.material3.adaptive.layout.PaneScaffoldMotionDataProvider<0:0>(0:0){0§<androidx.compose.material3.adaptive.layout.PaneScaffoldRole>}[0]
+final fun androidx.compose.material3.adaptive.layout/LevitatedPaneScrim(androidx.compose.ui/Modifier?, kotlin/Function0<kotlin/Unit>?, androidx.compose.ui.graphics/Color, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.material3.adaptive.layout/LevitatedPaneScrim|LevitatedPaneScrim(androidx.compose.ui.Modifier?;kotlin.Function0<kotlin.Unit>?;androidx.compose.ui.graphics.Color;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/ListDetailPaneScaffold(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.ui/Modifier?, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffold|ListDetailPaneScaffold(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldState;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.ui.Modifier?;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/ListDetailPaneScaffold(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.ui/Modifier?, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.material3.adaptive.layout/ListDetailPaneScaffold|ListDetailPaneScaffold(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldValue;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.ui.Modifier?;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/SupportingPaneScaffold(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.ui/Modifier?, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.material3.adaptive.layout/SupportingPaneScaffold|SupportingPaneScaffold(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldState;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.ui.Modifier?;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/SupportingPaneScaffold(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>, androidx.compose.ui/Modifier?, kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldPaneScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int) // androidx.compose.material3.adaptive.layout/SupportingPaneScaffold|SupportingPaneScaffold(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldValue;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>;androidx.compose.ui.Modifier?;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldPaneScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AdaptStrategy_Levitate$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AdaptStrategy_Levitate$stableprop_getter|androidx_compose_material3_adaptive_layout_AdaptStrategy_Levitate$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AdaptStrategy_Reflow$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AdaptStrategy_Reflow$stableprop_getter|androidx_compose_material3_adaptive_layout_AdaptStrategy_Reflow$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AnimatedPaneOverrideScope$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_AnimatedPaneOverrideScope$stableprop_getter|androidx_compose_material3_adaptive_layout_AnimatedPaneOverrideScope$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_DragToResizeState$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_DragToResizeState$stableprop_getter|androidx_compose_material3_adaptive_layout_DragToResizeState$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_LevitatedPaneScrimDefaults$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_LevitatedPaneScrimDefaults$stableprop_getter|androidx_compose_material3_adaptive_layout_LevitatedPaneScrimDefaults$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldDefaults$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldDefaults$stableprop_getter|androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldDefaults$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldRole$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldRole$stableprop_getter|androidx_compose_material3_adaptive_layout_ListDetailPaneScaffoldRole$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_MutableThreePaneScaffoldState$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_MutableThreePaneScaffoldState$stableprop_getter|androidx_compose_material3_adaptive_layout_MutableThreePaneScaffoldState$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Levitated$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Levitated$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Levitated$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Reflowed$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Reflowed$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneAdaptedValue_Reflowed$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneExpansionAnchor$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Offset$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Offset$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Offset$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Proportion$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Proportion$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneExpansionAnchor_Proportion$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionState$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneExpansionState$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneExpansionState$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneMotionData$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneMotionData$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneMotionData$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneMotionDefaults$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneMotionDefaults$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneMotionDefaults$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneScaffoldDirective$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_PaneScaffoldDirective$stableprop_getter|androidx_compose_material3_adaptive_layout_PaneScaffoldDirective$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldDefaults$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldDefaults$stableprop_getter|androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldDefaults$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldRole$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldRole$stableprop_getter|androidx_compose_material3_adaptive_layout_SupportingPaneScaffoldRole$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneMotion$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneMotion$stableprop_getter|androidx_compose_material3_adaptive_layout_ThreePaneMotion$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldAdaptStrategies$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldAdaptStrategies$stableprop_getter|androidx_compose_material3_adaptive_layout_ThreePaneScaffoldAdaptStrategies$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldDestinationItem$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldDestinationItem$stableprop_getter|androidx_compose_material3_adaptive_layout_ThreePaneScaffoldDestinationItem$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldHorizontalOrder$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldHorizontalOrder$stableprop_getter|androidx_compose_material3_adaptive_layout_ThreePaneScaffoldHorizontalOrder$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldOverrideScope$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldOverrideScope$stableprop_getter|androidx_compose_material3_adaptive_layout_ThreePaneScaffoldOverrideScope$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldState$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldState$stableprop_getter|androidx_compose_material3_adaptive_layout_ThreePaneScaffoldState$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldValue$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.layout/androidx_compose_material3_adaptive_layout_ThreePaneScaffoldValue$stableprop_getter|androidx_compose_material3_adaptive_layout_ThreePaneScaffoldValue$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.layout/calculatePaneScaffoldDirective(androidx.compose.material3.adaptive/WindowAdaptiveInfo, androidx.compose.material3.adaptive.layout/HingePolicy = ...): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.layout/calculatePaneScaffoldDirective|calculatePaneScaffoldDirective(androidx.compose.material3.adaptive.WindowAdaptiveInfo;androidx.compose.material3.adaptive.layout.HingePolicy){}[0]
+final fun androidx.compose.material3.adaptive.layout/calculatePaneScaffoldDirectiveWithTwoPanesOnMediumWidth(androidx.compose.material3.adaptive/WindowAdaptiveInfo, androidx.compose.material3.adaptive.layout/HingePolicy = ...): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.layout/calculatePaneScaffoldDirectiveWithTwoPanesOnMediumWidth|calculatePaneScaffoldDirectiveWithTwoPanesOnMediumWidth(androidx.compose.material3.adaptive.WindowAdaptiveInfo;androidx.compose.material3.adaptive.layout.HingePolicy){}[0]
+final fun androidx.compose.material3.adaptive.layout/calculateThreePaneScaffoldValue(kotlin/Int, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem<*>?, kotlin/Int = ...): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue // androidx.compose.material3.adaptive.layout/calculateThreePaneScaffoldValue|calculateThreePaneScaffoldValue(kotlin.Int;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldDestinationItem<*>?;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/calculateThreePaneScaffoldValue(kotlin/Int, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies, kotlin.collections/List<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem<*>>, kotlin/Int = ...): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue // androidx.compose.material3.adaptive.layout/calculateThreePaneScaffoldValue|calculateThreePaneScaffoldValue(kotlin.Int;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies;kotlin.collections.List<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldDestinationItem<*>>;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/rememberDragToResizeState(androidx.compose.material3.adaptive.layout/DockedEdge, androidx.compose.ui.unit/Dp, androidx.compose.ui.unit/Dp, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.layout/DragToResizeState // androidx.compose.material3.adaptive.layout/rememberDragToResizeState|rememberDragToResizeState(androidx.compose.material3.adaptive.layout.DockedEdge;androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/rememberPaneExpansionState(androidx.compose.material3.adaptive.layout/PaneExpansionStateKey?, kotlin.collections/List<androidx.compose.material3.adaptive.layout/PaneExpansionAnchor>?, kotlin/Int, androidx.compose.animation.core/FiniteAnimationSpec<kotlin/Float>?, androidx.compose.foundation.gestures/FlingBehavior?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.layout/PaneExpansionState // androidx.compose.material3.adaptive.layout/rememberPaneExpansionState|rememberPaneExpansionState(androidx.compose.material3.adaptive.layout.PaneExpansionStateKey?;kotlin.collections.List<androidx.compose.material3.adaptive.layout.PaneExpansionAnchor>?;kotlin.Int;androidx.compose.animation.core.FiniteAnimationSpec<kotlin.Float>?;androidx.compose.foundation.gestures.FlingBehavior?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/rememberPaneExpansionState(androidx.compose.material3.adaptive.layout/PaneExpansionStateKey?, kotlin.collections/List<androidx.compose.material3.adaptive.layout/PaneExpansionAnchor>?, kotlin/Int, androidx.compose.animation.core/FiniteAnimationSpec<kotlin/Float>?, androidx.compose.foundation.gestures/FlingBehavior?, kotlin/Function1<kotlin/Float, kotlin/Float>?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.layout/PaneExpansionState // androidx.compose.material3.adaptive.layout/rememberPaneExpansionState|rememberPaneExpansionState(androidx.compose.material3.adaptive.layout.PaneExpansionStateKey?;kotlin.collections.List<androidx.compose.material3.adaptive.layout.PaneExpansionAnchor>?;kotlin.Int;androidx.compose.animation.core.FiniteAnimationSpec<kotlin.Float>?;androidx.compose.foundation.gestures.FlingBehavior?;kotlin.Function1<kotlin.Float,kotlin.Float>?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/rememberPaneExpansionState(androidx.compose.material3.adaptive.layout/PaneExpansionStateKeyProvider, kotlin.collections/List<androidx.compose.material3.adaptive.layout/PaneExpansionAnchor>?, kotlin/Int, androidx.compose.animation.core/FiniteAnimationSpec<kotlin/Float>?, androidx.compose.foundation.gestures/FlingBehavior?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.layout/PaneExpansionState // androidx.compose.material3.adaptive.layout/rememberPaneExpansionState|rememberPaneExpansionState(androidx.compose.material3.adaptive.layout.PaneExpansionStateKeyProvider;kotlin.collections.List<androidx.compose.material3.adaptive.layout.PaneExpansionAnchor>?;kotlin.Int;androidx.compose.animation.core.FiniteAnimationSpec<kotlin.Float>?;androidx.compose.foundation.gestures.FlingBehavior?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.layout/rememberPaneExpansionState(androidx.compose.material3.adaptive.layout/PaneExpansionStateKeyProvider, kotlin.collections/List<androidx.compose.material3.adaptive.layout/PaneExpansionAnchor>?, kotlin/Int, androidx.compose.animation.core/FiniteAnimationSpec<kotlin/Float>?, androidx.compose.foundation.gestures/FlingBehavior?, kotlin/Function1<kotlin/Float, kotlin/Float>?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.layout/PaneExpansionState // androidx.compose.material3.adaptive.layout/rememberPaneExpansionState|rememberPaneExpansionState(androidx.compose.material3.adaptive.layout.PaneExpansionStateKeyProvider;kotlin.collections.List<androidx.compose.material3.adaptive.layout.PaneExpansionAnchor>?;kotlin.Int;androidx.compose.animation.core.FiniteAnimationSpec<kotlin.Float>?;androidx.compose.foundation.gestures.FlingBehavior?;kotlin.Function1<kotlin.Float,kotlin.Float>?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final inline fun <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole> (androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider<#A>).androidx.compose.material3.adaptive.layout/forEach(kotlin/Function2<#A, androidx.compose.material3.adaptive.layout/PaneMotionData, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/forEach|forEach@androidx.compose.material3.adaptive.layout.PaneScaffoldMotionDataProvider<0:0>(kotlin.Function2<0:0,androidx.compose.material3.adaptive.layout.PaneMotionData,kotlin.Unit>){0§<androidx.compose.material3.adaptive.layout.PaneScaffoldRole>}[0]
+final inline fun <#A: androidx.compose.material3.adaptive.layout/PaneScaffoldRole> (androidx.compose.material3.adaptive.layout/PaneScaffoldMotionDataProvider<#A>).androidx.compose.material3.adaptive.layout/forEachReversed(kotlin/Function2<#A, androidx.compose.material3.adaptive.layout/PaneMotionData, kotlin/Unit>) // androidx.compose.material3.adaptive.layout/forEachReversed|forEachReversed@androidx.compose.material3.adaptive.layout.PaneScaffoldMotionDataProvider<0:0>(kotlin.Function2<0:0,androidx.compose.material3.adaptive.layout.PaneMotionData,kotlin.Unit>){0§<androidx.compose.material3.adaptive.layout.PaneScaffoldRole>}[0]
@@ -0,0 +1,52 @@
+// :adaptive-layout - androidx.compose.material3.adaptive.layout.* (ListDetailPaneScaffold,
+// SupportingPaneScaffold, ThreePaneScaffold + pane motion / expansion machinery), vendored
+// VERBATIM from JetBrains/compose-multiplatform-core into src/vendor/. See :adaptive for why
+// upstream ships no linux / mingw artifact.
+//
+// Upstream's `skikoMain` carries the l10n translation tables (~75 files) plus the Strings and
+// drag-handle actuals; for this port every native target is a skiko target, so it lands in
+// src/vendor/native/ alongside upstream's own nativeMain actuals. The two sets actualise
+// disjoint expects, so they coexist in one source set.
+//
+// Provenance = compose-fork.txt + scripts/compose-fork/compose.properties. Never hand-edit
+// src/vendor - change the manifest + `python scripts/compose-fork/sync.py compose/material3/adaptive/adaptive-layout`.
+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(":compose:material3:adaptive:adaptive"))
+				api(project(":compose:ui:ui"))
+				api(project(":compose:animation:animation-core"))
+				api(libs.androidx.collection)
+				implementation(project(":compose:animation:animation"))
+				implementation(project(":compose:foundation:foundation"))
+				implementation(project(":compose:foundation:foundation-layout"))
+				implementation(project(":compose:ui:ui-geometry"))
+				implementation(libs.androidx.window.core)
+			}
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+		nativeMain {
+			kotlin.srcDir("src/vendor/native/kotlin")
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=androidx.compose.ui.ExperimentalComposeUiApi",
+			"-opt-in=androidx.compose.ui.InternalComposeUiApi",
+			"-opt-in=androidx.compose.animation.ExperimentalAnimationApi",
+			"-opt-in=androidx.compose.animation.ExperimentalSharedTransitionApi",
+			"-opt-in=androidx.compose.material3.adaptive.ExperimentalMaterial3AdaptiveApi",
+		)
+	}
+}
@@ -0,0 +1,133 @@
+SET_REPO=https://github.com/JetBrains/compose-multiplatform-core@<COMPOSE_CORE_REF>
+SET_FOLDER=compose/material3/adaptive/adaptive-layout/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/AdaptStrategy.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/AdaptStrategy.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/AnimateBoundsModifier.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/AnimateBoundsModifier.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/AnimateModifierUtils.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/AnimateModifierUtils.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/AnimateWithFadingModifier.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/AnimateWithFadingModifier.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/DragToResizeState.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/DragToResizeState.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/LevitatedPaneScrim.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/LevitatedPaneScrim.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ListDetailPaneScaffold.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ListDetailPaneScaffold.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/Pane.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/Pane.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneAdaptedValue.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneAdaptedValue.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneExpansionDraggableModifier.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneExpansionDraggableModifier.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneExpansionState.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneExpansionState.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneMargins.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneMargins.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneMotion.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneMotion.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffoldDirective.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffoldDirective.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffoldHorizontalOrder.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffoldHorizontalOrder.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffoldRole.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffoldRole.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffoldValue.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffoldValue.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/PredictiveBackScaleState.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/PredictiveBackScaleState.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/SupportingPaneScaffold.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/SupportingPaneScaffold.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneMotion.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneMotion.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffold.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffold.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldAdaptStrategies.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldAdaptStrategies.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldDestinationItem.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldDestinationItem.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldHorizontalOrder.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldHorizontalOrder.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldScope.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldScope.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldState.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldState.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldValue.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/ThreePaneScaffoldValue.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/WindowSizeClassHelper.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/WindowSizeClassHelper.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/internal/DelegableModifier.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/internal/DelegableModifier.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/internal/RememberUtils.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/internal/RememberUtils.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/internal/Strings.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/internal/Strings.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/layout/internal/System.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/layout/internal/System.kt
+skikoMain/kotlin/ -> src/vendor/native/kotlin/
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Af.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Af.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Am.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Am.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ar.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ar.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/As.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/As.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Az.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Az.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Be.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Be.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Bg.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Bg.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Bn.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Bn.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Bs.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Bs.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ca.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ca.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Cs.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Cs.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Da.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Da.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/De.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/De.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/El.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/El.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/En.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/En.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Es.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Es.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Et.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Et.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Eu.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Eu.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Fa.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Fa.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Fi.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Fi.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Fr.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Fr.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Gl.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Gl.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Gu.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Gu.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Hi.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Hi.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Hr.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Hr.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Hu.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Hu.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Hy.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Hy.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/In.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/In.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Is.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Is.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/It.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/It.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Iw.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Iw.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ja.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ja.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ka.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ka.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Kk.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Kk.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Km.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Km.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Kn.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Kn.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ko.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ko.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ky.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ky.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Lo.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Lo.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Lt.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Lt.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Lv.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Lv.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Mk.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Mk.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ml.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ml.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Mn.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Mn.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Mr.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Mr.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ms.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ms.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/My.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/My.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Nb.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Nb.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ne.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ne.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Nl.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Nl.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Or.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Or.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Pa.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Pa.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Pl.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Pl.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Pt.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Pt.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ro.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ro.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ru.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ru.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Si.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Si.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Sk.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Sk.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Sl.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Sl.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Sq.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Sq.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Sr.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Sr.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Sv.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Sv.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Sw.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Sw.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ta.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ta.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Te.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Te.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Th.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Th.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Tl.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Tl.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Tr.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Tr.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Translations.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Translations.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Uk.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Uk.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Ur.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Ur.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Uz.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Uz.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Vi.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Vi.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Zh.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Zh.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/l10n/Zu.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/l10n/Zu.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/layout/PaneExpansionDragHandle.skiko.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/layout/PaneExpansionDragHandle.skiko.kt
+#     | skikoMain/kotlin/androidx/compose/material3/adaptive/layout/internal/Strings.skiko.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/layout/internal/Strings.skiko.kt
+nativeMain/kotlin/ -> src/vendor/native/kotlin/
+#     | nativeMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.native.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.native.kt
+#     | nativeMain/kotlin/androidx/compose/material3/adaptive/layout/internal/System.native.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/layout/internal/System.native.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   androidMain (2)
+#     | androidMain/kotlin/androidx/compose/material3/adaptive/layout/PaneExpansionDraggableModifier.android.kt -> src/vendor/android/kotlin/androidx/compose/material3/adaptive/layout/PaneExpansionDraggableModifier.android.kt
+#     | androidMain/kotlin/androidx/compose/material3/adaptive/layout/internal/Strings.android.kt -> src/vendor/android/kotlin/androidx/compose/material3/adaptive/layout/internal/Strings.android.kt
+#   jsMain (2)
+#     | jsMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.js.kt -> src/vendor/js/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.js.kt
+#     | jsMain/kotlin/androidx/compose/material3/adaptive/layout/internal/System.js.kt -> src/vendor/js/kotlin/androidx/compose/material3/adaptive/layout/internal/System.js.kt
+#   jvmAndAndroidMain (2)
+#     | jvmAndAndroidMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.jvmAndAndroid.kt -> src/vendor/jvmAndAndroid/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.jvmAndAndroid.kt
+#     | jvmAndAndroidMain/kotlin/androidx/compose/material3/adaptive/layout/internal/System.jvmAndAndroid.kt -> src/vendor/jvmAndAndroid/kotlin/androidx/compose/material3/adaptive/layout/internal/System.jvmAndAndroid.kt
+#   wasmJsMain (2)
+#     | wasmJsMain/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.wasm.kt -> src/vendor/wasmJs/kotlin/androidx/compose/material3/adaptive/layout/PaneScaffold.wasm.kt
+#     | wasmJsMain/kotlin/androidx/compose/material3/adaptive/layout/internal/System.wasm.kt -> src/vendor/wasmJs/kotlin/androidx/compose/material3/adaptive/layout/internal/System.wasm.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>
@@ -0,0 +1,50 @@
+// 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.material3.adaptive:adaptive-navigation>
+abstract interface <#A: kotlin/Any?> androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator { // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator|null[0]
+    abstract val currentDestination // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.currentDestination|{}currentDestination[0]
+        abstract fun <get-currentDestination>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem<#A>? // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.currentDestination.<get-currentDestination>|<get-currentDestination>(){}[0]
+    abstract val scaffoldDirective // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.scaffoldDirective|{}scaffoldDirective[0]
+        abstract fun <get-scaffoldDirective>(): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.scaffoldDirective.<get-scaffoldDirective>|<get-scaffoldDirective>(){}[0]
+    abstract val scaffoldState // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.scaffoldState|{}scaffoldState[0]
+        abstract fun <get-scaffoldState>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldState // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.scaffoldState.<get-scaffoldState>|<get-scaffoldState>(){}[0]
+    abstract val scaffoldValue // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.scaffoldValue|{}scaffoldValue[0]
+        abstract fun <get-scaffoldValue>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.scaffoldValue.<get-scaffoldValue>|<get-scaffoldValue>(){}[0]
+
+    abstract var isDestinationHistoryAware // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.isDestinationHistoryAware|{}isDestinationHistoryAware[0]
+        abstract fun <get-isDestinationHistoryAware>(): kotlin/Boolean // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.isDestinationHistoryAware.<get-isDestinationHistoryAware>|<get-isDestinationHistoryAware>(){}[0]
+        abstract fun <set-isDestinationHistoryAware>(kotlin/Boolean) // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.isDestinationHistoryAware.<set-isDestinationHistoryAware>|<set-isDestinationHistoryAware>(kotlin.Boolean){}[0]
+
+    abstract fun canNavigateBack(androidx.compose.material3.adaptive.navigation/BackNavigationBehavior = ...): kotlin/Boolean // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.canNavigateBack|canNavigateBack(androidx.compose.material3.adaptive.navigation.BackNavigationBehavior){}[0]
+    abstract fun peekPreviousScaffoldValue(androidx.compose.material3.adaptive.navigation/BackNavigationBehavior = ...): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.peekPreviousScaffoldValue|peekPreviousScaffoldValue(androidx.compose.material3.adaptive.navigation.BackNavigationBehavior){}[0]
+    abstract suspend fun navigateBack(androidx.compose.material3.adaptive.navigation/BackNavigationBehavior = ...): kotlin/Boolean // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.navigateBack|navigateBack(androidx.compose.material3.adaptive.navigation.BackNavigationBehavior){}[0]
+    abstract suspend fun navigateTo(androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, #A? = ...) // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.navigateTo|navigateTo(androidx.compose.material3.adaptive.layout.ThreePaneScaffoldRole;1:0?){}[0]
+    abstract suspend fun seekBack(androidx.compose.material3.adaptive.navigation/BackNavigationBehavior = ..., kotlin/Float = ...) // androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator.seekBack|seekBack(androidx.compose.material3.adaptive.navigation.BackNavigationBehavior;kotlin.Float){}[0]
+}
+
+final value class androidx.compose.material3.adaptive.navigation/BackNavigationBehavior { // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior|null[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.toString|toString(){}[0]
+
+    final object Companion { // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion|null[0]
+        final val PopLatest // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion.PopLatest|{}PopLatest[0]
+            final fun <get-PopLatest>(): androidx.compose.material3.adaptive.navigation/BackNavigationBehavior // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion.PopLatest.<get-PopLatest>|<get-PopLatest>(){}[0]
+        final val PopUntilContentChange // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion.PopUntilContentChange|{}PopUntilContentChange[0]
+            final fun <get-PopUntilContentChange>(): androidx.compose.material3.adaptive.navigation/BackNavigationBehavior // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion.PopUntilContentChange.<get-PopUntilContentChange>|<get-PopUntilContentChange>(){}[0]
+        final val PopUntilCurrentDestinationChange // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion.PopUntilCurrentDestinationChange|{}PopUntilCurrentDestinationChange[0]
+            final fun <get-PopUntilCurrentDestinationChange>(): androidx.compose.material3.adaptive.navigation/BackNavigationBehavior // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion.PopUntilCurrentDestinationChange.<get-PopUntilCurrentDestinationChange>|<get-PopUntilCurrentDestinationChange>(){}[0]
+        final val PopUntilScaffoldValueChange // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion.PopUntilScaffoldValueChange|{}PopUntilScaffoldValueChange[0]
+            final fun <get-PopUntilScaffoldValueChange>(): androidx.compose.material3.adaptive.navigation/BackNavigationBehavior // androidx.compose.material3.adaptive.navigation/BackNavigationBehavior.Companion.PopUntilScaffoldValueChange.<get-PopUntilScaffoldValueChange>|<get-PopUntilScaffoldValueChange>(){}[0]
+    }
+}
+
+final fun <#A: kotlin/Any?> androidx.compose.material3.adaptive.navigation/rememberListDetailPaneScaffoldNavigator(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective?, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies?, kotlin/Boolean, kotlin.collections/List<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem<#A>>?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator<#A> // androidx.compose.material3.adaptive.navigation/rememberListDetailPaneScaffoldNavigator|rememberListDetailPaneScaffoldNavigator(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective?;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies?;kotlin.Boolean;kotlin.collections.List<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldDestinationItem<0:0>>?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){0§<kotlin.Any?>}[0]
+final fun <#A: kotlin/Any?> androidx.compose.material3.adaptive.navigation/rememberSupportingPaneScaffoldNavigator(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective?, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies?, kotlin/Boolean, kotlin.collections/List<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldDestinationItem<#A>>?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator<#A> // androidx.compose.material3.adaptive.navigation/rememberSupportingPaneScaffoldNavigator|rememberSupportingPaneScaffoldNavigator(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective?;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies?;kotlin.Boolean;kotlin.collections.List<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldDestinationItem<0:0>>?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){0§<kotlin.Any?>}[0]
+final fun androidx.compose.material3.adaptive.navigation/rememberListDetailPaneScaffoldNavigator(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective?, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator<kotlin/Any> // androidx.compose.material3.adaptive.navigation/rememberListDetailPaneScaffoldNavigator|rememberListDetailPaneScaffoldNavigator(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective?;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive.navigation/rememberSupportingPaneScaffoldNavigator(androidx.compose.material3.adaptive.layout/PaneScaffoldDirective?, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies?, kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.navigation/ThreePaneScaffoldNavigator<kotlin/Any> // androidx.compose.material3.adaptive.navigation/rememberSupportingPaneScaffoldNavigator|rememberSupportingPaneScaffoldNavigator(androidx.compose.material3.adaptive.layout.PaneScaffoldDirective?;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies?;kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
@@ -0,0 +1,35 @@
+// :adaptive-navigation - androidx.compose.material3.adaptive.navigation.*
+// (ThreePaneScaffoldNavigator + back-navigation behaviour), vendored VERBATIM from
+// JetBrains/compose-multiplatform-core into src/vendor/. See :adaptive for why upstream
+// ships no linux / mingw artifact. commonMain only - upstream's platform legs are
+// android-specific.
+//
+// Provenance = compose-fork.txt + scripts/compose-fork/compose.properties. Never hand-edit
+// src/vendor - change the manifest + `python scripts/compose-fork/sync.py compose/material3/adaptive/adaptive-navigation`.
+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(":compose:material3:adaptive:adaptive-layout"))
+				implementation(project(":compose:foundation:foundation"))
+				implementation(project(":compose:ui:ui-util"))
+			}
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=androidx.compose.material3.adaptive.ExperimentalMaterial3AdaptiveApi",
+		)
+	}
+}
@@ -0,0 +1,12 @@
+SET_REPO=https://github.com/JetBrains/compose-multiplatform-core@<COMPOSE_CORE_REF>
+SET_FOLDER=compose/material3/adaptive/adaptive-navigation/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/navigation/BackNavigationBehavior.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/navigation/BackNavigationBehavior.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/navigation/ThreePaneScaffoldNavigator.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/navigation/ThreePaneScaffoldNavigator.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   androidMain (2)
+#     | androidMain/kotlin/androidx/compose/material3/adaptive/navigation/AndroidThreePaneScaffold.android.kt -> src/vendor/android/kotlin/androidx/compose/material3/adaptive/navigation/AndroidThreePaneScaffold.android.kt
+#     | androidMain/kotlin/androidx/compose/material3/adaptive/navigation/ThreePaneScaffoldPredictiveBackHandler.android.kt -> src/vendor/android/kotlin/androidx/compose/material3/adaptive/navigation/ThreePaneScaffoldPredictiveBackHandler.android.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>
@@ -0,0 +1,93 @@
+// 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.material3.adaptive:adaptive-navigation3>
+sealed interface androidx.compose.material3.adaptive.navigation3/ListDetailSceneScope { // androidx.compose.material3.adaptive.navigation3/ListDetailSceneScope|null[0]
+    abstract val scaffoldTransitionScope // androidx.compose.material3.adaptive.navigation3/ListDetailSceneScope.scaffoldTransitionScope|{}scaffoldTransitionScope[0]
+        abstract fun <get-scaffoldTransitionScope>(): androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue> // androidx.compose.material3.adaptive.navigation3/ListDetailSceneScope.scaffoldTransitionScope.<get-scaffoldTransitionScope>|<get-scaffoldTransitionScope>(){}[0]
+}
+
+sealed interface androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneScope { // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneScope|null[0]
+    abstract val scaffoldTransitionScope // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneScope.scaffoldTransitionScope|{}scaffoldTransitionScope[0]
+        abstract fun <get-scaffoldTransitionScope>(): androidx.compose.material3.adaptive.layout/PaneScaffoldTransitionScope<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldRole, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldValue> // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneScope.scaffoldTransitionScope.<get-scaffoldTransitionScope>|<get-scaffoldTransitionScope>(){}[0]
+}
+
+final class <#A: kotlin/Any> androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy : androidx.navigation3.scene/SceneStrategy<#A> { // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy|null[0]
+    constructor <init>(kotlin/Boolean, androidx.compose.material3.adaptive.navigation/BackNavigationBehavior, androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?) // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.<init>|<init>(kotlin.Boolean;androidx.compose.material3.adaptive.navigation.BackNavigationBehavior;androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?){}[0]
+
+    final val adaptStrategies // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.adaptStrategies|{}adaptStrategies[0]
+        final fun <get-adaptStrategies>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.adaptStrategies.<get-adaptStrategies>|<get-adaptStrategies>(){}[0]
+    final val backNavigationBehavior // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.backNavigationBehavior|{}backNavigationBehavior[0]
+        final fun <get-backNavigationBehavior>(): androidx.compose.material3.adaptive.navigation/BackNavigationBehavior // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.backNavigationBehavior.<get-backNavigationBehavior>|<get-backNavigationBehavior>(){}[0]
+    final val directive // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.directive|{}directive[0]
+        final fun <get-directive>(): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.directive.<get-directive>|<get-directive>(){}[0]
+    final val paneExpansionDragHandle // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.paneExpansionDragHandle|{}paneExpansionDragHandle[0]
+        final fun <get-paneExpansionDragHandle>(): kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.paneExpansionDragHandle.<get-paneExpansionDragHandle>|<get-paneExpansionDragHandle>(){}[0]
+    final val paneExpansionState // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.paneExpansionState|{}paneExpansionState[0]
+        final fun <get-paneExpansionState>(): androidx.compose.material3.adaptive.layout/PaneExpansionState? // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.paneExpansionState.<get-paneExpansionState>|<get-paneExpansionState>(){}[0]
+    final val shouldHandleSinglePaneLayout // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.shouldHandleSinglePaneLayout|{}shouldHandleSinglePaneLayout[0]
+        final fun <get-shouldHandleSinglePaneLayout>(): kotlin/Boolean // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.shouldHandleSinglePaneLayout.<get-shouldHandleSinglePaneLayout>|<get-shouldHandleSinglePaneLayout>(){}[0]
+
+    final fun (androidx.navigation3.scene/SceneStrategyScope<#A>).calculateScene(kotlin.collections/List<androidx.navigation3.runtime/NavEntry<#A>>): androidx.navigation3.scene/Scene<#A>? // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.calculateScene|calculateScene@androidx.navigation3.scene.SceneStrategyScope<1:0>(kotlin.collections.List<androidx.navigation3.runtime.NavEntry<1:0>>){}[0]
+
+    final object Companion { // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.Companion|null[0]
+        final fun detailPane(kotlin/Any = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.Companion.detailPane|detailPane(kotlin.Any){}[0]
+        final fun extraPane(kotlin/Any = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.Companion.extraPane|extraPane(kotlin.Any){}[0]
+        final fun listPane(kotlin/Any = ..., kotlin/Function3<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit> = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.Companion.listPane|listPane(kotlin.Any;kotlin.Function3<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>){}[0]
+        final fun paneAnimation(androidx.compose.animation/EnterTransition? = ..., androidx.compose.animation/ExitTransition? = ..., androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntRect>? = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.Companion.paneAnimation|paneAnimation(androidx.compose.animation.EnterTransition?;androidx.compose.animation.ExitTransition?;androidx.compose.animation.core.FiniteAnimationSpec<androidx.compose.ui.unit.IntRect>?){}[0]
+        final fun preferredPaneSize(androidx.compose.ui.unit/Dp = ..., androidx.compose.ui.unit/Dp = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.Companion.preferredPaneSize|preferredPaneSize(androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp){}[0]
+        final fun preferredPaneSize(kotlin/Float = ..., kotlin/Float = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy.Companion.preferredPaneSize|preferredPaneSize(kotlin.Float;kotlin.Float){}[0]
+    }
+}
+
+final class <#A: kotlin/Any> androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy : androidx.navigation3.scene/SceneStrategy<#A> { // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy|null[0]
+    constructor <init>(kotlin/Boolean, androidx.compose.material3.adaptive.navigation/BackNavigationBehavior, androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?) // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.<init>|<init>(kotlin.Boolean;androidx.compose.material3.adaptive.navigation.BackNavigationBehavior;androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?){}[0]
+
+    final val adaptStrategies // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.adaptStrategies|{}adaptStrategies[0]
+        final fun <get-adaptStrategies>(): androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.adaptStrategies.<get-adaptStrategies>|<get-adaptStrategies>(){}[0]
+    final val backNavigationBehavior // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.backNavigationBehavior|{}backNavigationBehavior[0]
+        final fun <get-backNavigationBehavior>(): androidx.compose.material3.adaptive.navigation/BackNavigationBehavior // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.backNavigationBehavior.<get-backNavigationBehavior>|<get-backNavigationBehavior>(){}[0]
+    final val directive // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.directive|{}directive[0]
+        final fun <get-directive>(): androidx.compose.material3.adaptive.layout/PaneScaffoldDirective // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.directive.<get-directive>|<get-directive>(){}[0]
+    final val paneExpansionDragHandle // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.paneExpansionDragHandle|{}paneExpansionDragHandle[0]
+        final fun <get-paneExpansionDragHandle>(): kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>? // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.paneExpansionDragHandle.<get-paneExpansionDragHandle>|<get-paneExpansionDragHandle>(){}[0]
+    final val paneExpansionState // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.paneExpansionState|{}paneExpansionState[0]
+        final fun <get-paneExpansionState>(): androidx.compose.material3.adaptive.layout/PaneExpansionState? // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.paneExpansionState.<get-paneExpansionState>|<get-paneExpansionState>(){}[0]
+    final val shouldHandleSinglePaneLayout // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.shouldHandleSinglePaneLayout|{}shouldHandleSinglePaneLayout[0]
+        final fun <get-shouldHandleSinglePaneLayout>(): kotlin/Boolean // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.shouldHandleSinglePaneLayout.<get-shouldHandleSinglePaneLayout>|<get-shouldHandleSinglePaneLayout>(){}[0]
+
+    final fun (androidx.navigation3.scene/SceneStrategyScope<#A>).calculateScene(kotlin.collections/List<androidx.navigation3.runtime/NavEntry<#A>>): androidx.navigation3.scene/Scene<#A>? // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.calculateScene|calculateScene@androidx.navigation3.scene.SceneStrategyScope<1:0>(kotlin.collections.List<androidx.navigation3.runtime.NavEntry<1:0>>){}[0]
+
+    final object Companion { // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.Companion|null[0]
+        final fun extraPane(kotlin/Any = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.Companion.extraPane|extraPane(kotlin.Any){}[0]
+        final fun mainPane(kotlin/Any = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.Companion.mainPane|mainPane(kotlin.Any){}[0]
+        final fun paneAnimation(androidx.compose.animation/EnterTransition? = ..., androidx.compose.animation/ExitTransition? = ..., androidx.compose.animation.core/FiniteAnimationSpec<androidx.compose.ui.unit/IntRect>? = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.Companion.paneAnimation|paneAnimation(androidx.compose.animation.EnterTransition?;androidx.compose.animation.ExitTransition?;androidx.compose.animation.core.FiniteAnimationSpec<androidx.compose.ui.unit.IntRect>?){}[0]
+        final fun preferredPaneSize(androidx.compose.ui.unit/Dp = ..., androidx.compose.ui.unit/Dp = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.Companion.preferredPaneSize|preferredPaneSize(androidx.compose.ui.unit.Dp;androidx.compose.ui.unit.Dp){}[0]
+        final fun preferredPaneSize(kotlin/Float = ..., kotlin/Float = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.Companion.preferredPaneSize|preferredPaneSize(kotlin.Float;kotlin.Float){}[0]
+        final fun supportingPane(kotlin/Any = ...): kotlin.collections/Map<kotlin/String, kotlin/Any> // androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy.Companion.supportingPane|supportingPane(kotlin.Any){}[0]
+    }
+}
+
+final val androidx.compose.material3.adaptive.navigation3/LocalListDetailSceneScope // androidx.compose.material3.adaptive.navigation3/LocalListDetailSceneScope|{}LocalListDetailSceneScope[0]
+    final fun <get-LocalListDetailSceneScope>(): androidx.compose.runtime/ProvidableCompositionLocal<androidx.compose.material3.adaptive.navigation3/ListDetailSceneScope?> // androidx.compose.material3.adaptive.navigation3/LocalListDetailSceneScope.<get-LocalListDetailSceneScope>|<get-LocalListDetailSceneScope>(){}[0]
+final val androidx.compose.material3.adaptive.navigation3/LocalSupportingPaneSceneScope // androidx.compose.material3.adaptive.navigation3/LocalSupportingPaneSceneScope|{}LocalSupportingPaneSceneScope[0]
+    final fun <get-LocalSupportingPaneSceneScope>(): androidx.compose.runtime/ProvidableCompositionLocal<androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneScope?> // androidx.compose.material3.adaptive.navigation3/LocalSupportingPaneSceneScope.<get-LocalSupportingPaneSceneScope>|<get-LocalSupportingPaneSceneScope>(){}[0]
+final val androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ListDetailSceneStrategy$stableprop // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ListDetailSceneStrategy$stableprop|#static{}androidx_compose_material3_adaptive_navigation3_ListDetailSceneStrategy$stableprop[0]
+final val androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_SupportingPaneSceneStrategy$stableprop // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_SupportingPaneSceneStrategy$stableprop|#static{}androidx_compose_material3_adaptive_navigation3_SupportingPaneSceneStrategy$stableprop[0]
+final val androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldScene_OnBackResult$stableprop // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldScene_OnBackResult$stableprop|#static{}androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldScene_OnBackResult$stableprop[0]
+final val androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_ListDetail$stableprop // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_ListDetail$stableprop|#static{}androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_ListDetail$stableprop[0]
+final val androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_SupportingPane$stableprop // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_SupportingPane$stableprop|#static{}androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_SupportingPane$stableprop[0]
+
+final fun <#A: kotlin/Any> androidx.compose.material3.adaptive.navigation3/rememberListDetailSceneStrategy(kotlin/Boolean, androidx.compose.material3.adaptive.navigation/BackNavigationBehavior, androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy<#A> // androidx.compose.material3.adaptive.navigation3/rememberListDetailSceneStrategy|rememberListDetailSceneStrategy(kotlin.Boolean;androidx.compose.material3.adaptive.navigation.BackNavigationBehavior;androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){0§<kotlin.Any>}[0]
+final fun <#A: kotlin/Any> androidx.compose.material3.adaptive.navigation3/rememberListDetailSceneStrategy(kotlin/Boolean, androidx.compose.material3.adaptive.navigation/BackNavigationBehavior?, androidx.compose.material3.adaptive.layout/PaneScaffoldDirective?, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies?, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.navigation3/ListDetailSceneStrategy<#A> // androidx.compose.material3.adaptive.navigation3/rememberListDetailSceneStrategy|rememberListDetailSceneStrategy(kotlin.Boolean;androidx.compose.material3.adaptive.navigation.BackNavigationBehavior?;androidx.compose.material3.adaptive.layout.PaneScaffoldDirective?;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies?;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){0§<kotlin.Any>}[0]
+final fun <#A: kotlin/Any> androidx.compose.material3.adaptive.navigation3/rememberSupportingPaneSceneStrategy(kotlin/Boolean, androidx.compose.material3.adaptive.navigation/BackNavigationBehavior, androidx.compose.material3.adaptive.layout/PaneScaffoldDirective, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy<#A> // androidx.compose.material3.adaptive.navigation3/rememberSupportingPaneSceneStrategy|rememberSupportingPaneSceneStrategy(kotlin.Boolean;androidx.compose.material3.adaptive.navigation.BackNavigationBehavior;androidx.compose.material3.adaptive.layout.PaneScaffoldDirective;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){0§<kotlin.Any>}[0]
+final fun <#A: kotlin/Any> androidx.compose.material3.adaptive.navigation3/rememberSupportingPaneSceneStrategy(kotlin/Boolean, androidx.compose.material3.adaptive.navigation/BackNavigationBehavior?, androidx.compose.material3.adaptive.layout/PaneScaffoldDirective?, androidx.compose.material3.adaptive.layout/ThreePaneScaffoldAdaptStrategies?, kotlin/Function4<androidx.compose.material3.adaptive.layout/ThreePaneScaffoldScope, androidx.compose.material3.adaptive.layout/PaneExpansionState, androidx.compose.runtime/Composer, kotlin/Int, kotlin/Unit>?, androidx.compose.material3.adaptive.layout/PaneExpansionState?, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive.navigation3/SupportingPaneSceneStrategy<#A> // androidx.compose.material3.adaptive.navigation3/rememberSupportingPaneSceneStrategy|rememberSupportingPaneSceneStrategy(kotlin.Boolean;androidx.compose.material3.adaptive.navigation.BackNavigationBehavior?;androidx.compose.material3.adaptive.layout.PaneScaffoldDirective?;androidx.compose.material3.adaptive.layout.ThreePaneScaffoldAdaptStrategies?;kotlin.Function4<androidx.compose.material3.adaptive.layout.ThreePaneScaffoldScope,androidx.compose.material3.adaptive.layout.PaneExpansionState,androidx.compose.runtime.Composer,kotlin.Int,kotlin.Unit>?;androidx.compose.material3.adaptive.layout.PaneExpansionState?;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){0§<kotlin.Any>}[0]
+final fun androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ListDetailSceneStrategy$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ListDetailSceneStrategy$stableprop_getter|androidx_compose_material3_adaptive_navigation3_ListDetailSceneStrategy$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_SupportingPaneSceneStrategy$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_SupportingPaneSceneStrategy$stableprop_getter|androidx_compose_material3_adaptive_navigation3_SupportingPaneSceneStrategy$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldScene_OnBackResult$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldScene_OnBackResult$stableprop_getter|androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldScene_OnBackResult$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_ListDetail$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_ListDetail$stableprop_getter|androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_ListDetail$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_SupportingPane$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive.navigation3/androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_SupportingPane$stableprop_getter|androidx_compose_material3_adaptive_navigation3_ThreePaneScaffoldType_SupportingPane$stableprop_getter(){}[0]
@@ -0,0 +1,40 @@
+// :adaptive-navigation3 - androidx.compose.material3.adaptive.navigation3.*
+// (ListDetail / SupportingPane SceneStrategy for Navigation 3), vendored VERBATIM from
+// JetBrains/compose-multiplatform-core into src/vendor/. See :adaptive for why upstream
+// ships no linux / mingw artifact. commonMain only.
+//
+// navigation3-ui is the PROJECT module: upstream's org.jetbrains.androidx.navigation3:
+// navigation3-ui has no K/N desktop artifact either, which is why :navigation3:navigation3-ui
+// exists. navigationevent-compose is a plain Maven dep (api-exposed by :ui).
+//
+// Provenance = compose-fork.txt + scripts/compose-fork/compose.properties. Never hand-edit
+// src/vendor - change the manifest + `python scripts/compose-fork/sync.py compose/material3/adaptive/adaptive-navigation3`.
+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(":compose:material3:adaptive:adaptive-navigation"))
+				api(project(":navigation3:navigation3-ui"))
+				implementation(libs.androidx.collection)
+				implementation(libs.androidx.navigationevent.compose)
+			}
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=androidx.compose.ui.ExperimentalComposeUiApi",
+			"-opt-in=androidx.compose.material3.adaptive.ExperimentalMaterial3AdaptiveApi",
+		)
+	}
+}
@@ -0,0 +1,13 @@
+SET_REPO=https://github.com/JetBrains/compose-multiplatform-core@<COMPOSE_CORE_REF>
+SET_FOLDER=compose/material3/adaptive/adaptive-navigation3/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/navigation3/ListDetailSceneScope.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/navigation3/ListDetailSceneScope.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/navigation3/ListDetailSceneStrategy.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/navigation3/ListDetailSceneStrategy.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/navigation3/SupportingPaneSceneScope.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/navigation3/SupportingPaneSceneScope.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/navigation3/SupportingPaneSceneStrategy.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/navigation3/SupportingPaneSceneStrategy.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/navigation3/ThreePaneScaffoldScene.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/navigation3/ThreePaneScaffoldScene.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   (none - every source set under SET_FOLDER is vendored)
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>
@@ -0,0 +1,85 @@
+// 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.material3.adaptive:adaptive>
+open annotation class androidx.compose.material3.adaptive/ExperimentalMaterial3AdaptiveApi : kotlin/Annotation { // androidx.compose.material3.adaptive/ExperimentalMaterial3AdaptiveApi|null[0]
+    constructor <init>() // androidx.compose.material3.adaptive/ExperimentalMaterial3AdaptiveApi.<init>|<init>(){}[0]
+}
+
+open annotation class androidx.compose.material3.adaptive/ExperimentalMaterial3AdaptiveComponentOverrideApi : kotlin/Annotation { // androidx.compose.material3.adaptive/ExperimentalMaterial3AdaptiveComponentOverrideApi|null[0]
+    constructor <init>() // androidx.compose.material3.adaptive/ExperimentalMaterial3AdaptiveComponentOverrideApi.<init>|<init>(){}[0]
+}
+
+final class androidx.compose.material3.adaptive/HingeInfo { // androidx.compose.material3.adaptive/HingeInfo|null[0]
+    constructor <init>(androidx.compose.ui.geometry/Rect, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean, kotlin/Boolean) // androidx.compose.material3.adaptive/HingeInfo.<init>|<init>(androidx.compose.ui.geometry.Rect;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean;kotlin.Boolean){}[0]
+
+    final val bounds // androidx.compose.material3.adaptive/HingeInfo.bounds|{}bounds[0]
+        final fun <get-bounds>(): androidx.compose.ui.geometry/Rect // androidx.compose.material3.adaptive/HingeInfo.bounds.<get-bounds>|<get-bounds>(){}[0]
+    final val isFlat // androidx.compose.material3.adaptive/HingeInfo.isFlat|{}isFlat[0]
+        final fun <get-isFlat>(): kotlin/Boolean // androidx.compose.material3.adaptive/HingeInfo.isFlat.<get-isFlat>|<get-isFlat>(){}[0]
+    final val isOccluding // androidx.compose.material3.adaptive/HingeInfo.isOccluding|{}isOccluding[0]
+        final fun <get-isOccluding>(): kotlin/Boolean // androidx.compose.material3.adaptive/HingeInfo.isOccluding.<get-isOccluding>|<get-isOccluding>(){}[0]
+    final val isSeparating // androidx.compose.material3.adaptive/HingeInfo.isSeparating|{}isSeparating[0]
+        final fun <get-isSeparating>(): kotlin/Boolean // androidx.compose.material3.adaptive/HingeInfo.isSeparating.<get-isSeparating>|<get-isSeparating>(){}[0]
+    final val isVertical // androidx.compose.material3.adaptive/HingeInfo.isVertical|{}isVertical[0]
+        final fun <get-isVertical>(): kotlin/Boolean // androidx.compose.material3.adaptive/HingeInfo.isVertical.<get-isVertical>|<get-isVertical>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive/HingeInfo.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive/HingeInfo.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive/HingeInfo.toString|toString(){}[0]
+}
+
+final class androidx.compose.material3.adaptive/Posture { // androidx.compose.material3.adaptive/Posture|null[0]
+    constructor <init>(kotlin/Boolean = ..., kotlin.collections/List<androidx.compose.material3.adaptive/HingeInfo> = ...) // androidx.compose.material3.adaptive/Posture.<init>|<init>(kotlin.Boolean;kotlin.collections.List<androidx.compose.material3.adaptive.HingeInfo>){}[0]
+
+    final val hingeList // androidx.compose.material3.adaptive/Posture.hingeList|{}hingeList[0]
+        final fun <get-hingeList>(): kotlin.collections/List<androidx.compose.material3.adaptive/HingeInfo> // androidx.compose.material3.adaptive/Posture.hingeList.<get-hingeList>|<get-hingeList>(){}[0]
+    final val isTabletop // androidx.compose.material3.adaptive/Posture.isTabletop|{}isTabletop[0]
+        final fun <get-isTabletop>(): kotlin/Boolean // androidx.compose.material3.adaptive/Posture.isTabletop.<get-isTabletop>|<get-isTabletop>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive/Posture.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive/Posture.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive/Posture.toString|toString(){}[0]
+}
+
+final class androidx.compose.material3.adaptive/WindowAdaptiveInfo { // androidx.compose.material3.adaptive/WindowAdaptiveInfo|null[0]
+    constructor <init>(androidx.window.core.layout/WindowSizeClass, androidx.compose.material3.adaptive/Posture) // androidx.compose.material3.adaptive/WindowAdaptiveInfo.<init>|<init>(androidx.window.core.layout.WindowSizeClass;androidx.compose.material3.adaptive.Posture){}[0]
+
+    final val windowPosture // androidx.compose.material3.adaptive/WindowAdaptiveInfo.windowPosture|{}windowPosture[0]
+        final fun <get-windowPosture>(): androidx.compose.material3.adaptive/Posture // androidx.compose.material3.adaptive/WindowAdaptiveInfo.windowPosture.<get-windowPosture>|<get-windowPosture>(){}[0]
+    final val windowSizeClass // androidx.compose.material3.adaptive/WindowAdaptiveInfo.windowSizeClass|{}windowSizeClass[0]
+        final fun <get-windowSizeClass>(): androidx.window.core.layout/WindowSizeClass // androidx.compose.material3.adaptive/WindowAdaptiveInfo.windowSizeClass.<get-windowSizeClass>|<get-windowSizeClass>(){}[0]
+
+    final fun equals(kotlin/Any?): kotlin/Boolean // androidx.compose.material3.adaptive/WindowAdaptiveInfo.equals|equals(kotlin.Any?){}[0]
+    final fun hashCode(): kotlin/Int // androidx.compose.material3.adaptive/WindowAdaptiveInfo.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // androidx.compose.material3.adaptive/WindowAdaptiveInfo.toString|toString(){}[0]
+}
+
+final val androidx.compose.material3.adaptive/allHorizontalHingeBounds // androidx.compose.material3.adaptive/allHorizontalHingeBounds|@androidx.compose.material3.adaptive.Posture{}allHorizontalHingeBounds[0]
+    final fun (androidx.compose.material3.adaptive/Posture).<get-allHorizontalHingeBounds>(): kotlin.collections/List<androidx.compose.ui.geometry/Rect> // androidx.compose.material3.adaptive/allHorizontalHingeBounds.<get-allHorizontalHingeBounds>|<get-allHorizontalHingeBounds>@androidx.compose.material3.adaptive.Posture(){}[0]
+final val androidx.compose.material3.adaptive/allVerticalHingeBounds // androidx.compose.material3.adaptive/allVerticalHingeBounds|@androidx.compose.material3.adaptive.Posture{}allVerticalHingeBounds[0]
+    final fun (androidx.compose.material3.adaptive/Posture).<get-allVerticalHingeBounds>(): kotlin.collections/List<androidx.compose.ui.geometry/Rect> // androidx.compose.material3.adaptive/allVerticalHingeBounds.<get-allVerticalHingeBounds>|<get-allVerticalHingeBounds>@androidx.compose.material3.adaptive.Posture(){}[0]
+final val androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_HingeInfo$stableprop // androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_HingeInfo$stableprop|#static{}androidx_compose_material3_adaptive_HingeInfo$stableprop[0]
+final val androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_Posture$stableprop // androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_Posture$stableprop|#static{}androidx_compose_material3_adaptive_Posture$stableprop[0]
+final val androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_WindowAdaptiveInfo$stableprop // androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_WindowAdaptiveInfo$stableprop|#static{}androidx_compose_material3_adaptive_WindowAdaptiveInfo$stableprop[0]
+final val androidx.compose.material3.adaptive/occludingHorizontalHingeBounds // androidx.compose.material3.adaptive/occludingHorizontalHingeBounds|@androidx.compose.material3.adaptive.Posture{}occludingHorizontalHingeBounds[0]
+    final fun (androidx.compose.material3.adaptive/Posture).<get-occludingHorizontalHingeBounds>(): kotlin.collections/List<androidx.compose.ui.geometry/Rect> // androidx.compose.material3.adaptive/occludingHorizontalHingeBounds.<get-occludingHorizontalHingeBounds>|<get-occludingHorizontalHingeBounds>@androidx.compose.material3.adaptive.Posture(){}[0]
+final val androidx.compose.material3.adaptive/occludingVerticalHingeBounds // androidx.compose.material3.adaptive/occludingVerticalHingeBounds|@androidx.compose.material3.adaptive.Posture{}occludingVerticalHingeBounds[0]
+    final fun (androidx.compose.material3.adaptive/Posture).<get-occludingVerticalHingeBounds>(): kotlin.collections/List<androidx.compose.ui.geometry/Rect> // androidx.compose.material3.adaptive/occludingVerticalHingeBounds.<get-occludingVerticalHingeBounds>|<get-occludingVerticalHingeBounds>@androidx.compose.material3.adaptive.Posture(){}[0]
+final val androidx.compose.material3.adaptive/separatingHorizontalHingeBounds // androidx.compose.material3.adaptive/separatingHorizontalHingeBounds|@androidx.compose.material3.adaptive.Posture{}separatingHorizontalHingeBounds[0]
+    final fun (androidx.compose.material3.adaptive/Posture).<get-separatingHorizontalHingeBounds>(): kotlin.collections/List<androidx.compose.ui.geometry/Rect> // androidx.compose.material3.adaptive/separatingHorizontalHingeBounds.<get-separatingHorizontalHingeBounds>|<get-separatingHorizontalHingeBounds>@androidx.compose.material3.adaptive.Posture(){}[0]
+final val androidx.compose.material3.adaptive/separatingVerticalHingeBounds // androidx.compose.material3.adaptive/separatingVerticalHingeBounds|@androidx.compose.material3.adaptive.Posture{}separatingVerticalHingeBounds[0]
+    final fun (androidx.compose.material3.adaptive/Posture).<get-separatingVerticalHingeBounds>(): kotlin.collections/List<androidx.compose.ui.geometry/Rect> // androidx.compose.material3.adaptive/separatingVerticalHingeBounds.<get-separatingVerticalHingeBounds>|<get-separatingVerticalHingeBounds>@androidx.compose.material3.adaptive.Posture(){}[0]
+
+final fun androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_HingeInfo$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_HingeInfo$stableprop_getter|androidx_compose_material3_adaptive_HingeInfo$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_Posture$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_Posture$stableprop_getter|androidx_compose_material3_adaptive_Posture$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_WindowAdaptiveInfo$stableprop_getter(): kotlin/Int // androidx.compose.material3.adaptive/androidx_compose_material3_adaptive_WindowAdaptiveInfo$stableprop_getter|androidx_compose_material3_adaptive_WindowAdaptiveInfo$stableprop_getter(){}[0]
+final fun androidx.compose.material3.adaptive/currentWindowAdaptiveInfo(androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.material3.adaptive/WindowAdaptiveInfo // androidx.compose.material3.adaptive/currentWindowAdaptiveInfo|currentWindowAdaptiveInfo(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive/currentWindowAdaptiveInfo(kotlin/Boolean, androidx.compose.runtime/Composer?, kotlin/Int, kotlin/Int): androidx.compose.material3.adaptive/WindowAdaptiveInfo // androidx.compose.material3.adaptive/currentWindowAdaptiveInfo|currentWindowAdaptiveInfo(kotlin.Boolean;androidx.compose.runtime.Composer?;kotlin.Int;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive/currentWindowAdaptiveInfoV2(androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.material3.adaptive/WindowAdaptiveInfo // androidx.compose.material3.adaptive/currentWindowAdaptiveInfoV2|currentWindowAdaptiveInfoV2(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive/currentWindowDpSize(androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.ui.unit/DpSize // androidx.compose.material3.adaptive/currentWindowDpSize|currentWindowDpSize(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
+final fun androidx.compose.material3.adaptive/currentWindowSize(androidx.compose.runtime/Composer?, kotlin/Int): androidx.compose.ui.unit/IntSize // androidx.compose.material3.adaptive/currentWindowSize|currentWindowSize(androidx.compose.runtime.Composer?;kotlin.Int){}[0]
@@ -0,0 +1,47 @@
+// :adaptive - androidx.compose.material3.adaptive.* (WindowAdaptiveInfo / Posture /
+// window size class helpers), vendored VERBATIM from JetBrains/compose-multiplatform-core
+// (compose/material3/adaptive/adaptive) into src/vendor/.
+//
+// Upstream org.jetbrains.compose.material3.adaptive:* publishes only ios / macosArm64 -
+// no linux, no mingw (github.com/bitsycore/compose-desktop-native/issues/4). Nothing in
+// the sources blocks those targets: the whole port is vendor-only, every actual the
+// native targets need already exists upstream, and the one real dependency
+// (androidx.window:window-core) ALREADY publishes linux + mingw + macos. The artifacts
+// are missing purely because upstream did not enable the targets.
+//
+// Upstream's `nonAndroidMain` lands in src/vendor/native/ - for this port native IS the
+// only non-android leg, same treatment coil's nonAndroid sets get.
+//
+// Provenance = compose-fork.txt + scripts/compose-fork/compose.properties. Never hand-edit
+// src/vendor - change the manifest + `python scripts/compose-fork/sync.py compose/material3/adaptive/adaptive`.
+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(":compose:ui:ui"))
+				api(libs.androidx.window.core)
+				implementation(project(":compose:foundation:foundation"))
+			}
+			kotlin.srcDir("src/vendor/common/kotlin")
+		}
+		nativeMain {
+			kotlin.srcDir("src/vendor/native/kotlin")
+		}
+	}
+	compilerOptions {
+		freeCompilerArgs.addAll(
+			"-Xexpect-actual-classes",
+			"-opt-in=androidx.compose.ui.ExperimentalComposeUiApi",
+			"-opt-in=androidx.compose.material3.adaptive.ExperimentalMaterial3AdaptiveApi",
+		)
+	}
+}
@@ -0,0 +1,17 @@
+SET_REPO=https://github.com/JetBrains/compose-multiplatform-core@<COMPOSE_CORE_REF>
+SET_FOLDER=compose/material3/adaptive/adaptive/src
+
+commonMain/kotlin/ -> src/vendor/common/kotlin/
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/ExperimentalMaterial3AdaptiveApi.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/ExperimentalMaterial3AdaptiveApi.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/ExperimentalMaterial3AdaptiveComponentOverrideApi.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/ExperimentalMaterial3AdaptiveComponentOverrideApi.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/Posture.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/Posture.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/WindowAdaptiveInfo.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/WindowAdaptiveInfo.kt
+#     | commonMain/kotlin/androidx/compose/material3/adaptive/WindowSizeClassHelper.kt -> src/vendor/common/kotlin/androidx/compose/material3/adaptive/WindowSizeClassHelper.kt
+nonAndroidMain/kotlin/ -> src/vendor/native/kotlin/
+#     | nonAndroidMain/kotlin/androidx/compose/material3/adaptive/WindowAdaptiveInfo.nonAndroid.kt -> src/vendor/native/kotlin/androidx/compose/material3/adaptive/WindowAdaptiveInfo.nonAndroid.kt
+
+# >>> ---- DIAGNOSTIC GAPS ---- <<<<
+#   androidMain (2)
+#     | androidMain/kotlin/androidx/compose/material3/adaptive/AndroidPosture.android.kt -> src/vendor/android/kotlin/androidx/compose/material3/adaptive/AndroidPosture.android.kt
+#     | androidMain/kotlin/androidx/compose/material3/adaptive/AndroidWindowAdaptiveInfo.android.kt -> src/vendor/android/kotlin/androidx/compose/material3/adaptive/AndroidWindowAdaptiveInfo.android.kt
+# <<< ---- DIAGNOSTIC GAPS ---- >>>>
@@ -30,16 +30,16 @@ kotlin {
 				// :ui provides ui / ui-text / runtime; :foundation provides foundation.* +
 				// (transitively) animation.* + foundation.layout.*; :animation-core provides
 				// animation.core.*; :material-ripple provides material.ripple.*.
-				api(project(":ui"))
-				api(project(":foundation"))
-				api(project(":animation-core"))
-				api(project(":material-ripple"))
+				api(project(":compose:ui:ui"))
+				api(project(":compose:foundation:foundation"))
+				api(project(":compose:animation:animation-core"))
+				api(project(":compose:material:material-ripple"))
 				// androidx.collection is used by material3 internals (MutableIntObjectMap, …).
 				// Already on the classpath via :ui's runtime; declare here for clarity.
-				implementation("androidx.collection:collection:1.5.0")
+				implementation(libs.androidx.collection)
 				// androidx.graphics.shapes.* - MaterialShapes (RoundedPolygon /
 				// Morph / CornerRounding) that WavyProgress / LoadingIndicator use.
-				implementation("androidx.graphics:graphics-shapes:1.1.0")
+				implementation(libs.androidx.graphics.shapes)
 				// kotlinx.datetime - DatePicker / TimePicker / CalendarModel.
 				implementation(libs.kotlinx.datetime)
 			}
@@ -14,8 +14,8 @@ kotlin {
 		commonMain {
 			dependencies {
 				api("org.jetbrains.compose.runtime:runtime:${libs.versions.composeRuntime.get()}")
-				api("androidx.navigationevent:navigationevent-compose:1.1.2")
-				api(project(":ui-util"))
+				api(libs.androidx.navigationevent.compose)
+				api(project(":compose:ui:ui-util"))
 				implementation(libs.kotlinx.coroutines.core)
 			}
 			kotlin.srcDir("src/vendor/common/kotlin")
@@ -14,7 +14,7 @@ kotlin {
 		commonMain {
 			dependencies {
 				api("org.jetbrains.compose.runtime:runtime:${libs.versions.composeRuntime.get()}")
-				api(project(":ui-util"))
+				api(project(":compose:ui:ui-util"))
 			}
 			kotlin.srcDir("src/vendor/common/kotlin")
 		}
@@ -333,24 +333,18 @@ abstract interface androidx.compose.ui.graphics/Shape { // androidx.compose.ui.g

 abstract interface com.compose.sdl.graphics/EncodedImageDecoder { // com.compose.sdl.graphics/EncodedImageDecoder|null[0]
    abstract fun decode(kotlin/ByteArray): androidx.compose.ui.graphics/ImageBitmap? // com.compose.sdl.graphics/EncodedImageDecoder.decode|decode(kotlin.ByteArray){}[0]
+    open fun decodeSvgAt(kotlin/ByteArray, kotlin/Int, kotlin/Int): androidx.compose.ui.graphics/ImageBitmap? // com.compose.sdl.graphics/EncodedImageDecoder.decodeSvgAt|decodeSvgAt(kotlin.ByteArray;kotlin.Int;kotlin.Int){}[0]
+    open fun svgIntrinsicSize(kotlin/ByteArray): androidx.compose.ui.geometry/Size? // com.compose.sdl.graphics/EncodedImageDecoder.svgIntrinsicSize|svgIntrinsicSize(kotlin.ByteArray){}[0]
 }

 abstract interface com.compose.sdl.graphics/NativeFinishableCanvas { // com.compose.sdl.graphics/NativeFinishableCanvas|null[0]
    abstract fun finish() // com.compose.sdl.graphics/NativeFinishableCanvas.finish|finish(){}[0]
 }

-abstract interface com.compose.sdl.graphics/NativePainterCanvas { // com.compose.sdl.graphics/NativePainterCanvas|null[0]
-    abstract fun drawNativePainter(kotlin/String, com.compose.sdl.res/ResourceKind, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float) // com.compose.sdl.graphics/NativePainterCanvas.drawNativePainter|drawNativePainter(kotlin.String;com.compose.sdl.res.ResourceKind;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float){}[0]
-}
-
 abstract interface com.compose.sdl.graphics/NativeShadowCanvas { // com.compose.sdl.graphics/NativeShadowCanvas|null[0]
    abstract fun drawDropShadow(androidx.compose.ui.graphics/Outline, kotlin/Float, androidx.compose.ui.graphics/Color, androidx.compose.ui.graphics/Color) // com.compose.sdl.graphics/NativeShadowCanvas.drawDropShadow|drawDropShadow(androidx.compose.ui.graphics.Outline;kotlin.Float;androidx.compose.ui.graphics.Color;androidx.compose.ui.graphics.Color){}[0]
 }

-abstract interface com.compose.sdl.graphics/NativeShapeClipCanvas { // com.compose.sdl.graphics/NativeShapeClipCanvas|null[0]
-    abstract fun clipRoundRect(androidx.compose.ui.geometry/RoundRect) // com.compose.sdl.graphics/NativeShapeClipCanvas.clipRoundRect|clipRoundRect(androidx.compose.ui.geometry.RoundRect){}[0]
-}
-
 abstract interface com.compose.sdl.res/ImageLoader { // com.compose.sdl.res/ImageLoader|null[0]
    abstract fun intrinsicSize(kotlin/String, com.compose.sdl.res/ResourceKind): androidx.compose.ui.geometry/Size // com.compose.sdl.res/ImageLoader.intrinsicSize|intrinsicSize(kotlin.String;com.compose.sdl.res.ResourceKind){}[0]
    abstract fun readBytes(kotlin/String): kotlin/ByteArray? // com.compose.sdl.res/ImageLoader.readBytes|readBytes(kotlin.String){}[0]
@@ -362,62 +356,6 @@ sealed interface androidx.compose.ui.graphics.shadow/ShadowContext { // androidx
    open fun createInnerShadowPainter(androidx.compose.ui.graphics/Shape, androidx.compose.ui.graphics.shadow/Shadow): androidx.compose.ui.graphics.shadow/InnerShadowPainter // androidx.compose.ui.graphics.shadow/ShadowContext.createInnerShadowPainter|createInnerShadowPainter(androidx.compose.ui.graphics.Shape;androidx.compose.ui.graphics.shadow.Shadow){}[0]
 }

-sealed interface com.compose.sdl.graphics/PathCommand { // com.compose.sdl.graphics/PathCommand|null[0]
-    final class CubicTo : com.compose.sdl.graphics/PathCommand { // com.compose.sdl.graphics/PathCommand.CubicTo|null[0]
-        constructor <init>(kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float) // com.compose.sdl.graphics/PathCommand.CubicTo.<init>|<init>(kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float){}[0]
-
-        final val c1x // com.compose.sdl.graphics/PathCommand.CubicTo.c1x|{}c1x[0]
-            final fun <get-c1x>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.CubicTo.c1x.<get-c1x>|<get-c1x>(){}[0]
-        final val c1y // com.compose.sdl.graphics/PathCommand.CubicTo.c1y|{}c1y[0]
-            final fun <get-c1y>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.CubicTo.c1y.<get-c1y>|<get-c1y>(){}[0]
-        final val c2x // com.compose.sdl.graphics/PathCommand.CubicTo.c2x|{}c2x[0]
-            final fun <get-c2x>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.CubicTo.c2x.<get-c2x>|<get-c2x>(){}[0]
-        final val c2y // com.compose.sdl.graphics/PathCommand.CubicTo.c2y|{}c2y[0]
-            final fun <get-c2y>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.CubicTo.c2y.<get-c2y>|<get-c2y>(){}[0]
-        final val x // com.compose.sdl.graphics/PathCommand.CubicTo.x|{}x[0]
-            final fun <get-x>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.CubicTo.x.<get-x>|<get-x>(){}[0]
-        final val y // com.compose.sdl.graphics/PathCommand.CubicTo.y|{}y[0]
-            final fun <get-y>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.CubicTo.y.<get-y>|<get-y>(){}[0]
-    }
-
-    final class LineTo : com.compose.sdl.graphics/PathCommand { // com.compose.sdl.graphics/PathCommand.LineTo|null[0]
-        constructor <init>(kotlin/Float, kotlin/Float) // com.compose.sdl.graphics/PathCommand.LineTo.<init>|<init>(kotlin.Float;kotlin.Float){}[0]
-
-        final val x // com.compose.sdl.graphics/PathCommand.LineTo.x|{}x[0]
-            final fun <get-x>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.LineTo.x.<get-x>|<get-x>(){}[0]
-        final val y // com.compose.sdl.graphics/PathCommand.LineTo.y|{}y[0]
-            final fun <get-y>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.LineTo.y.<get-y>|<get-y>(){}[0]
-    }
-
-    final class MoveTo : com.compose.sdl.graphics/PathCommand { // com.compose.sdl.graphics/PathCommand.MoveTo|null[0]
-        constructor <init>(kotlin/Float, kotlin/Float) // com.compose.sdl.graphics/PathCommand.MoveTo.<init>|<init>(kotlin.Float;kotlin.Float){}[0]
-
-        final val x // com.compose.sdl.graphics/PathCommand.MoveTo.x|{}x[0]
-            final fun <get-x>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.MoveTo.x.<get-x>|<get-x>(){}[0]
-        final val y // com.compose.sdl.graphics/PathCommand.MoveTo.y|{}y[0]
-            final fun <get-y>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.MoveTo.y.<get-y>|<get-y>(){}[0]
-    }
-
-    final class QuadTo : com.compose.sdl.graphics/PathCommand { // com.compose.sdl.graphics/PathCommand.QuadTo|null[0]
-        constructor <init>(kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float) // com.compose.sdl.graphics/PathCommand.QuadTo.<init>|<init>(kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float){}[0]
-
-        final val cx // com.compose.sdl.graphics/PathCommand.QuadTo.cx|{}cx[0]
-            final fun <get-cx>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.QuadTo.cx.<get-cx>|<get-cx>(){}[0]
-        final val cy // com.compose.sdl.graphics/PathCommand.QuadTo.cy|{}cy[0]
-            final fun <get-cy>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.QuadTo.cy.<get-cy>|<get-cy>(){}[0]
-        final val x // com.compose.sdl.graphics/PathCommand.QuadTo.x|{}x[0]
-            final fun <get-x>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.QuadTo.x.<get-x>|<get-x>(){}[0]
-        final val y // com.compose.sdl.graphics/PathCommand.QuadTo.y|{}y[0]
-            final fun <get-y>(): kotlin/Float // com.compose.sdl.graphics/PathCommand.QuadTo.y.<get-y>|<get-y>(){}[0]
-    }
-
-    final object Close : com.compose.sdl.graphics/PathCommand { // com.compose.sdl.graphics/PathCommand.Close|null[0]
-        final fun equals(kotlin/Any?): kotlin/Boolean // com.compose.sdl.graphics/PathCommand.Close.equals|equals(kotlin.Any?){}[0]
-        final fun hashCode(): kotlin/Int // com.compose.sdl.graphics/PathCommand.Close.hashCode|hashCode(){}[0]
-        final fun toString(): kotlin/String // com.compose.sdl.graphics/PathCommand.Close.toString|toString(){}[0]
-    }
-}
-
 abstract class androidx.compose.ui.graphics.colorspace/Adaptation { // androidx.compose.ui.graphics.colorspace/Adaptation|null[0]
    final object Companion { // androidx.compose.ui.graphics.colorspace/Adaptation.Companion|null[0]
        final val Bradford // androidx.compose.ui.graphics.colorspace/Adaptation.Companion.Bradford|{}Bradford[0]
@@ -1090,6 +1028,8 @@ final class com.compose.sdl.renderer.skia/SkiaEncodedImageDecoder : com.compose.
    constructor <init>() // com.compose.sdl.renderer.skia/SkiaEncodedImageDecoder.<init>|<init>(){}[0]

    final fun decode(kotlin/ByteArray): androidx.compose.ui.graphics/ImageBitmap? // com.compose.sdl.renderer.skia/SkiaEncodedImageDecoder.decode|decode(kotlin.ByteArray){}[0]
+    final fun decodeSvgAt(kotlin/ByteArray, kotlin/Int, kotlin/Int): androidx.compose.ui.graphics/ImageBitmap? // com.compose.sdl.renderer.skia/SkiaEncodedImageDecoder.decodeSvgAt|decodeSvgAt(kotlin.ByteArray;kotlin.Int;kotlin.Int){}[0]
+    final fun svgIntrinsicSize(kotlin/ByteArray): androidx.compose.ui.geometry/Size? // com.compose.sdl.renderer.skia/SkiaEncodedImageDecoder.svgIntrinsicSize|svgIntrinsicSize(kotlin.ByteArray){}[0]
 }

 final class com.compose.sdl.renderer.skia/SkiaImageCache { // com.compose.sdl.renderer.skia/SkiaImageCache|null[0]
@@ -1107,19 +1047,6 @@ final class com.compose.sdl.renderer.skia/SkiaLeafDrawer { // com.compose.sdl.re
        final fun <get-imageCache>(): com.compose.sdl.renderer.skia/SkiaImageCache // com.compose.sdl.renderer.skia/SkiaLeafDrawer.imageCache.<get-imageCache>|<get-imageCache>(){}[0]
 }

-final class com.compose.sdl.res/ResourcePainter : androidx.compose.ui.graphics.painter/Painter { // com.compose.sdl.res/ResourcePainter|null[0]
-    final val intrinsicSize // com.compose.sdl.res/ResourcePainter.intrinsicSize|{}intrinsicSize[0]
-        final fun <get-intrinsicSize>(): androidx.compose.ui.geometry/Size // com.compose.sdl.res/ResourcePainter.intrinsicSize.<get-intrinsicSize>|<get-intrinsicSize>(){}[0]
-    final val kind // com.compose.sdl.res/ResourcePainter.kind|{}kind[0]
-        final fun <get-kind>(): com.compose.sdl.res/ResourceKind // com.compose.sdl.res/ResourcePainter.kind.<get-kind>|<get-kind>(){}[0]
-    final val resourcePath // com.compose.sdl.res/ResourcePainter.resourcePath|{}resourcePath[0]
-        final fun <get-resourcePath>(): kotlin/String // com.compose.sdl.res/ResourcePainter.resourcePath.<get-resourcePath>|<get-resourcePath>(){}[0]
-
-    final fun equals(kotlin/Any?): kotlin/Boolean // com.compose.sdl.res/ResourcePainter.equals|equals(kotlin.Any?){}[0]
-    final fun hashCode(): kotlin/Int // com.compose.sdl.res/ResourcePainter.hashCode|hashCode(){}[0]
-    final fun toString(): kotlin/String // com.compose.sdl.res/ResourcePainter.toString|toString(){}[0]
-}
-
 final value class androidx.compose.ui.graphics.colorspace/ColorModel { // androidx.compose.ui.graphics.colorspace/ColorModel|null[0]
    final val componentCount // androidx.compose.ui.graphics.colorspace/ColorModel.componentCount|{}componentCount[0]
        final fun <get-componentCount>(): kotlin/Int // androidx.compose.ui.graphics.colorspace/ColorModel.componentCount.<get-componentCount>|<get-componentCount>(){}[0]
@@ -2104,10 +2031,6 @@ final object com.compose.sdl.graphics/NativeReleaseQueue { // com.compose.sdl.gr
    final fun enqueue(kotlin/Function0<kotlin/Unit>) // com.compose.sdl.graphics/NativeReleaseQueue.enqueue|enqueue(kotlin.Function0<kotlin.Unit>){}[0]
 }

-final object com.compose.sdl.res/AndroidVectorToSvg { // com.compose.sdl.res/AndroidVectorToSvg|null[0]
-    final fun convert(kotlin/String): kotlin/String // com.compose.sdl.res/AndroidVectorToSvg.convert|convert(kotlin.String){}[0]
-}
-
 final object com.compose.sdl.res/Res { // com.compose.sdl.res/Res|null[0]
    final fun readBytes(kotlin/String): kotlin/ByteArray? // com.compose.sdl.res/Res.readBytes|readBytes(kotlin.String){}[0]

@@ -2257,11 +2180,9 @@ final val com.compose.sdl.graphics/gradientTileMode // com.compose.sdl.graphics/
 final val com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaEncodedImageDecoder$stableprop // com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaEncodedImageDecoder$stableprop|#static{}com_compose_sdl_renderer_skia_SkiaEncodedImageDecoder$stableprop[0]
 final val com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaImageCache$stableprop // com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaImageCache$stableprop|#static{}com_compose_sdl_renderer_skia_SkiaImageCache$stableprop[0]
 final val com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaLeafDrawer$stableprop // com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaLeafDrawer$stableprop|#static{}com_compose_sdl_renderer_skia_SkiaLeafDrawer$stableprop[0]
-final val com.compose.sdl.res/com_compose_sdl_res_AndroidVectorToSvg$stableprop // com.compose.sdl.res/com_compose_sdl_res_AndroidVectorToSvg$stableprop|#static{}com_compose_sdl_res_AndroidVectorToSvg$stableprop[0]
 final val com.compose.sdl.res/com_compose_sdl_res_Res$stableprop // com.compose.sdl.res/com_compose_sdl_res_Res$stableprop|#static{}com_compose_sdl_res_Res$stableprop[0]
 final val com.compose.sdl.res/com_compose_sdl_res_Res_drawable$stableprop // com.compose.sdl.res/com_compose_sdl_res_Res_drawable$stableprop|#static{}com_compose_sdl_res_Res_drawable$stableprop[0]
 final val com.compose.sdl.res/com_compose_sdl_res_Res_files$stableprop // com.compose.sdl.res/com_compose_sdl_res_Res_files$stableprop|#static{}com_compose_sdl_res_Res_files$stableprop[0]
-final val com.compose.sdl.res/com_compose_sdl_res_ResourcePainter$stableprop // com.compose.sdl.res/com_compose_sdl_res_ResourcePainter$stableprop|#static{}com_compose_sdl_res_ResourcePainter$stableprop[0]

 final var androidx.compose.ui.graphics/alphaMultiplier // androidx.compose.ui.graphics/alphaMultiplier|@androidx.compose.ui.graphics.Canvas{}alphaMultiplier[0]
    final fun (androidx.compose.ui.graphics/Canvas).<get-alphaMultiplier>(): kotlin/Float // androidx.compose.ui.graphics/alphaMultiplier.<get-alphaMultiplier>|<get-alphaMultiplier>@androidx.compose.ui.graphics.Canvas(){}[0]
@@ -2445,19 +2366,18 @@ final fun com.compose.sdl.graphics/com_compose_sdl_graphics_PathCommand_MoveTo$s
 final fun com.compose.sdl.graphics/com_compose_sdl_graphics_PathCommand_QuadTo$stableprop_getter(): kotlin/Int // com.compose.sdl.graphics/com_compose_sdl_graphics_PathCommand_QuadTo$stableprop_getter|com_compose_sdl_graphics_PathCommand_QuadTo$stableprop_getter(){}[0]
 final fun com.compose.sdl.graphics/createGraphicsContext(): androidx.compose.ui.graphics/GraphicsContext // com.compose.sdl.graphics/createGraphicsContext|createGraphicsContext(){}[0]
 final fun com.compose.sdl.graphics/decodeEncodedImageBitmap(kotlin/ByteArray): androidx.compose.ui.graphics/ImageBitmap? // com.compose.sdl.graphics/decodeEncodedImageBitmap|decodeEncodedImageBitmap(kotlin.ByteArray){}[0]
+final fun com.compose.sdl.graphics/decodeSvgAt(kotlin/ByteArray, kotlin/Int, kotlin/Int): androidx.compose.ui.graphics/ImageBitmap? // com.compose.sdl.graphics/decodeSvgAt|decodeSvgAt(kotlin.ByteArray;kotlin.Int;kotlin.Int){}[0]
 final fun com.compose.sdl.graphics/prepareLayerTransformationMatrix(androidx.compose.ui.graphics/Matrix, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float, kotlin/Float) // com.compose.sdl.graphics/prepareLayerTransformationMatrix|prepareLayerTransformationMatrix(androidx.compose.ui.graphics.Matrix;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float){}[0]
+final fun com.compose.sdl.graphics/svgIntrinsicSize(kotlin/ByteArray): androidx.compose.ui.geometry/Size? // com.compose.sdl.graphics/svgIntrinsicSize|svgIntrinsicSize(kotlin.ByteArray){}[0]
 final fun com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaEncodedImageDecoder$stableprop_getter(): kotlin/Int // com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaEncodedImageDecoder$stableprop_getter|com_compose_sdl_renderer_skia_SkiaEncodedImageDecoder$stableprop_getter(){}[0]
 final fun com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaImageCache$stableprop_getter(): kotlin/Int // com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaImageCache$stableprop_getter|com_compose_sdl_renderer_skia_SkiaImageCache$stableprop_getter(){}[0]
 final fun com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaLeafDrawer$stableprop_getter(): kotlin/Int // com.compose.sdl.renderer.skia/com_compose_sdl_renderer_skia_SkiaLeafDrawer$stableprop_getter|com_compose_sdl_renderer_skia_SkiaLeafDrawer$stableprop_getter(){}[0]
 final fun com.compose.sdl.renderer.skia/readBackBgra(org.jetbrains.skia/Surface?, kotlin/Int, kotlin/Int): kotlin/Triple<kotlin/Int, kotlin/Int, kotlin/ByteArray>? // com.compose.sdl.renderer.skia/readBackBgra|readBackBgra(org.jetbrains.skia.Surface?;kotlin.Int;kotlin.Int){}[0]
-final fun com.compose.sdl.res/com_compose_sdl_res_AndroidVectorToSvg$stableprop_getter(): kotlin/Int // com.compose.sdl.res/com_compose_sdl_res_AndroidVectorToSvg$stableprop_getter|com_compose_sdl_res_AndroidVectorToSvg$stableprop_getter(){}[0]
 final fun com.compose.sdl.res/com_compose_sdl_res_Res$stableprop_getter(): kotlin/Int // com.compose.sdl.res/com_compose_sdl_res_Res$stableprop_getter|com_compose_sdl_res_Res$stableprop_getter(){}[0]
 final fun com.compose.sdl.res/com_compose_sdl_res_Res_drawable$stableprop_getter(): kotlin/Int // com.compose.sdl.res/com_compose_sdl_res_Res_drawable$stableprop_getter|com_compose_sdl_res_Res_drawable$stableprop_getter(){}[0]
 final fun com.compose.sdl.res/com_compose_sdl_res_Res_files$stableprop_getter(): kotlin/Int // com.compose.sdl.res/com_compose_sdl_res_Res_files$stableprop_getter|com_compose_sdl_res_Res_files$stableprop_getter(){}[0]
-final fun com.compose.sdl.res/com_compose_sdl_res_ResourcePainter$stableprop_getter(): kotlin/Int // com.compose.sdl.res/com_compose_sdl_res_ResourcePainter$stableprop_getter|com_compose_sdl_res_ResourcePainter$stableprop_getter(){}[0]
 final fun com.compose.sdl.res/painterResource(kotlin/String): androidx.compose.ui.graphics.painter/Painter // com.compose.sdl.res/painterResource|painterResource(kotlin.String){}[0]
 final fun com.compose.sdl.res/painterResource(kotlin/String, com.compose.sdl.res/ResourceKind): androidx.compose.ui.graphics.painter/Painter // com.compose.sdl.res/painterResource|painterResource(kotlin.String;com.compose.sdl.res.ResourceKind){}[0]
-final fun com.compose.sdl.res/resourceKindForPath(kotlin/String): com.compose.sdl.res/ResourceKind // com.compose.sdl.res/resourceKindForPath|resourceKindForPath(kotlin.String){}[0]
 final inline fun (androidx.compose.ui.graphics.drawscope/DrawScope).androidx.compose.ui.graphics.drawscope/clipPath(androidx.compose.ui.graphics/Path, androidx.compose.ui.graphics/ClipOp = ..., kotlin/Function1<androidx.compose.ui.graphics.drawscope/DrawScope, kotlin/Unit>) // androidx.compose.ui.graphics.drawscope/clipPath|clipPath@androidx.compose.ui.graphics.drawscope.DrawScope(androidx.compose.ui.graphics.Path;androidx.compose.ui.graphics.ClipOp;kotlin.Function1<androidx.compose.ui.graphics.drawscope.DrawScope,kotlin.Unit>){}[0]
 final inline fun (androidx.compose.ui.graphics.drawscope/DrawScope).androidx.compose.ui.graphics.drawscope/clipRect(kotlin/Float = ..., kotlin/Float = ..., kotlin/Float = ..., kotlin/Float = ..., androidx.compose.ui.graphics/ClipOp = ..., kotlin/Function1<androidx.compose.ui.graphics.drawscope/DrawScope, kotlin/Unit>) // androidx.compose.ui.graphics.drawscope/clipRect|clipRect@androidx.compose.ui.graphics.drawscope.DrawScope(kotlin.Float;kotlin.Float;kotlin.Float;kotlin.Float;androidx.compose.ui.graphics.ClipOp;kotlin.Function1<androidx.compose.ui.graphics.drawscope.DrawScope,kotlin.Unit>){}[0]
 final inline fun (androidx.compose.ui.graphics.drawscope/DrawScope).androidx.compose.ui.graphics.drawscope/draw(androidx.compose.ui.unit/Density, androidx.compose.ui.unit/LayoutDirection, androidx.compose.ui.graphics/Canvas, androidx.compose.ui.geometry/Size, androidx.compose.ui.graphics.layer/GraphicsLayer? = ..., kotlin/Function1<androidx.compose.ui.graphics.drawscope/DrawScope, kotlin/Unit>) // androidx.compose.ui.graphics.drawscope/draw|draw@androidx.compose.ui.graphics.drawscope.DrawScope(androidx.compose.ui.unit.Density;androidx.compose.ui.unit.LayoutDirection;androidx.compose.ui.graphics.Canvas;androidx.compose.ui.geometry.Size;androidx.compose.ui.graphics.layer.GraphicsLayer?;kotlin.Function1<androidx.compose.ui.graphics.drawscope.DrawScope,kotlin.Unit>){}[0]
@@ -24,9 +24,9 @@ kotlin {
        commonMain {
            kotlin.srcDir("src/vendor/common/kotlin")
            dependencies {
-                api(project(":ui-geometry"))
-                api(project(":ui-unit"))
-                api(project(":ui-util"))
+                api(project(":compose:ui:ui-geometry"))
+                api(project(":compose:ui:ui-unit"))
+                api(project(":compose:ui:ui-util"))
                api("org.jetbrains.compose.runtime:runtime:${libs.versions.composeRuntime.get()}")
                implementation(libs.kotlinx.coroutines.core)
                // androidx.collection comes transitively via :ui-util (api).
@@ -55,7 +55,7 @@ kotlin {
                kotlin.srcDir("src/skikoRendererMain/kotlin")
                kotlin.srcDir("src/vendor/skikoRenderer/kotlin")
                dependencies {
-                    implementation("com.bitsycore.skiko:skiko:${providers.gradleProperty("skikoMingwVersion").getOrElse("0.150.1-mingw.1")}")
+                    implementation("com.bitsycore.skiko:skiko:${providers.gradleProperty("skikoMingwVersion").getOrElse(libs.versions.skikoMingw.get())}")
                }
            }
            val skikoRendererMingwMain = create("skikoRendererMingwMain") { dependsOn(skikoRendererMingwSharedMain) }
@@ -16,7 +16,7 @@ import com.compose.sdl.res.ResourceKind
 the given rect, and this seam carries no ui-layout (ContentScale) dependency -
 keeping :ui-graphics free of :ui.
 */
-interface NativePainterCanvas {
+internal interface NativePainterCanvas {
 	fun drawNativePainter(
 		inResourcePath: String,
 		inKind: ResourceKind,
@@ -10,7 +10,7 @@ package com.compose.sdl.graphics
   carries a `commands: List<PathCommand>` that the SDL3 / Skia renderers walk
   directly. No official equivalent, so lives in com.compose.sdl
   per FIDELITY.md's relocate rule. */
-sealed interface PathCommand {
+internal sealed interface PathCommand {
 	class MoveTo(val x: Float, val y: Float) : PathCommand
 	class LineTo(val x: Float, val y: Float) : PathCommand
 	class QuadTo(val cx: Float, val cy: Float, val x: Float, val y: Float) : PathCommand
@@ -21,7 +21,7 @@ import androidx.compose.ui.geometry.RoundRect
 `Canvas.restore()` - the backend composites and pops it on the matching
 `restore()`.
 */
-interface NativeShapeClipCanvas {
+internal interface NativeShapeClipCanvas {
 	// Pushes a rounded-rect clip for subsequent draws until the matching
 	// Canvas.restore(). [inRoundRect] is in the CURRENT canvas-local coordinate
 	// space (the same space draw calls use after the enclosing translate).
@@ -16,7 +16,7 @@ package com.compose.sdl.res
   Not supported: <group> transforms (paths are flattened, transforms ignored),
   gradients, clip-paths, trim-path. This covers the common single-/multi-path
   icon case such as exported Material icons. */
-object AndroidVectorToSvg {
+internal object AndroidVectorToSvg {

 	// Tag values never contain '>' (pathData is letters/digits/.,- /space) and
 	// quoted attribute values can't either, so [^>] within a tag is safe.
--- a/Show More
+++ b/Show More