peachsim 0.1.648 → 0.1.649

package/kotlin/fixtures/kotlin-app/app/src/main/java/dev/contrast/kotlinapp/ProbeApplication.kt

@@ -0,0 +1,18 @@
+package dev.contrast.kotlinapp
+
+import android.app.Application
+
+// process globals the probe reads back: the cold-start order and a value only
+// the application sets before any activity exists.
+object Probe {
+    val log = mutableListOf<String>()
+    var greeting = "unset"
+}
+
+class ProbeApplication : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        Probe.log += "app.onCreate"
+        Probe.greeting = "set by application"
+    }
+}

package/kotlin/fixtures/kotlin-app/build.gradle.kts

@@ -0,0 +1,5 @@
+plugins {
+    id("com.android.application") version "9.2.1" apply false
+    id("org.jetbrains.kotlin.android") version "2.2.0" apply false
+    id("org.jetbrains.kotlin.plugin.compose") version "2.2.0" apply false
+}

package/kotlin/fixtures/kotlin-app/gradle.properties

@@ -0,0 +1,4 @@
+android.useAndroidX=true
+android.builtInKotlin=false
+android.newDsl=false
+org.gradle.jvmargs=-Xmx2g

package/kotlin/fixtures/kotlin-app/settings.gradle.kts

@@ -0,0 +1,4 @@
+pluginManagement { repositories { google(); mavenCentral(); gradlePluginPortal() } }
+dependencyResolutionManagement { repositories { google(); mavenCentral() } }
+rootProject.name = "KotlinApp"
+include(":app")

package/kotlin/fork/NOTICE

@@ -17,9 +17,11 @@ The license text is in LICENSE beside this file.
     https://android.googlesource.com/platform/frameworks/base
 
 Modifications: compose-worker-globals.patch and skiko-worker-clock.patch
-change four upstream source files so their web code reads globalThis instead
-of window (performance.now, isSecureContext, navigator.clipboard,
-navigator.languages). Each modified file carries a notice saying so. No other
-upstream file changes; the built klibs are ui-wasm-js and ui-text-wasm-js
+change clock and clipboard reads to globalThis rather than window, and add an
+explicit ui-text locale provider and Skiko host OS provider whose defaults
+retain upstream navigator behavior. Each modified file carries a notice saying so. The Skiko
+loader build also reads import.meta.url instead of self.location.href, which
+React Native tenants do not expose. The built klibs are ui-wasm-js and ui-text-wasm-js
 1.13.0-alpha01 and skiko-wasm-js 0.152.0-alpha02 compiled from the patched
-sources.
+sources; skiko-wasm-0.152.0-alpha02.jar contains that worker-safe loader and
+Skiko's own wasm runtime.

package/kotlin/fork/README.md

@@ -1,59 +1,51 @@
 # Peach's JetBrains web fork
 
-Peach runs Compose in a tenant worker, which has no `window`, like any browser
-worker. Three web functions in Compose UI 1.13.0-alpha01 and one in Skiko
-0.152.0-alpha02 name `window` anyway, so a Compose scene throws
-`window is not defined` before its first frame. Peach carries patched builds
-of those modules until upstream supports workers.
+Peach runs Compose in a React Native tenant worker, with no `window`,
+`document`, `location`, or browser navigator language/platform fields. The official
+Compose UI 1.13.0-alpha01 and Skiko 0.152.0-alpha02 platform actuals assume
+browser globals that this native host does not publish. Peach carries patched
+builds until upstream supplies equivalent worker and native host hooks.
 
-The patches replace `window` with `globalThis` and nothing else:
-
-| module | file | read |
+| module | file | native host binding |
 | --- | --- | --- |
