peachsim 0.1.649 → 0.1.650

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 = 5
+const BUILD_FORMAT = 7
 const builds = new Map<string, Promise<KotlinArtifact>>()
 
 function buildsDir(): string {
@@ -291,21 +297,92 @@ export async function kotlinArtifact(
     generated[`OneNativeSource_${id}.kt`] = renderKotlinSourceGlue(id, contract).source
   }
   generated['PeachEntry.kt'] = entrySource(ids)
-  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')
-  }
+  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 }))
@@ -440,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))
@@ -518,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)