peachsim 0.1.648 → 0.1.650

package/src/kotlin-app.ts

@@ -0,0 +1,411 @@
+// reads a pure Kotlin Android app module the way its Gradle build and the
+// device resolve it, for the subset Peach boots: one module's `main` source
+// set, its own manifest, literal Gradle values and the pinned Compose closure.
+// anything outside that subset rejects with its location, never approximated.
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+export interface KotlinAppProject {
+  projectDir: string
+  moduleDir: string
+  sources: string[]
+  language: string
+  packageName: string
+  namespace: string
+  targetSdk: number
+  optOutEdgeToEdge: boolean
+  applicationClass: string | null
+  launcher: { name: string; targetClass: string }
+}
+
+export interface ComposeAndroidPins {
+  ui: string
+  foundation: string
+  runtime: string
+  material3: string
+}
+
+const ANDROID_NS = 'android:'
+const MAIN = 'android.intent.action.MAIN'
+const LAUNCHER = 'android.intent.category.LAUNCHER'
+const PLUGINS = new Set([
+  'com.android.application',
+  'org.jetbrains.kotlin.android',
+  'org.jetbrains.kotlin.plugin.compose',
+])
+// the closure Peach links. compose artifacts must match its Android pins; the
+// activity, lifecycle and savedstate artifacts are Peach's platform actuals.
+const PLATFORM_GROUPS = new Set([
+  'androidx.activity',
+  'androidx.lifecycle',
+  'androidx.savedstate',
+])
+const COMPOSE_PIN: Record<string, keyof ComposeAndroidPins> = {
+  'androidx.compose.ui': 'ui',
+  'androidx.compose.foundation': 'foundation',
+  'androidx.compose.runtime': 'runtime',
+  'androidx.compose.material3': 'material3',
+}
+
+interface XmlElement {
+  name: string
+  attributes: Record<string, string>
+  children: XmlElement[]
+}
+
+// manifest XML: elements and quoted attributes; comments, declarations and
+// text are skipped
+function parseXml(text: string, file: string): XmlElement {
+  const root: XmlElement = { name: '#document', attributes: {}, children: [] }
+  const stack = [root]
+  const body = text.replace(/<!--[\s\S]*?-->/g, '').replace(/<\?[\s\S]*?\?>/g, '')
+  for (const match of body.matchAll(
+    /<(\/?)([\w:.-]+)((?:\s+[\w:.-]+\s*=\s*"[^"]*")*)\s*(\/?)>/g,
+  )) {
+    const [, closing, name, rawAttributes, selfClosing] = match
+    if (!name) continue
+    if (closing) {
+      const open = stack.pop()
+      if (open?.name !== name)
+        throw new Error(`${file}: </${name}> closes <${open?.name}>`)
+      continue
+    }
+    const attributes: Record<string, string> = {}
+    for (const [, key, value] of (rawAttributes ?? '').matchAll(
+      /([\w:.-]+)\s*=\s*"([^"]*)"/g,
+    ))
+      if (key)
+        attributes[key] = (value ?? '').replaceAll('&quot;', '"').replaceAll('&amp;', '&')
+    const element: XmlElement = { name, attributes, children: [] }
+    stack.at(-1)?.children.push(element)
+    if (!selfClosing) stack.push(element)
+  }
+  if (stack.length !== 1)
+    throw new Error(`${file}: <${stack.at(-1)?.name}> is never closed`)
+  return root
+}
+
+function readGradle(dir: string): { file: string; text: string } | null {
+  for (const name of ['build.gradle.kts', 'build.gradle']) {
+    const file = path.join(dir, name)
+    if (fs.existsSync(file)) return { file, text: fs.readFileSync(file, 'utf8') }
+  }
+  return null
+}
+
+function lineOf(text: string, index: number): number {
+  return text.slice(0, index).split('\n').length
+}
+
+// a literal `name = value` or `name value`; any other assignment of the name
+// is a value Peach cannot read without running Gradle
+function gradleLiteral(
+  gradle: { file: string; text: string },
+  name: string,
+  pattern: string,
+): string | null {
+  const literal = new RegExp(`\\b${name}\\s*=?\\s*(${pattern})\\s*$`, 'm').exec(
+    gradle.text,
+  )
+  if (literal?.[1]) return literal[1].replace(/^"|"$/g, '')
+  const any = new RegExp(`\\b${name}\\b\\s*=?\\s*\\S`, 'm').exec(gradle.text)
+  if (any)
+    throw new Error(
+      `${gradle.file}:${lineOf(gradle.text, any.index)}: ${name} must be a literal for peach kotlin`,
+    )
+  return null
+}
+
+function kotlinPluginVersion(
+  projectDir: string,
+  moduleGradle: { file: string; text: string },
+) {
+  const sources = [readGradle(projectDir), moduleGradle].filter((value) => value !== null)
+  for (const gradle of sources) {
+    const match =
+      /id\(\s*"org\.jetbrains\.kotlin\.android"\s*\)\s*version\s*"([^"]+)"/.exec(
+        gradle.text,
+      ) ?? /kotlin\(\s*"android"\s*\)\s*version\s*"([^"]+)"/.exec(gradle.text)
+    if (match?.[1]) return match[1]
+  }
+  const catalog = path.join(projectDir, 'gradle', 'libs.versions.toml')
+  if (fs.existsSync(catalog)) {
+    const match = /^kotlin\s*=\s*"([^"]+)"/m.exec(fs.readFileSync(catalog, 'utf8'))
+    if (match?.[1]) return match[1]
+  }
+  throw new Error(
+    `${projectDir} declares no literal org.jetbrains.kotlin.android plugin version`,
+  )
+}
+
+function checkModuleGradle(
+  gradle: { file: string; text: string },
+  pins: ComposeAndroidPins,
+) {
+  const at = (index: number) => `${gradle.file}:${lineOf(gradle.text, index)}`
+  for (const match of gradle.text.matchAll(
+    /\bid\(\s*"([^"]+)"\s*\)|\bkotlin\(\s*"([^"]+)"\s*\)/g,
+  )) {
+    const plugin = match[1] ?? `org.jetbrains.kotlin.${match[2]}`
+    if (!PLUGINS.has(plugin))
+      throw new Error(
+        `${at(match.index)}: plugin ${plugin} is not supported by peach kotlin`,
+      )
+  }
+  for (const block of gradle.text.matchAll(/\bdependencies\s*\{/g)) {
+    // the block runs to its matching brace, on one line or many; every
+    // statement in it must be a literal dependency Peach can check
+    const start = block.index + block[0].length
+    let depth = 1
+    let end = start
+    for (; end < gradle.text.length && depth > 0; end++) {
+      if (gradle.text[end] === '{') depth++
+      else if (gradle.text[end] === '}') depth--
+    }
+    if (depth > 0) throw new Error(`${at(block.index)}: dependencies block never closes`)
+    const body = gradle.text.slice(start, end - 1)
+    for (const statement of body.matchAll(/[^\n;]+/g)) {
+      const text = statement[0].replace(/\/\/.*$/, '').trim()
+      if (!text) continue
+      const where = at(start + statement.index)
+      const call = /^(\w+)\s*\(\s*(.*?)\s*\)$/.exec(text)
+      if (!call) throw new Error(`${where}: ${text} is not a literal dependency`)
+      const [, configuration = '', value = ''] = call
+      if (/^(test|androidTest|debug|release)/.test(configuration)) continue
+      const coordinate = /^["']([^"':]+):([^"':]+):([^"']+)["']$/.exec(value)
+      if (!coordinate)
+        throw new Error(`${where}: ${value} is not a literal group:artifact:version`)
+      const [, group = '', artifact, version] = coordinate
+      const pin = COMPOSE_PIN[group]
+      if (pin) {
+        if (version !== pins[pin])
+          throw new Error(
+            `${where}: ${group}:${artifact}:${version} differs from Peach's Compose ${pin} ${pins[pin]}`,
+          )
+      } else if (!PLATFORM_GROUPS.has(group))
+        throw new Error(`${where}: ${group}:${artifact} is not in Peach's Kotlin closure`)
+    }
+  }
+}
+
+function themeOptsOut(moduleDir: string, theme: string | undefined): boolean {
+  const name = theme?.startsWith('@style/') ? theme.slice('@style/'.length) : null
+  if (!name) return false
+  const values = path.join(moduleDir, 'src/main/res/values')
+  if (!fs.existsSync(values)) throw new Error(`${theme} names no style in ${values}`)
+  for (const file of fs.readdirSync(values).filter((entry) => entry.endsWith('.xml'))) {
+    const full = path.join(values, file)
+    const resources = parseXml(fs.readFileSync(full, 'utf8'), full)
+    for (const style of resources.children.flatMap((element) => element.children)) {
+      if (style.name !== 'style' || style.attributes.name !== name) continue
+      if (style.attributes.parent?.startsWith('@style/'))
+        throw new Error(
+          `${full}: style ${name} inherits an app style; peach kotlin reads one level`,
+        )
+      const items = fs
+        .readFileSync(full, 'utf8')
+        .match(new RegExp(`<style\\b[^>]*name="${name}"[\\s\\S]*?</style>`))?.[0]
+      return /<item\s+name="android:windowOptOutEdgeToEdgeEnforcement"\s*>\s*true\s*</.test(
+        items ?? '',
+      )
+    }
+  }
+  throw new Error(`${theme} names no style in ${values}`)
+}
+
+function enabled(element: XmlElement): boolean {
+  return element.attributes[`${ANDROID_NS}enabled`] !== 'false'
+}
+
+// PackageParser: a component with an intent filter must declare
+// android:exported from target SDK 31 and defaults to exported below it.
+// launching from the home screen or the shell needs an exported component.
+function exported(element: XmlElement, targetSdk: number, manifestFile: string): boolean {
+  const value = element.attributes[`${ANDROID_NS}exported`]
+  if (value !== undefined) return value === 'true'
+  const filtered = element.children.some((child) => child.name === 'intent-filter')
+  if (filtered && targetSdk >= 31)
+    throw new Error(
+      `${manifestFile}: ${element.attributes[`${ANDROID_NS}name`]} has an intent filter and no android:exported, which fails to install from target SDK 31`,
+    )
+  return filtered
+}
+
+function isLauncher(element: XmlElement): boolean {
+  return element.children.some(
+    (filter) =>
+      filter.name === 'intent-filter' &&
+      filter.children.some(
+        (child) =>
+          child.name === 'action' && child.attributes[`${ANDROID_NS}name`] === MAIN,
+      ) &&
+      filter.children.some(
+        (child) =>
+          child.name === 'category' && child.attributes[`${ANDROID_NS}name`] === LAUNCHER,
+      ),
+  )
+}
+
+export function readKotlinApp(
+  moduleArg: string,
+  options: { activity?: string; pins: ComposeAndroidPins },
+): KotlinAppProject {
+  const moduleDir = fs.realpathSync(path.resolve(moduleArg))
+  const manifestFile = path.join(moduleDir, 'src/main/AndroidManifest.xml')
+  if (!fs.existsSync(manifestFile))
+    throw new Error(
+      `${moduleDir} is not an Android app module: no src/main/AndroidManifest.xml`,
+    )
+  let projectDir = moduleDir
+  while (
+    !['settings.gradle.kts', 'settings.gradle'].some((name) =>
+      fs.existsSync(path.join(projectDir, name)),
+    )
+  ) {
+    const parent = path.dirname(projectDir)
+    if (parent === projectDir)
+      throw new Error(`${moduleDir} has no settings.gradle above it`)
+    projectDir = parent
+  }
+  const gradle = readGradle(moduleDir)
+  if (!gradle) throw new Error(`${moduleDir} has no build.gradle`)
+  checkModuleGradle(gradle, options.pins)
+  const namespace = gradleLiteral(gradle, 'namespace', '"[\\w.]+"')
+  const applicationId = gradleLiteral(gradle, 'applicationId', '"[\\w.]+"')
+  const targetSdk = Number(gradleLiteral(gradle, 'targetSdk(?:Version)?', '\\d+'))
+  if (!Number.isInteger(targetSdk) || targetSdk <= 0)
+    throw new Error(`${gradle.file}: declares no literal targetSdk`)
+  const kotlin = kotlinPluginVersion(projectDir, gradle)
+  const language = /^(\d+)\.(\d+)/.exec(kotlin)?.slice(1, 3).join('.')
+  if (!language)
+    throw new Error(`Kotlin plugin version ${kotlin} names no language version`)
+
+  const manifest = parseXml(fs.readFileSync(manifestFile, 'utf8'), manifestFile)
+  const root = manifest.children.find((element) => element.name === 'manifest')
+  const application = root?.children.find((element) => element.name === 'application')
+  if (!root || !application) throw new Error(`${manifestFile} has no <application>`)
+  const base = namespace ?? root.attributes.package
+  if (!base)
+    throw new Error(`${gradle.file}: declares no namespace and the manifest no package`)
+  const className = (name: string) =>
+    name.startsWith('.') ? base + name : name.includes('.') ? name : `${base}.${name}`
+  if (application.attributes[`${ANDROID_NS}appComponentFactory`])
+    throw new Error(
+      `${manifestFile}: android:appComponentFactory is not supported by peach kotlin`,
+    )
+  for (const element of application.children) {
+    if (element.name === 'provider')
+      throw new Error(
+        `${manifestFile}: <provider ${element.attributes[`${ANDROID_NS}name`]}> is not supported by peach kotlin`,
+      )
+    if (element.attributes[`${ANDROID_NS}process`])
+      throw new Error(
+        `${manifestFile}: android:process on ${element.attributes[`${ANDROID_NS}name`]} is not supported by peach kotlin`,
+      )
+  }
+  if (application.attributes[`${ANDROID_NS}process`])
+    throw new Error(
+      `${manifestFile}: android:process on <application> is not supported by peach kotlin`,
+    )
+  for (const [key, value] of [
+    ...[root, application].flatMap((element) => Object.entries(element.attributes)),
+  ])
+    if (value.includes('${'))
+      throw new Error(`${manifestFile}: ${key}="${value}" is a Gradle placeholder`)
+
+  const activities = application.children.filter((element) => element.name === 'activity')
+  const components = application.children.filter(
+    (element) => element.name === 'activity' || element.name === 'activity-alias',
+  )
+  const target = (element: XmlElement) => {
+    const name = element.attributes[`${ANDROID_NS}name`]
+    if (!name) throw new Error(`${manifestFile}: <${element.name}> has no android:name`)
+    if (element.name === 'activity') return className(name)
+    const targetName = element.attributes[`${ANDROID_NS}targetActivity`]
+    const activity = activities.find(
+      (candidate) =>
+        className(candidate.attributes[`${ANDROID_NS}name`] ?? '') ===
+        className(targetName ?? ''),
+    )
+    if (!targetName || !activity)
+      throw new Error(
+        `${manifestFile}: activity-alias ${name} targets no declared activity`,
+      )
+    if (!enabled(activity)) return null
+    return className(targetName)
+  }
+  const applicationEnabled = enabled(application)
+  let chosen: XmlElement | undefined
+  if (options.activity) {
+    const wanted = className(options.activity)
+    chosen = components.find(
+      (element) => className(element.attributes[`${ANDROID_NS}name`] ?? '') === wanted,
+    )
+    if (!chosen)
+      throw new Error(`Error type 3: Activity class {${base}/${wanted}} does not exist.`)
+    if (!applicationEnabled || !enabled(chosen) || target(chosen) === null)
+      throw new Error(`Activity {${base}/${wanted}} is disabled`)
+    if (!exported(chosen, targetSdk, manifestFile))
+      throw new Error(`Permission Denial: ${base}/${wanted} is not exported`)
+  } else {
+    const launchers = applicationEnabled
+      ? components.filter(
+          (element) =>
+            enabled(element) &&
+            isLauncher(element) &&
+            exported(element, targetSdk, manifestFile) &&
+            target(element) !== null,
+        )
+      : []
+    if (launchers.length === 0)
+      throw new Error(
+        `${manifestFile}: no enabled activity resolves the MAIN/LAUNCHER intent`,
+      )
+    if (launchers.length > 1)
+      throw new Error(
+        `${manifestFile}: ${launchers.map((element) => element.attributes[`${ANDROID_NS}name`]).join(', ')} all resolve the launcher intent; pick one with --activity`,
+      )
+    chosen = launchers[0]
+  }
+  const launcherName = className(chosen?.attributes[`${ANDROID_NS}name`] ?? '')
+  const targetClass = chosen ? target(chosen) : null
+  if (!targetClass) throw new Error(`${launcherName} targets a disabled activity`)
+  const themeOwner = activities.find(
+    (element) => className(element.attributes[`${ANDROID_NS}name`] ?? '') === targetClass,
+  )
+  const theme =
+    themeOwner?.attributes[`${ANDROID_NS}theme`] ??
+    application.attributes[`${ANDROID_NS}theme`]
+  const applicationName = application.attributes[`${ANDROID_NS}name`]
+
+  const sources: string[] = []
+  for (const set of ['java', 'kotlin']) {
+    const dir = path.join(moduleDir, 'src/main', set)
+    if (!fs.existsSync(dir)) continue
+    const walk = (current: string) => {
+      for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+        const full = path.join(current, entry.name)
+        if (entry.isDirectory()) walk(full)
+        else if (entry.name.endsWith('.java'))
+          throw new Error(`${full}: Java sources are not supported by peach kotlin`)
+        else if (entry.name.endsWith('.kt')) sources.push(full)
+      }
+    }
+    walk(dir)
+  }
+  if (sources.length === 0)
+    throw new Error(`${moduleDir}/src/main holds no Kotlin sources`)
+  return {
+    projectDir,
+    moduleDir,
+    sources: sources.sort(),
+    language,
+    packageName: applicationId ?? base,
+    namespace: base,
+    targetSdk,
+    optOutEdgeToEdge: themeOptsOut(moduleDir, theme),
+    applicationClass: applicationName ? className(applicationName) : null,
+    launcher: { name: launcherName, targetClass },
+  }
+}

package/src/kotlin-host.ts

@@ -12,6 +12,7 @@ import path from 'node:path'
 import { promisify } from 'node:util'
 import { rnxHomeDir } from './home-paths'
 import { isRecord } from './is-record'
+import type { KotlinAppProject } from './kotlin-app'
 import type { ServerResponse } from 'node:http'
 
 const run = promisify(execFile)
@@ -192,11 +193,16 @@ const SKIP_DIRS = new Set([
   'scripts',
 ])
 
-export function kotlinSources(root: string): string[] {
+// peach's own platform sources live in package dirs such as `android`, so
+// they walk with no skip set
+export function kotlinSources(
+  root: string,
+  skip: ReadonlySet<string> = SKIP_DIRS,
+): string[] {
   const sources: string[] = []
   const walk = (dir: string) => {
     for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (entry.name.startsWith('.') || SKIP_DIRS.has(entry.name)) continue
+      if (entry.name.startsWith('.') || skip.has(entry.name)) continue
       const full = path.join(dir, entry.name)
       if (entry.isDirectory()) walk(full)
       else if (entry.isFile() && entry.name.endsWith('.kt')) sources.push(full)
@@ -256,7 +262,7 @@ function entrySource(ids: string[]): string {
   ].join('\n')
 }
 
-const BUILD_FORMAT = 4
+const BUILD_FORMAT = 7
 const builds = new Map<string, Promise<KotlinArtifact>>()
 
 function buildsDir(): string {
@@ -278,18 +284,105 @@ 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'] = viewsSource(viewIds)
+  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')))
+  return compileKotlin(
+    { root, toolchain, language, sources, generated, shims, usesCompose },
+    origin,
+  )
+}
+
+function viewsSource(viewIds: string[]): string {
+  return [
+    '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')
+}
+
+// a pure Kotlin app: its module's sources, the Android platform actuals and
+// the compose host, with an entry that cold-starts the resolved launcher
+export async function kotlinAppArtifact(
+  app: KotlinAppProject,
+  moduleRoot: string,
+  origin: string,
+): Promise<KotlinArtifact> {
+  const toolchain = readToolchain(moduleRoot)
+  const kotlinString = (value: string) => JSON.stringify(value).replaceAll('$', '\\$')
+  const generated: Record<string, string> = {
+    'PeachEntry.kt': entrySource([]),
+    'PeachViews.kt': viewsSource([]),
+    'PeachAppEntry.kt': [
+      '@file:OptIn(kotlin.js.ExperimentalJsExport::class)',
+      '',
+      '@JsExport',
+      'fun peachAppMount(density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,',
+      '    regular: String, medium: String, bold: String, statusBar: Int, navigationBar: Int,',
+      '    invalidate: (Boolean) -> Unit): String = dev.peach.app.peachStartApp(',
+      '    dev.peach.app.PeachAppSpec(',
+      `        android.content.ComponentName(${kotlinString(app.packageName)}, ${kotlinString(app.launcher.name)}),`,
+      `        android.content.ComponentName(${kotlinString(app.packageName)}, ${kotlinString(app.launcher.targetClass)}),`,
+      `        ${app.targetSdk}, ${app.optOutEdgeToEdge},`,
+      `        { ${app.applicationClass ?? 'android.app.Application'}() },`,
+      `        { ${app.launcher.targetClass}() },`,
+      '    ),',
+      '    density, fontScale, locale, backend, stencilBits, regular, medium, bold, statusBar, navigationBar, invalidate,',
+      ')',
+      '',
+    ].join('\n'),
+  }
+  const shims = [
+    ...kotlinSources(path.join(moduleRoot, 'Sources')),
+    ...kotlinSources(path.join(moduleRoot, 'ComposeSources')),
+    ...kotlinSources(path.join(moduleRoot, 'AppSources'), new Set()),
+  ]
+  return compileKotlin(
+    {
+      root: app.projectDir,
+      toolchain,
+      language: app.language,
+      sources: app.sources,
+      generated,
+      shims,
+      usesCompose: true,
+    },
+    origin,
+  )
+}
+
+async function compileKotlin(
+  input: {
+    root: string
+    toolchain: KotlinToolchain
+    language: string
+    sources: string[]
+    generated: Record<string, string>
+    shims: string[]
+    usesCompose: boolean
+  },
+  origin: string,
+): Promise<KotlinArtifact> {
+  const { root, toolchain, language, sources, generated, shims, usesCompose } = input
   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 }))
@@ -424,25 +517,46 @@ export async function kotlinArtifact(
         `kotlin compile failed:\n${output.trim() || (error instanceof Error ? error.message : String(error))}`,
       )
     }