-| `org.jetbrains.compose.ui:ui` | `Actuals.wasm.kt` | `currentTimeMillis()` from `globalThis.performance.now()` |
-| `org.jetbrains.compose.ui:ui` | `PlatformClipboard.web.kt` | `globalThis.isSecureContext`, `globalThis.navigator.clipboard` |
-| `org.jetbrains.compose.ui:ui-text` | `PlatformLocale.web.kt` | `globalThis.navigator.languages` |
-| `org.jetbrains.skiko:skiko` | `Actuals.web.kt` | `currentNanoTime()` from `globalThis.performance.now()` |
-
-In a document `globalThis` is the window, so behavior there is unchanged. In a
-worker each read returns the worker's real value: its clock, its secure
-context, its languages, and no clipboard API. Nothing defines a `window`.
-
-## files
-
-- `fork.json`: upstream repositories, tags and commits, patch sha256s, and the
-  builder's pinned JDK and Android command-line tools.
-- `compose-worker-globals.patch`, `skiko-worker-clock.patch`: the whole fork.
-  Every modified file carries a notice saying it was modified.
-- `LICENSE` (Apache 2.0, both upstreams) and `NOTICE`.
-- `build.sh`: fetches each upstream at its commit, applies its patch and runs
-  the upstream Gradle build for the changed modules only.
-
-`packages/peachsim/kotlin/toolchain.json` names each built klib by its sha256
-at `https://r2.rnxsim.com/peach-kotlin-fork/<sha256>/<file>`, beside a copy of
-the patches, `fork.json`, `LICENSE` and `NOTICE`. Every other Compose library
-is the official Maven artifact. The klibs load only for an app whose Kotlin
-imports Compose, like the rest of the Compose closure.
-
-## rebuilding
+| Compose `ui` | `Actuals.wasm.kt` | clock reads `globalThis.performance.now()` |
+| Compose `ui` | `PlatformClipboard.web.kt` | worker-safe secure-context and clipboard reads |
+| Compose `ui-text` | `PlatformLocale.web.kt` | explicit `setPlatformLocaleProvider`; its default keeps upstream navigator behavior |
+| Skiko | `OsArch.web.kt` | explicit `setHostOsProvider`; its default lazily retains upstream OS detection |
+| Skiko | `Actuals.web.kt` | nanosecond clock reads `globalThis.performance.now()` |
+| Skiko loader build | `OptimizeSkikoWasmTask.kt` | script directory reads `import.meta.url`, without `self.location` |
+
+The Compose host installs the locale provider once before any scene, from the
+same device locale it passes to `PlatformContext`, and installs `OS.Android`
+through Skiko’s host OS provider before any scene. Browser navigator fields
+stay absent in guest JS. Changes to device language after launch are outside
+this contract.
+
+`fork.json` pins repositories, commits, patch hashes, JDK and Android tools.
+Every changed upstream file carries a modification notice. `LICENSE` and
+`NOTICE` travel with the patches. `build.sh` builds the changed KLIBs and Skiko
+runtime jar with the upstream Gradle builds on the Linux builder.
 
 ```sh
 bun remote bash packages/peachsim/kotlin/fork/build.sh
 bun packages/peachsim/kotlin/fork/publish.ts .remote-out/kotlin-fork
 ```
 
-The build runs on the Linux builder under its idle scheduling and memory
-bound; a warm rebuild takes a few minutes. The build delivers the klibs with
-the record it used (`fork.json`, patches, LICENSE, NOTICE, `klibs.sha256`).
-`publish.ts` uploads exactly that delivery under each klib's sha256, refuses to
-replace an existing object with other bytes, and prints the `toolchain.json`
-entries. Moving a pin means a new tag, commit, regenerated patch and patch
-sha256 in `fork.json`, then a rebuild.
-
-## exit
-
-Delete this directory and point `toolchain.json` back at Maven Central when
-official Compose Multiplatform and Skiko releases read worker-safe globals in
-all four places, and those releases match the Android pin table in
-`plans/peach/kotlin-everywhere.md`. The upstream issue text lives with that
-plan's owner until it is filed.
+The delivery includes `artifacts.sha256` and its exact fork record. Publication
+stores each binary at `peach-kotlin-fork/<binary-sha256>/<file>` and its record
+at `peach-kotlin-fork/<binary-sha256>/records/<record-sha256>/`. It refuses to
+replace existing bytes. A metadata change cannot overwrite a previous record
+when a binary is unchanged. `toolchain.json` pins these immutable binary URLs;
+all other Compose libraries remain official Maven artifacts. Everything stays
+lazy for Kotlin/Compose apps.
+
+The isolated worker probe cannot certify the native tenant's absent globals.
+`scripts/debug/peach-compose-mount/tenant-run.ts` boots the actual capture tenant
+with the imported `.kt` component, asserts those globals stay absent, and
+checks `Locale.current` and `LocalLocaleList` against an ar-EG device setting
+with an en-US browser.
+
+Delete the fork when official releases provide worker-safe clocks/clipboard,
+a location-independent loader and equivalent native locale/host OS provider hooks,
+then rematch the Android pins in `plans/peach/kotlin-everywhere.md`. The prepared
+upstream issue names these hooks and the full guest regression vehicle.

package/kotlin/fork/build.sh

