peachsim 0.1.939 → 0.1.1399

package/src/kotlin-host.ts

@@ -9,7 +9,9 @@ import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { promisify } from 'node:util'
+import { parse } from 'acorn'
 import { rnxHomeDir } from './home-paths'
 import { isRecord } from './is-record'
 import {
@@ -18,6 +20,7 @@ import {
   type ViewModelClass,
 } from './kotlin-view-models'
 import type { DayNight, DrawableFile } from './android-drawables'
+import type { ExpoKotlinModules } from './expo-kotlin-host'
 import type { KotlinAppProject, KotlinWindowTheme } from './kotlin-app'
 import type { ServerResponse } from 'node:http'
 
@@ -226,9 +229,9 @@ export function kotlinSources(
 // are a table here.
 function entrySource(ids: string[]): string {
   return [
+    'import android.os.Build',
     'import kotlin.js.JsAny',
     'import kotlin.js.Promise',
-    'import kotlinx.coroutines.CoroutineStart',
     'import kotlinx.coroutines.Dispatchers',
     'import kotlinx.coroutines.GlobalScope',
     'import kotlinx.coroutines.promise',
@@ -242,10 +245,14 @@ function entrySource(ids: string[]): string {
     '    else -> null',
     '}?.also { instances[packageName] = it }',
     '',
+    '@OptIn(kotlin.js.ExperimentalJsExport::class)',
+    '@JsExport',
+    'fun peachSetAndroidBuildInfo(model: String, release: String) = Build.setDevice(model, release)',
+    '',
     '@OptIn(kotlin.js.ExperimentalJsExport::class, kotlin.js.ExperimentalWasmJsInterop::class, kotlinx.coroutines.DelicateCoroutinesApi::class)',
     '@JsExport',
     'fun peachNativeCall(module: String, method: String, argsJson: String, contractHash: String): Promise<JsAny?> =',
-    '    GlobalScope.promise(Dispatchers.Main, CoroutineStart.UNDISPATCHED) {',
+    '    GlobalScope.promise(Dispatchers.Main) {',
     '        val reply = JSONObject()',
     '        try {',
     '            val packageName = module.substringBefore(\'.\', "")',
@@ -268,7 +275,7 @@ function entrySource(ids: string[]): string {
   ].join('\n')
 }
 
-const BUILD_FORMAT = 8
+const BUILD_FORMAT = 14
 const builds = new Map<string, Promise<KotlinArtifact>>()
 
 function buildsDir(): string {
@@ -304,7 +311,7 @@ export async function kotlinArtifact(
   }
   generated['PeachEntry.kt'] = entrySource(ids)
   if (viewIds.length > 0) generated['PeachViews.kt'] = viewsSource(viewIds)
-  const shims = kotlinSources(path.join(moduleRoot, 'Sources')).filter(
+  const shims = kotlinSources(path.join(moduleRoot, 'Sources'), new Set()).filter(
     (file) => usesCompose || !file.endsWith('/OneNativeSourceViewDispatch.kt'),
   )
   if (viewIds.length > 0)
@@ -315,6 +322,379 @@ export async function kotlinArtifact(
   )
 }
 
+interface ExpoField {
+  name: string
+  key: string
+  required: boolean
+  mutable: boolean
+  hidden: boolean
+  initializer: [number, number] | null
+}
+
+interface ExpoTypesFile {
+  file: string
+  package: string
+  records: { name: string; hidden: boolean; fields: ExpoField[] }[]
+  enums: {
+    name: string
+    hidden: boolean
+    fields: number
+    parameter: string | null
+    hiddenParameter: boolean
+  }[]
+  // Expo views; compose views also name their props class
+  views: { name: string; hidden: boolean; props: string }[]
+  // ComposeProps classes with their public member properties
+  props: { name: string; hidden: boolean; states: string[] }[]
+}
+
+function readExpoField(value: unknown): ExpoField {
+  if (
+    !isRecord(value) ||
+    typeof value.name !== 'string' ||
+    typeof value.key !== 'string' ||
+    typeof value.required !== 'boolean' ||
+    typeof value.mutable !== 'boolean' ||
+    typeof value.hidden !== 'boolean'
+  )
+    throw new Error('expo-types printed an invalid field')
+  const range = value.initializer
+  if (
+    range !== null &&
+    (!Array.isArray(range) ||
+      range.length !== 2 ||
+      typeof range[0] !== 'number' ||
+      typeof range[1] !== 'number')
+  )
+    throw new Error('expo-types printed an invalid initializer range')
+  return {
+    name: value.name,
+    key: value.key,
+    required: value.required,
+    mutable: value.mutable,
+    hidden: value.hidden,
+    initializer: range === null ? null : [range[0], range[1]],
+  }
+}
+
+function readExpoTypes(output: string): ExpoTypesFile[] {
+  return output
+    .split('\n')
+    .filter((line) => line.startsWith('{'))
+    .map((line) => {
+      const row: unknown = JSON.parse(line)
+      if (
+        !isRecord(row) ||
+        typeof row.file !== 'string' ||
+        typeof row.package !== 'string' ||
+        !Array.isArray(row.records) ||
+        !Array.isArray(row.enums) ||
+        !Array.isArray(row.views) ||
+        !Array.isArray(row.props)
+      )
+        throw new Error('expo-types printed an invalid file')
+      return {
+        file: row.file,
+        package: row.package,
+        records: row.records.map((record: unknown) => {
+          if (
+            !isRecord(record) ||
+            typeof record.name !== 'string' ||
+            typeof record.hidden !== 'boolean' ||
+            !Array.isArray(record.fields)
+          )
+            throw new Error('expo-types printed an invalid record')
+          return {
+            name: record.name,
+            hidden: record.hidden,
+            fields: record.fields.map(readExpoField),
+          }
+        }),
+        enums: row.enums.map((entry: unknown) => {
+          if (
+            !isRecord(entry) ||
+            typeof entry.name !== 'string' ||
+            typeof entry.hidden !== 'boolean' ||
+            typeof entry.fields !== 'number' ||
+            (entry.parameter !== null && typeof entry.parameter !== 'string') ||
+            typeof entry.hiddenParameter !== 'boolean'
+          )
+            throw new Error('expo-types printed an invalid enum')
+          return {
+            name: entry.name,
+            hidden: entry.hidden,
+            fields: entry.fields,
+            parameter: entry.parameter,
+            hiddenParameter: entry.hiddenParameter,
+          }
+        }),
+        views: row.views.map((view: unknown) => {
+          if (
+            !isRecord(view) ||
+            typeof view.name !== 'string' ||
+            typeof view.hidden !== 'boolean' ||
+            typeof view.props !== 'string'
+          )
+            throw new Error('expo-types printed an invalid view')
+          return { name: view.name, hidden: view.hidden, props: view.props }
+        }),
+        props: row.props.map((entry: unknown) => {
+          if (
+            !isRecord(entry) ||
+            typeof entry.name !== 'string' ||
+            typeof entry.hidden !== 'boolean' ||
+            !Array.isArray(entry.states) ||
+            !entry.states.every((state: unknown) => typeof state === 'string')
+          )
+            throw new Error('expo-types printed invalid compose props')
+          return { name: entry.name, hidden: entry.hidden, states: entry.states }
+        }),
+      }
+    })
+}
+
+const expoTypeScans = new Map<string, Promise<ExpoTypesFile[]>>()
+
+// the records, enums, compose views and compose props the module sources
+// declare, read by Kotlin's own parser; sources that name none skip the JVM start
+function scanExpoTypes(
+  toolchain: KotlinToolchain,
+  script: string,
+  sources: string[],
+): Promise<ExpoTypesFile[]> {
+  const candidates = sources.filter((file) =>
+    /\bRecord\b|\benum\s+class\b|\bExpoComposeView\b|\bExpoView\b|\bComposeProps\b/.test(
+      fs.readFileSync(file, 'utf8'),
+    ),
+  )
+  if (candidates.length === 0) return Promise.resolve([])
+  const digest = createHash('sha256')
+  for (const file of [script, ...candidates])
+    digest.update(`${file}\0${fs.readFileSync(file, 'utf8')}\0`)
+  const key = digest.digest('hex')
+  let scan = expoTypeScans.get(key)
+  if (!scan) {
+    scan = (async () => {
+      const { kotlinc } = await ensureToolchain(toolchain)
+      const { stdout } = await run(
+        path.join(path.dirname(kotlinc), 'kotlinc'),
+        [
+          '-cp',
+          path.resolve(path.dirname(kotlinc), '../lib/kotlin-compiler.jar'),
+          '-script',
+          script,
+          ...candidates,
+        ],
+        { maxBuffer: 16 * 1024 * 1024 },
+      )
+      return readExpoTypes(stdout)
+    })().catch((error: unknown) => {
+      expoTypeScans.delete(key)
+      throw error
+    })
+    expoTypeScans.set(key, scan)
+  }
+  return scan
+}
+
+// upstream converts records and enums by reflection; Kotlin/Wasm has none, so
+// each @Field initializer and constructor default reads the incoming value
+// through PeachExpoTypes.initial, and each package registers its types
+function expoTypeSources(files: ExpoTypesFile[]): {
+  generated: Record<string, string>
+  origins: Record<string, string>
+  registrations: string[]
+} {
+  const generated: Record<string, string> = {}
+  const origins: Record<string, string> = {}
+  const registrations: string[] = []
+  files.forEach((file, index) => {
+    const edits: { range: [number, number]; owner: string; field: ExpoField }[] = []
+    const calls: string[] = []
+    for (const record of file.records) {
+      const fields: string[] = []
+      for (const field of record.fields) {
+        if (field.initializer)
+          edits.push({ range: field.initializer, owner: record.name, field })
+        if (field.hidden) {
+          if (!field.initializer)
+            throw new Error(
+              `${file.file}: @Field ${record.name}.${field.name} is private and has no initializer, which Peach cannot set`,
+            )
+          continue
+        }
+        const name = literal(field.key)
+        const read = `{ record: ${record.name} -> record.${field.name} }`
+        const write =
+          field.mutable && !field.initializer
+            ? `{ record, value -> record.${field.name} = value }`
+            : 'null'
+        fields.push(
+          `        dev.peach.expo.PeachExpoTypes.field(${name}, ${field.required}, ${read}, ${write}),`,
+        )
+      }
+      if (record.hidden) continue
+      calls.push(
+        [
+          `    dev.peach.expo.PeachExpoTypes.record(${record.name}::class, ${literal(file.package ? `${file.package}.${record.name}` : record.name)}, { ${record.name}() }, listOf(`,
+          ...fields,
+          '    ))',
+        ].join('\n'),
+      )
+    }
+    for (const entry of file.enums) {
+      if (entry.hidden) continue
+      if (entry.hiddenParameter)
+        throw new Error(
+          `${file.file}: enum ${entry.name} keeps its value in a private property, which Peach cannot read`,
+        )
+      const value = entry.fields === 1 ? `{ it.${entry.parameter} }` : 'null'
+      calls.push(
+        `    dev.peach.expo.PeachExpoTypes.enum(${entry.name}::class, enumValues<${entry.name}>(), ${entry.fields}, ${entry.parameter === null ? 'null' : literal(entry.parameter)}, ${value})`,
+      )
+    }
+    // a view's constructor and its props' states are named where the source
+    // declares them, so they resolve through the source's own imports
+    const views = [
+      ...file.views
+        .filter((view) => !view.hidden)
+        .map(
+          (view) =>
+            `    dev.peach.expo.PeachExpoTypes.view(${view.name}::class, ${view.props ? `${view.props}::class` : 'null'}) { context, appContext -> ${view.name}(context, appContext) }`,
+        ),
+      ...file.props
+        .filter((entry) => !entry.hidden)
+        .map((entry) =>
+          [
+            `    dev.peach.expo.PeachExpoTypes.composeProps(${entry.name}::class, listOf(`,
+            ...entry.states.map(
+              (state) =>
+                `        dev.peach.expo.PeachExpoCompose.prop(${literal(state)}) { props: ${entry.name} -> props.${state} },`,
+            ),
+            '    ))',
+          ].join('\n'),
+        ),
+    ]
+    if (edits.length > 0 || views.length > 0) {
+      let text = fs.readFileSync(file.file, 'utf8').replaceAll('\r\n', '\n')
+      for (const { range, owner, field } of edits.sort((a, b) => b.range[0] - a.range[0]))
+        text = `${text.slice(0, range[0])}dev.peach.expo.PeachExpoTypes.initial(${owner}::class, ${literal(field.key)}, ${field.required}) { ${text.slice(range[0], range[1])} }${text.slice(range[1])}`
+      if (views.length > 0) {
+        text = [
+          text,
+          '',
+          `internal fun peachExpoViews${index}() {`,
+          ...views,
+          '}',
+          '',
+        ].join('\n')
+        registrations.push(
+          `${file.package ? `${file.package}.` : ''}peachExpoViews${index}()`,
+        )
+      }
+      const name = `PeachExpoSource_${index}_${path.basename(file.file)}`
+      generated[name] = text
+      origins[name] = file.file
+    }
+    if (calls.length === 0) return
+    generated[`PeachExpoTypes_${index}.kt`] = [
+      ...(file.package ? [`package ${file.package}`, ''] : []),
+      `internal fun peachExpoTypes${index}() {`,
+      ...calls,
+      '}',
+      '',
+    ].join('\n')
+    registrations.push(
+      `${file.package ? `${file.package}.` : ''}peachExpoTypes${index}()`,
+    )
+  })
+  return { generated, origins, registrations }
+}
+
+// local Expo modules: their android Kotlin, the shared actuals and the
+// expo-modules-core DSL port, with an entry registering the classes Expo's
+// autolinker names, as its generated ExpoModulesPackageList does
+export async function expoKotlinArtifact(
+  root: string,
+  moduleRoot: string,
+  origin: string,
+  modules: ExpoKotlinModules,
+): Promise<KotlinArtifact & { compose: boolean }> {
+  const toolchain = readToolchain(moduleRoot)
+  const language = appKotlinLanguage(root)
+  const scanned = await scanExpoTypes(
+    toolchain,
+    path.join(moduleRoot, 'tools/expo-types.main.kts'),
+    modules.sources,
+  )
+  // every exported view uses the existing native scene presenter. modules
+  // without views or compose imports do not link that renderer.
+  const usesCompose =
+    scanned.some((file) => file.views.length > 0) ||
+    modules.sources.some((file) =>
+      /\bandroidx\.compose\./.test(fs.readFileSync(file, 'utf8')),
+    )
+  const shims = [
+    ...kotlinSources(path.join(moduleRoot, 'Sources'), new Set()).filter(
+      (file) => usesCompose || !file.endsWith('/OneNativeSourceViewDispatch.kt'),
+    ),
+    ...kotlinSources(path.join(moduleRoot, 'ExpoSources'), new Set()),
+    ...kotlinSources(path.join(moduleRoot, 'AndroidViewSources'), new Set()),
+    ...(usesCompose
+      ? [
+          ...kotlinSources(path.join(moduleRoot, 'ComposeSources')),
+          ...kotlinSources(path.join(moduleRoot, 'ExpoComposeSources'), new Set()),
+        ]
+      : []),
+  ]
+  const types = expoTypeSources(scanned)
+  const rewritten = new Set(Object.values(types.origins))
+  const entry = [
+    '@file:OptIn(kotlin.js.ExperimentalJsExport::class)',
+    '',
+    'import dev.peach.expo.PeachExpoRuntime',
+    '',
+    'private val registered by lazy {',
+    ...types.registrations.map((call) => `    ${call}`),
+    '    PeachExpoRuntime.register(listOf(',
+    ...modules.modules.map(
+      ({ classifier, name }) =>
+        `        { ${classifier}() } to ${name === null ? 'null' : JSON.stringify(name)},`,
+    ),
+    '    ))',
+    '}',
+    '',
+    '@JsExport fun peachExpoListen(notify: () -> Unit) {',
+    '    registered',
+    '    PeachExpoRuntime.listen(notify)',
+    '}',
+    '',
+    '@JsExport fun peachExpoCall(payload: String): String {',
+    '    registered',
+    '    return PeachExpoRuntime.dispatch(payload)',
+    '}',
+    '',
+  ].join('\n')
+  const artifact = await compileKotlin(
+    {
+      root,
+      toolchain,
+      language,
+      sources: modules.sources.filter((file) => !rewritten.has(file)),
+      generated: {
+        ...types.generated,
+        'PeachExpoEntry.kt': entry,
+        ...(usesCompose ? { 'PeachViews.kt': viewsSource([]) } : {}),
+      },
+      origins: types.origins,
+      shims,
+      usesCompose,
+    },
+    origin,
+  )
+  return { ...artifact, compose: usesCompose }
+}
+
 function viewsSource(viewIds: string[]): string {
   return [
     'import dev.onejs.one.OneNativeSourceViewDispatch',
@@ -377,8 +757,8 @@ export async function kotlinAppArtifact(
       'import androidx.lifecycle.createSavedStateHandle',
       '',
       '@JsExport',
-      'fun peachAppMount(density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,',
-      '    regular: String, medium: String, bold: String, insets: String, night: Boolean,',
+      'fun peachAppMount(density: Float, fontScale: Float, locale: String,',
+      '    font: String, insets: String, night: Boolean,',
       '    invalidate: (Boolean) -> Unit): String = dev.peach.app.peachStartApp(',
       '    dev.peach.app.PeachAppSpec(',
       `        android.content.ComponentName(${literal(app.packageName)}, ${literal(app.launcher.name)}),`,
@@ -392,8 +772,9 @@ export async function kotlinAppArtifact(
       '        androidx.lifecycle.viewmodel.viewModelFactory {',
       ...viewModels.map(viewModelInitializer),
       '        },',
+      `        ${app.predictiveBack},`,
       '    ),',
-      '    density, fontScale, locale, backend, stencilBits, regular, medium, bold, insets, night, invalidate,',
+      '    density, fontScale, locale, font, insets, night, invalidate,',
       ')',
       '',
       '@JsExport',
@@ -406,7 +787,10 @@ export async function kotlinAppArtifact(
       'fun peachAppNight(night: Boolean) = dev.peach.app.peachAppNight(night)',
       '',
       '@JsExport',
-      'fun peachAppIme(bottom: Int) = dev.peach.app.peachAppIme(bottom)',
+      'fun peachAppIme(bottom: Int, visible: Boolean) = dev.peach.app.peachAppIme(bottom, visible)',
+      '',
+      '@JsExport',
+      'fun peachAppInsets(insets: String, visibleSystemBars: Int) = dev.peach.app.peachAppInsets(insets, visibleSystemBars)',
       '',
     ].join('\n')
   const generated: Record<string, string> = {
@@ -416,9 +800,10 @@ export async function kotlinAppArtifact(
     ...appResourceSources(app),
   }
   const shims = [
-    ...kotlinSources(path.join(moduleRoot, 'Sources')),
+    ...kotlinSources(path.join(moduleRoot, 'Sources'), new Set()),
     ...kotlinSources(path.join(moduleRoot, 'ComposeSources')),
     ...kotlinSources(path.join(moduleRoot, 'AppSources'), new Set()),
+    ...kotlinSources(path.join(moduleRoot, 'AndroidViewSources'), new Set()),
   ]
   return compileKotlin(
     {
@@ -637,6 +1022,8 @@ async function compileKotlin(
     language: string
     sources: string[]
     generated: Record<string, string>
+    // the app source a generated file rewrites, which its diagnostics name
+    origins?: Record<string, string>
     shims: string[]
     usesCompose: boolean
     // a generated file that names the app's view models: rendered empty for a
@@ -655,6 +1042,7 @@ async function compileKotlin(
     language,
     sources,
     generated,
+    origins = {},
     shims,
     usesCompose,
     viewModels,
@@ -701,6 +1089,7 @@ async function compileKotlin(
     const common = [
       // the full upstream Compose graph exceeds kotlinc's 512 mib default heap.
       '-J-Xmx2g',
+      '-Xallow-kotlin-package',
       '-Xwasm-target=js',
       '-libraries',
       libraries.join(path.delimiter),
@@ -771,16 +1160,56 @@ async function compileKotlin(
         ],
         { maxBuffer: 16 * 1024 * 1024 },
       )
-      if (usesCompose)
+      if (usesCompose) {
         await run('unzip', [
           '-q',
           '-j',
           composeRuntime,
           'skiko.mjs',
-          'skiko.wasm',
           '-d',
           path.join(work, 'js'),
         ])
+        // each artifact references the tenant's one upstream callback namespace.
+        // the pinned loader's binding declarations define its public ABI.
+        const skikoPath = path.join(work, 'js', 'skiko.mjs')
+        const upstream = parse(fs.readFileSync(skikoPath, 'utf8'), {
+          ecmaVersion: 'latest',
+          sourceType: 'module',
+        })
+        const bindings: string[] = []
+        for (const statement of upstream.body) {
+          if (
+            statement.type !== 'ExportNamedDeclaration' ||
+            statement.declaration?.type !== 'VariableDeclaration' ||
+            statement.declaration.kind !== 'let'
+          )
+            continue
+          for (const binding of statement.declaration.declarations) {
+            if (binding.id.type !== 'Identifier')
+              throw new Error('Skiko binding must have one exported identifier')
+            bindings.push(binding.id.name)
+          }
+        }
+        if (bindings.length !== 967) throw new Error('pinned Skiko binding count changed')
+        const names = [
+          'awaitSkiko',
+          'loadedWasm',
+          'registerSkikoWasmReadyCallback',
+          'skikoApi',
+          'GL',
+          ...bindings,
+        ]
+        fs.writeFileSync(
+          skikoPath,
+          [
+            'const runtime = globalThis.__peachKotlinSkiko;',
+            "if (!runtime) throw Error('Kotlin tenant runtime was not installed before guest evaluation');",
+            `for (const name of ${JSON.stringify(names)}) if (!(name in runtime)) throw Error('Kotlin tenant runtime has no ' + name);`,
+            ...names.map((name) => `export const ${name} = runtime.${name};`),
+            '',
+          ].join('\n'),
+        )
+      }
       // kotlin's npm externals remain bare imports after linking. publish the
       // exact upstream ES modules beside the generated loader for workers.
       if (usesCompose) {
@@ -815,9 +1244,11 @@ async function compileKotlin(
       }
     } catch (error) {
       fs.rmSync(work, { recursive: true, force: true })
-      const output = isRecord(error)
+      let output = isRecord(error)
         ? `${String(error.stderr ?? '')}${String(error.stdout ?? '')}`
         : ''
+      for (const [name, source] of Object.entries(origins))
+        output = output.replaceAll(path.join(generatedDir, name), source)
       throw new Error(
         `kotlin compile failed:\n${output.trim() || (error instanceof Error ? error.message : String(error))}`,
       )
@@ -882,6 +1313,22 @@ const CONTENT_TYPES: Record<string, string> = {
   '.wasm': 'application/wasm',
 }
 
+// a compiled module's loader, import object and wasm, which a release bundle
+// carries beside its javascript
+export function kotlinArtifactFiles(
+  hash: string,
+): { name: string; bytes: Buffer; contentType: string }[] {
+  const dir = path.join(buildsDir(), hash, 'js')
+  return fs
+    .readdirSync(dir)
+    .sort()
+    .map((name) => {
+      const contentType = CONTENT_TYPES[path.extname(name)]
+      if (!contentType) throw new Error(`unexpected kotlin artifact file ${name}`)
+      return { name, bytes: fs.readFileSync(path.join(dir, name)), contentType }
+    })
+}
+
 // serves a compiled module's loader, import object and wasm, cross-origin
 // to the simulator that imports them
 export function serveKotlinArtifact(pathname: string, res: ServerResponse): boolean {
@@ -915,13 +1362,10 @@ export function serveKotlinArtifact(pathname: string, res: ServerResponse): bool
 
 const KOTLIN_PACKAGE_PATH = '/__peach/kotlin-package'
 
-// peachsim's own Kotlin module (toolchain pins and shims) beside the app's
-// installed peachsim
-export function peachKotlinModuleRoot(root: string): string {
-  const peachsimPackage = createRequire(path.join(root, 'package.json')).resolve(
-    'peachsim/package.json',
-  )
-  return path.join(path.dirname(peachsimPackage), 'kotlin')
+// peachsim's own Kotlin module (toolchain pins and shims), found from this
+// file (src/ or dist-lib/ → ..) so apps need no direct peachsim dependency
+export function peachKotlinModuleRoot(): string {
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'kotlin')
 }
 
 // answers one /__peach/kotlin* request: the app's compiled module description,