-    // Kotlin's loader picks node when `process.release.name` says so; the
-    // Peach tenant defines a react native `process` with no release, so that
-    // read throws before the browser branch runs. the loader keeps its
-    // browser path when the read is optional.
-    let patched = 0
-    for (const file of fs.readdirSync(path.join(work, 'js'))) {
-      if (!file.endsWith('.mjs')) continue
-      const target = path.join(work, 'js', file)
-      const text = fs.readFileSync(target, 'utf8')
-      const next = text.replaceAll('process.release.name', 'process.release?.name')
-      if (next !== text) {
-        patched++
-        fs.writeFileSync(target, next)
+    // the Kotlin module shares the tenant's react native globals, which a
+    // Kotlin process never sees. Kotlin's loader picks node when
+    // `process.release.name` says so, and react native's `process` has no
+    // release, so the read becomes optional. kotlinx-coroutines dispatches
+    // through `window.postMessage(msg, '*')` when it finds a window with
+    // `addEventListener`, which the tenant's window has and a worker cannot
+    // honor, so the module takes the setTimeout dispatcher a worker gets.
+    const seams: Array<[string, string]> = [
+      ['process.release.name', 'process.release?.name'],
+    ]
+    const js = fs
+      .readdirSync(path.join(work, 'js'))
+      .filter((file) => file.endsWith('.mjs'))
+    if (
+      js.some((file) =>
+        fs
+          .readFileSync(path.join(work, 'js', file), 'utf8')
+          .includes("'kotlinx.coroutines."),
+      )
+    )
+      seams.push([
+        "(typeof(window) !== 'undefined' && window != null && typeof(window.addEventListener) === 'function') ? window : null",
+        'null',
+      ])
+    for (const [from, to] of seams) {
+      let patched = 0
+      for (const file of js) {
+        const target = path.join(work, 'js', file)
+        const text = fs.readFileSync(target, 'utf8')
+        const next = text.replaceAll(from, to)
+        if (next !== text) {
+          patched++
+          fs.writeFileSync(target, next)
+        }
       }
+      if (patched === 0)
+        throw new Error(
+          `kotlin output no longer contains ${from}; recheck how it detects its host in Peach`,
+        )
     }
-    if (patched === 0)
-      throw new Error(
-        'kotlin loader no longer reads process.release.name; recheck its node detection in Peach',
-      )
     fs.renameSync(work, out)
     return artifact
   })().finally(() => builds.delete(hash))