@@ -115,7 +115,8 @@ checkout 1
   cd "${SOURCE}/skiko"
   gradle -Pdeploy.version=0.152.0-alpha02 -Pdeploy.release=true \
     -Pskiko.wasm.enabled=true -Pskiko.awt.enabled=false \
-    :publishWasmJsPublicationToMavenLocal
+    :publishWasmJsPublicationToMavenLocal :skikoWasmJar
+  cp build/libs/skiko-wasm-0.152.0-alpha02.jar "${DELIVER}/"
 )
 
 cp "${M2}/org/jetbrains/compose/ui/ui-wasm-js/1.13.0-alpha01/ui-wasm-js-1.13.0-alpha01.klib" \
@@ -125,4 +126,4 @@ cp "${M2}/org/jetbrains/compose/ui/ui-wasm-js/1.13.0-alpha01/ui-wasm-js-1.13.0-a
 # the record travels with the klibs it describes, so publishing attaches what
 # this build used, not whatever the checkout holds later
 cp "${FORK}/fork.json" "${FORK}/LICENSE" "${FORK}/NOTICE" "${FORK}"/*.patch "${DELIVER}/"
-(cd "${DELIVER}" && sha256sum -- *.klib > klibs.sha256 && cat klibs.sha256)
+(cd "${DELIVER}" && sha256sum -- *.klib *.jar > artifacts.sha256 && cat artifacts.sha256)

package/kotlin/fork/compose-worker-globals.patch

@@ -1,5 +1,4 @@
 diff --git a/compose/ui/ui-text/src/webMain/kotlin/androidx/compose/ui/text/intl/PlatformLocale.web.kt b/compose/ui/ui-text/src/webMain/kotlin/androidx/compose/ui/text/intl/PlatformLocale.web.kt
-index 6e80e51..28f1de1 100644
 --- a/compose/ui/ui-text/src/webMain/kotlin/androidx/compose/ui/text/intl/PlatformLocale.web.kt
 +++ b/compose/ui/ui-text/src/webMain/kotlin/androidx/compose/ui/text/intl/PlatformLocale.web.kt
 @@ -12,6 +12,10 @@
@@ -7,20 +6,32 @@ index 6e80e51..28f1de1 100644
   * See the License for the specific language governing permissions and
   * limitations under the License.
 + *
-+ * Modified for Peach (https://peachsim.com): reads worker-safe globals through
-+ * globalThis instead of window, so this code runs in a Web Worker as well as a
-+ * document. See the Peach fork record for the patch and upstream revision.
++ * modified for Peach: an explicit locale provider lets a native host supply
++ * device languages without exposing browser navigator fields to guest code.
++ * see the fork record for the patch and upstream revision.
   */
  
  package androidx.compose.ui.text.intl
-@@ -127,4 +131,4 @@ private fun userPreferredLanguages(): List<String> {
+@@ -64,8 +68,18 @@
+ // The locale code en-001 denotes the English language spoken in the World.
+ private const val FALLBACK_LANGUAGE_TAG = "en-001"
  
- @OptIn(ExperimentalWasmJsInterop::class)
- private fun getUserPreferredLanguagesAsArray(): JsArray<JsString> =
--    js("window.navigator.languages")
-
-+    js("globalThis.navigator.languages")
-
++private var currentLocaleProvider: () -> LocaleList = {
++    localeListFromLanguageTags(userPreferredLanguages())
++}
++
++// the host installs the device provider before constructing its first scene.
++@InternalComposeUiApi
++fun setPlatformLocaleProvider(provider: () -> LocaleList) {
++    currentLocaleProvider = provider
++}
++
+ internal actual fun createPlatformLocaleDelegate(): PlatformLocaleDelegate =
+     object : PlatformLocaleDelegate {
+         override val current: LocaleList
+-            get() = localeListFromLanguageTags(userPreferredLanguages())
++            get() = currentLocaleProvider()
+     }
 diff --git a/compose/ui/ui/src/wasmJsMain/kotlin/androidx/compose/ui/Actuals.wasm.kt b/compose/ui/ui/src/wasmJsMain/kotlin/androidx/compose/ui/Actuals.wasm.kt
 index 26aa8ea..aa4f6d4 100644
 --- a/compose/ui/ui/src/wasmJsMain/kotlin/androidx/compose/ui/Actuals.wasm.kt

package/kotlin/fork/fork.json

@@ -18,7 +18,7 @@
       "tag": "v1.13.0-alpha01",
       "commit": "a9e47e8aa04c95cfe572ab4297c770f3cbfb234e",
       "patch": "compose-worker-globals.patch",
-      "patchSha256": "7f7df0788145b8d44c32a9ca7746cf254c363beca816922f84d73faa0effed5a"
+      "patchSha256": "51fa45bda1e0aae7db2eab1b056def406352958257e1d3b899c5c3d8aa5edddb"
     },
     {
       "name": "skiko",
@@ -27,7 +27,7 @@
       "tag": "v0.152.0-alpha02",
       "commit": "96378296bb23c23c5f30cd2b0d42d6f8fdeff730",
       "patch": "skiko-worker-clock.patch",
-      "patchSha256": "d55007f3aa4c2b61e44f036bdb43f37ab38455bf800664fdb6598955874d10da"
+      "patchSha256": "735a42f7a9d3be1ab288f4d67bef44924ec2b6bbcd59f5a5f76edf22f912c347"
     }
   ]
 }