@@ -502,13 +616,22 @@ export function peachKotlinModuleRoot(root: string): string {
 export async function serveKotlinRequest(
   pathname: string,
   res: ServerResponse,
-  app: { root: string; moduleRoot: string; origin: string; hmrPath: string },
+  app: {
+    root: string
+    moduleRoot: string
+    origin: string
+    hmrPath: string
+    // a pure Kotlin app (peach kotlin); otherwise the root's imported sources
+    project?: KotlinAppProject
+  },
 ): Promise<boolean> {
   if (serveKotlinArtifact(pathname, res)) return true
   if (pathname !== KOTLIN_PACKAGE_PATH) return false
   res.setHeader('access-control-allow-origin', '*')
   try {
-    const artifact = await kotlinArtifact(app.root, app.moduleRoot, app.origin)
+    const artifact = app.project
+      ? await kotlinAppArtifact(app.project, app.moduleRoot, app.origin)
+      : await kotlinArtifact(app.root, app.moduleRoot, app.origin)
     res.setHeader('content-type', 'application/json')
     res.end(JSON.stringify({ ...artifact, hmrPath: app.hmrPath }))
   } catch (error) {

package/src/swift-compile.ts

@@ -529,6 +529,11 @@ export function writeSwiftProject(
 ): void {
   const targets = compileTargets(input)
   const files = new Map<string, string>()
+  // swiftpm plans a build root's build once and reuses the plan until a
+  // manifest changes, so a file added to the module would never compile
+  // there (RAN: a broken new UIKitCore file built "complete" in 0.1s). the
+  // module's file list in the manifest replans exactly when it changes.
+  const moduleFiles = `\n// sootsim-swift files ${createHash('sha256').update(swiftModuleInputFiles(moduleRoot).join('\n')).digest('hex').slice(0, 16)}\n`
   if (targets.length === 0) {
     for (const [file, contents] of Object.entries(input.files)) {
       if (file === 'Package.swift') continue
@@ -552,7 +557,7 @@ export function writeSwiftProject(
         .replace(product, `${product}\n        ${ONE_PRODUCT},`)
         .replace(flags, `${flags}${ONE_IMPLICIT_FLAGS}`)
     }
-    files.set(path.join(layout.root, 'Package.swift'), manifest)
+    files.set(path.join(layout.root, 'Package.swift'), manifest + moduleFiles)
   } else {
     for (const [file, contents] of Object.entries(input.files)) {
       if (file === 'Package.swift') continue
@@ -582,7 +587,7 @@ export function writeSwiftProject(
         siblings: swiftSiblingDependencies(input.files, targets),
         moduleRoot,
         oneModule: input.oneModule,
-      }),
+      }) + moduleFiles,
     )
   }
   syncSwiftTree(layout.root, files)