package/kotlin/fork/publish.ts

@@ -1,6 +1,6 @@
-// uploads the klibs one build.sh run delivered to R2, each under its sha256
+// uploads the artifacts one build.sh run delivered to R2, each under its sha256
 // beside the record that run copied (patches, fork.json, LICENSE, NOTICE,
-// klibs.sha256), and prints the toolchain.json entries that name them. keys
+// artifacts.sha256), and prints the toolchain.json entries that name them. keys
 // are immutable: an existing object with other bytes stops the publish. needs
 // R2 credentials; reads are public.
 //
@@ -22,27 +22,32 @@ const files = readdirSync(delivered)
 const record = files.filter(
   (name) =>
     name.endsWith('.patch') ||
-    ['fork.json', 'LICENSE', 'NOTICE', 'klibs.sha256'].includes(name),
+    ['fork.json', 'LICENSE', 'NOTICE', 'artifacts.sha256'].includes(name),
+)
+if (
+  record.length !==
+  files.filter((name) => !name.endsWith('.klib') && !name.endsWith('.jar')).length
 )
-if (record.length !== files.filter((name) => !name.endsWith('.klib')).length)
   throw new Error(`${delivered} holds files build.sh does not deliver`)
-if (!record.includes('klibs.sha256') || !record.includes('fork.json'))
+if (!record.includes('artifacts.sha256') || !record.includes('fork.json'))
   throw new Error(`${delivered} is not a build.sh delivery`)
 
-// the klibs are exactly the ones the build hashed
+// the artifacts are exactly the ones the build hashed
 const built = new Map(
-  readFileSync(path.join(delivered, 'klibs.sha256'), 'utf8')
+  readFileSync(path.join(delivered, 'artifacts.sha256'), 'utf8')
     .trim()
     .split('\n')
     .map((line) => {
       const [hash, name] = line.split(/\s+/)
-      if (!hash || !name) throw new Error(`malformed klibs.sha256 line: ${line}`)
+      if (!hash || !name) throw new Error(`malformed artifacts.sha256 line: ${line}`)
       return [name, hash]
     }),
 )
-const klibs = files.filter((name) => name.endsWith('.klib')).sort()
-if (klibs.length === 0 || klibs.length !== built.size)
-  throw new Error(`${delivered} klibs do not match klibs.sha256`)
+const artifacts = files
+  .filter((name) => name.endsWith('.klib') || name.endsWith('.jar'))
+  .sort()
+if (artifacts.length === 0 || artifacts.length !== built.size)
+  throw new Error(`${delivered} artifacts do not match artifacts.sha256`)
 
 async function put(key: string, bytes: Buffer, contentType: string) {
   const existing = await readR2Object(key, 120000)
@@ -53,23 +58,33 @@ async function put(key: string, bytes: Buffer, contentType: string) {
   await uploadToR2(key, bytes, contentType, IMMUTABLE)
 }
 
+const recordHash = sha256(
+  Buffer.concat(
+    record
+      .sort()
+      .flatMap((file) => [
+        Buffer.from(file + '\0'),
+        readFileSync(path.join(delivered, file)),
+      ]),
+  ),
+)
 const entries = []
-for (const name of klibs) {
+for (const name of artifacts) {
   const bytes = readFileSync(path.join(delivered, name))
   const hash = sha256(bytes)
   if (built.get(name) !== hash)
-    throw new Error(`${name} is not the klib the build hashed`)
+    throw new Error(`${name} is not the artifact the build hashed`)
   const prefix = `peach-kotlin-fork/${hash}`
   await put(`${prefix}/${name}`, bytes, 'application/octet-stream')
   for (const file of record)
     await put(
-      `${prefix}/${file}`,
+      `${prefix}/records/${recordHash}/${file}`,
       readFileSync(path.join(delivered, file)),
       'text/plain; charset=utf-8',
     )
   // the loader caches a library by its name, so the name carries the hash
   entries.push({
-    name: name.replace(/\.klib$/, `-peach-${hash.slice(0, 12)}.klib`),
+    name: name.replace(/\.(klib|jar)$/, `-peach-${hash.slice(0, 12)}.$1`),
     url: `${RNX_PUBLIC.publicR2Origin}/${prefix}/${name}`,
     sha256: hash,
   })

package/kotlin/fork/skiko-worker-clock.patch

@@ -31,3 +31,41 @@ index 366ed37..d56c267 100644
 +    js("globalThis.performance.now() * 1000000")
  
  annotation class WebImport(val name : String)
+diff --git a/skiko/buildSrc/src/main/kotlin/OptimizeSkikoWasmTask.kt b/skiko/buildSrc/src/main/kotlin/OptimizeSkikoWasmTask.kt
+--- a/skiko/buildSrc/src/main/kotlin/OptimizeSkikoWasmTask.kt
++++ b/skiko/buildSrc/src/main/kotlin/OptimizeSkikoWasmTask.kt
+@@ -65,6 +65,12 @@ abstract class OptimizeSkikoWasmTask : AbstractSkikoNativeToolTask() {
+                                     "${inputFile.nameWithoutExtension}.wasm",
+                                     "${libOutputFileName.get()}.wasm"
+                                 )
++                                // peach tenants hide location from react native;
++                                // emscripten already uses this module url below.
++                                .replace(
++                                    "scriptDirectory=self.location.href",
++                                    "scriptDirectory=import.meta.url"
++                                )
+                         )
+                     }
+                 }
+diff --git a/skiko/src/webMain/kotlin/org/jetbrains/skiko/OsArch.web.kt b/skiko/src/webMain/kotlin/org/jetbrains/skiko/OsArch.web.kt
+--- a/skiko/src/webMain/kotlin/org/jetbrains/skiko/OsArch.web.kt
++++ b/skiko/src/webMain/kotlin/org/jetbrains/skiko/OsArch.web.kt
+@@ -3,6 +3,15 @@
+ import kotlinx.browser.window
+ import kotlin.js.js
+-
++
+-actual val hostOs: OS = detectHostOs()
++private val defaultHostOs: OS by lazy { detectHostOs() }
++private var hostOsProvider: () -> OS = { defaultHostOs }
++
++// modified for Peach: native hosts install their device's platform before
++// any compose scene. see the fork record for the patch and upstream revision.
++fun setHostOsProvider(provider: () -> OS) {
++    hostOsProvider = provider
++}
++
++actual val hostOs: OS get() = hostOsProvider()
+-
++
+ actual val hostArch: Arch = Arch.Unknown

package/kotlin/toolchain.json

@@ -33,9 +33,9 @@
       "sha256": "6187e199922b061cffa16fd9ae2ed920d6a59f0b0f7c3207e829b983ff132d38"
     },
     {
-      "name": "skiko-wasm-js-0.152.0-alpha02-peach-a480f0730dab.klib",
-      "url": "https://r2.rnxsim.com/peach-kotlin-fork/a480f0730dabea887e2fa22f5f5683454d3594445557a8d8149647af90d3d312/skiko-wasm-js-0.152.0-alpha02.klib",
-      "sha256": "a480f0730dabea887e2fa22f5f5683454d3594445557a8d8149647af90d3d312"
+      "name": "skiko-wasm-js-0.152.0-alpha02-peach-3834433e1790.klib",
+      "url": "https://r2.rnxsim.com/peach-kotlin-fork/3834433e17902a3d86dc973abb245b7af5aae0012ca29e1ac9668d74335f3115/skiko-wasm-js-0.152.0-alpha02.klib",
+      "sha256": "3834433e17902a3d86dc973abb245b7af5aae0012ca29e1ac9668d74335f3115"
     },
     {
       "name": "annotation-wasm-js-1.9.1.klib",
@@ -73,9 +73,9 @@
       "sha256": "dab0b337dd99ec99e8a3cc4efd365d8101db050971490eff6839fc566aeadc6c"
     },
     {
-      "name": "ui-text-wasm-js-1.13.0-alpha01-peach-a2c25f211136.klib",
-      "url": "https://r2.rnxsim.com/peach-kotlin-fork/a2c25f2111369c638e785f192312934a78fcacc15186da681429b580b143ddd7/ui-text-wasm-js-1.13.0-alpha01.klib",
-      "sha256": "a2c25f2111369c638e785f192312934a78fcacc15186da681429b580b143ddd7"
+      "name": "ui-text-wasm-js-1.13.0-alpha01-peach-10c54ff0fa5f.klib",
+      "url": "https://r2.rnxsim.com/peach-kotlin-fork/10c54ff0fa5fc0ff066fb4561e2d5ca9d5c41fedcb32a61414016ef215b035ba/ui-text-wasm-js-1.13.0-alpha01.klib",
+      "sha256": "10c54ff0fa5fc0ff066fb4561e2d5ca9d5c41fedcb32a61414016ef215b035ba"
     },
     {
       "name": "ui-unit-wasm-js-1.13.0-alpha01.klib",
@@ -290,9 +290,9 @@
     "skiko": "0.152.0-alpha02"
   },
   "composeRuntime": {
-    "name": "skiko-wasm-0.152.0-alpha02.jar",
-    "url": "https://repo1.maven.org/maven2/org/jetbrains/skiko/skiko-wasm-js/0.152.0-alpha02/skiko-wasm-js-0.152.0-alpha02-skiko-runtime.jar",
-    "sha256": "14e37c567f10d906a10a74df80b44ee5a5dd5e3a75929f351a32d5b123dad643"
+    "name": "skiko-wasm-0.152.0-alpha02-peach-4814686165d0.jar",
+    "url": "https://r2.rnxsim.com/peach-kotlin-fork/4814686165d0ba869e605e661d0fb261ecc79f5e984ed6ae78dfe20300923c98/skiko-wasm-0.152.0-alpha02.jar",
+    "sha256": "4814686165d0ba869e605e661d0fb261ecc79f5e984ed6ae78dfe20300923c98"
   },
   "composeJsLibraries": [
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.648",
+  "version": "0.1.649",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/src/kotlin-host.ts

@@ -256,7 +256,7 @@ function entrySource(ids: string[]): string {
   ].join('\n')
 }
 
-const BUILD_FORMAT = 4
+const BUILD_FORMAT = 5
 const builds = new Map<string, Promise<KotlinArtifact>>()
 
 function buildsDir(): string {
@@ -278,18 +278,34 @@ export async function kotlinArtifact(
   if (sources.length === 0) throw new Error(`${root} holds no Kotlin sources`)
   const generated: Record<string, string> = {}
   const ids: string[] = []
+  const viewIds: string[] = []
   let usesCompose = false
   for (const file of sources) {
     const source = fs.readFileSync(file, 'utf8')
     if (/\bandroidx\.compose\./.test(source)) usesCompose = true
     const contract = nativeSourceContract(file, source)
-    if (contract.modules.length === 0) continue
+    if (contract.modules.length === 0 && contract.views.length === 0) continue
     const id = kotlinSourceId(root, file)
-    ids.push(id)
+    if (contract.modules.length > 0) ids.push(id)
+    if (contract.views.length > 0) viewIds.push(id)
     generated[`OneNativeSource_${id}.kt`] = renderKotlinSourceGlue(id, contract).source
   }
   generated['PeachEntry.kt'] = entrySource(ids)
-  const shims = kotlinSources(path.join(moduleRoot, 'Sources'))
+  if (viewIds.length > 0) {
+    generated['PeachViews.kt'] = [
+      'import dev.onejs.one.OneNativeSourceViewDispatch',
+      '',
+      'fun peachViewDispatcher(source: String): OneNativeSourceViewDispatch = when (source) {',
+      ...viewIds.map((id) => `    ${JSON.stringify(id)} -> OneNativeSourceViews_${id}()`),
+      '    else -> error("composable source $source is not linked; rebuild the app")',
+      '}',
+    ].join('\n')
+  }
+  const shims = kotlinSources(path.join(moduleRoot, 'Sources')).filter(
+    (file) => usesCompose || !file.endsWith('/OneNativeSourceViewDispatch.kt'),
+  )
+  if (viewIds.length > 0)
+    shims.push(...kotlinSources(path.join(moduleRoot, 'ComposeSources')))
   const digest = createHash('sha256')
   // BUILD_FORMAT moves when this host changes what it does to a build
   digest.update(JSON.stringify({ format: BUILD_FORMAT, toolchain, language }))