peachsim 0.1.578 → 0.1.579

package/src/swift-submit.ts

@@ -22,6 +22,18 @@
 
 export const SWIFT_COMPILE_PATH = '/api/swift-compile'
 
+/**
+ * what an artifact needs from the mount that instantiates it. every request
+ * carries the sender's, and the compile host refuses one that is not its own,
+ * so a page still running an older mount (an open tab across a deploy, an
+ * older peachsim) is told to reload instead of receiving an artifact it cannot
+ * run. bump it with any change that makes an artifact require something new of
+ * its host. 1: the host fills Sources/PeachICU's reserved icu data and provides
+ * `peach.icu_data_v1` (`packages/sootsim-swift/src/icuData.ts`). a request
+ * without one comes from before this field, a host that is 0.
+ */
+export const SWIFT_HOST_ABI = 1
+
 export interface SwiftImageUpload {
   /** the raster file picked for the asset (has the extension). */
   file: string
@@ -43,6 +55,12 @@ export type SwiftCompileOutcome =
       status: 'published'
       artifactUrl: string
       hash: string
+      /**
+       * the icu common data the artifact reserves, root-relative like the
+       * artifact url: one immutable blob per toolchain, so every app and every
+       * edit shares the browser's one copy.
+       */
+      icuUrl: string
       /**
        * the published photo rasters, bundle asset name to absolute url.
        * root-relative like the artifact url; the caller resolves it against
@@ -50,6 +68,8 @@ export type SwiftCompileOutcome =
        * when the request packs no images.
        */
       imageUrls?: Record<string, string>
+      /** the callable swift modules the sources export; absent when none. */
+      native?: SwiftNativeModules
     }
   /**
    * the build is running; poll the same source set again. One build is tens of
@@ -64,6 +84,44 @@ export type SwiftCompileOutcome =
 
 const POLL_INTERVAL_MS = 1500
 
+/**
+ * the callable surface of a swift package whose sources declare `RNXModule`
+ * classes, as vxrn's native-source contract describes it: `one typegen`
+ * writes it beside a One package, and the compile host derives it for a
+ * project. the dispatch glue compiled into the artifact checks `hash` on every
+ * call, so a module keyed by this descriptor can never call an older build.
+ */
+export interface SwiftNativeModules {
+  packageId: string
+  hash: string
+  /** source file to the module names it declares. */
+  files: Record<string, string[]>
+  /** module name to its method names. */
+  modules: Record<string, string[]>
+  /** the files that also declare the package's `@main` view. */
+  defaultViewFiles: string[]
+}
+
+/** what one imported source file exports from a package's native modules. */
+export function swiftNativeEntry(
+  native: SwiftNativeModules,
+  file: string,
+): {
+  packageId: string
+  contractHash: string
+  modules: Record<string, string[]>
+  defaultView: boolean
+} {
+  return {
+    packageId: native.packageId,
+    contractHash: native.hash,
+    modules: Object.fromEntries(
+      (native.files[file] ?? []).map((name) => [name, native.modules[name] ?? []]),
+    ),
+    defaultView: native.defaultViewFiles.includes(file),
+  }
+}
+
 export interface SwiftCompileContext {
   /**
    * the compile credential: the signed preview token `BundlerSessionRuntime`
@@ -72,6 +130,12 @@ export interface SwiftCompileContext {
    * project with `.swift` sources cannot be compiled.
    */
   assetReadToken?: string
+  /**
+   * an `Authorization` header value in place of `assetReadToken`, for a
+   * caller outside Contrast: peachsim's dev server sends the `peach login`
+   * session or a `sk_rnx_` key.
+   */
+  authorization?: string
   /**
    * absolute origin of the app serving `/api/swift-compile`. The browser
    * worker omits it and posts its own origin; a node caller that is not that
@@ -87,14 +151,16 @@ export type SwiftCompileSubmit = (work: {
   /** the photo rasters to publish; absent means the project packs none. */
   images?: Record<string, SwiftImageUpload>
   entry: string
+  /** the id a One package's native modules register under; absent means `App`. */
+  packageId?: string
 }) => Promise<SwiftCompileOutcome>
 
 /** the HTTP submitter, shared by the browser worker and the node build. */
 export function httpSwiftCompileSubmit(
   context: SwiftCompileContext,
 ): SwiftCompileSubmit | undefined {
-  const { assetReadToken, endpoint } = context
-  if (!assetReadToken) return undefined
+  const { assetReadToken, authorization, endpoint } = context
+  if (!assetReadToken && !authorization) return undefined
   const url = endpoint
     ? `${endpoint.replace(/\/+$/, '')}${SWIFT_COMPILE_PATH}`
     : SWIFT_COMPILE_PATH
@@ -104,8 +170,15 @@ export function httpSwiftCompileSubmit(
     try {
       response = await fetch(url, {
         method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify({ ...work, token: assetReadToken }),
+        headers: {
+          'content-type': 'application/json',
+          ...(authorization ? { authorization } : {}),
+        },
+        body: JSON.stringify({
+          ...work,
+          hostAbi: SWIFT_HOST_ABI,
+          ...(assetReadToken ? { token: assetReadToken } : {}),
+        }),
       })
     } catch (error) {
       throw new Error(
@@ -127,8 +200,12 @@ export interface SwiftModuleAddress {
   /** absolute url the tenant fetches the wasm from. */
   url: string
   hash: string
+  /** absolute url of the icu common data the artifact reserves. */
+  icuUrl: string
   /** bundle asset name to absolute photo url, when the pack publishes any. */
   imageUrls?: Record<string, string>
+  /** the callable swift modules the artifact links, when the sources declare any. */
+  native?: SwiftNativeModules
 }
 
 /** the service answers root-relative; the caller that knows the origin resolves. */
@@ -159,6 +236,7 @@ export async function compileSwiftProject(
     resources?: Record<string, string>
     images?: Record<string, SwiftImageUpload>
     entry: string
+    packageId?: string
   },
   origin: string,
 ): Promise<SwiftModuleAddress> {
@@ -169,9 +247,11 @@ export async function compileSwiftProject(
         return {
           url: new URL(outcome.artifactUrl, origin).href,
           hash: outcome.hash,
+          icuUrl: new URL(outcome.icuUrl, origin).href,
           ...(outcome.imageUrls === undefined
             ? {}
             : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }),
+          ...(outcome.native === undefined ? {} : { native: outcome.native }),
         }
       case 'compiling':
         await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))

package/src/swift.ts

@@ -2,6 +2,8 @@
 // implementation lives beside the toolchain it drives, in sootsim-swift.
 export {
   createSwiftEntry,
+  callSwiftModule,
+  useSwiftHost,
   type SwiftEntryOptions,
   type SwiftModuleOptions,
 } from '../../sootsim-swift/src/mount.tsx'

package/src/vite-plugin-kotlin.ts

@@ -0,0 +1,376 @@
+// Peach's Kotlin host for One apps on an Android device: every Kotlin source
+// the app holds compiles, with One's generated dispatch glue, into one
+// Kotlin/Wasm module, as prebuild compiles them all into the one app process.
+// the vite plugin loads this on the first /__peach/kotlin request, so an app
+// with no Kotlin never evaluates it.
+
+import { execFile } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { promisify } from 'node:util'
+import { rnxHomeDir } from './home-paths'
+import { isRecord } from './is-record'
+import type { ServerResponse } from 'node:http'
+
+const run = promisify(execFile)
+
+export const KOTLIN_ARTIFACT_PREFIX = '/__peach/kotlin-artifact/'
+
+interface Download {
+  url: string
+  sha256: string
+}
+
+interface KotlinToolchain {
+  compiler: Download & { version: string }
+  libraries: (Download & { name: string })[]
+}
+
+export interface KotlinArtifact {
+  // the module the seam imports; it loads its wasm beside it
+  url: string
+  hash: string
+}
+
+function readToolchain(moduleRoot: string): KotlinToolchain {
+  const parsed: unknown = JSON.parse(
+    fs.readFileSync(path.join(moduleRoot, 'toolchain.json'), 'utf8'),
+  )
+  const download = (value: unknown): Download => {
+    if (
+      !isRecord(value) ||
+      typeof value.url !== 'string' ||
+      typeof value.sha256 !== 'string'
+    )
+      throw new Error(
+        'peachsim kotlin/toolchain.json names a download without url and sha256',
+      )
+    return { url: value.url, sha256: value.sha256 }
+  }
+  if (!isRecord(parsed) || !isRecord(parsed.compiler) || !Array.isArray(parsed.libraries))
+    throw new Error('peachsim kotlin/toolchain.json has no compiler and libraries')
+  const version = parsed.compiler.version
+  if (typeof version !== 'string')
+    throw new Error('peachsim kotlin/toolchain.json has no compiler version')
+  return {
+    compiler: { ...download(parsed.compiler), version },
+    libraries: parsed.libraries.map((library) => {
+      if (!isRecord(library) || typeof library.name !== 'string')
+        throw new Error('peachsim kotlin/toolchain.json names a library without a name')
+      return { ...download(library), name: library.name }
+    }),
+  }
+}
+
+function kotlinHome(): string {
+  return path.join(rnxHomeDir(), 'kotlin')
+}
+
+async function fetchVerified(download: Download, target: string): Promise<void> {
+  if (fs.existsSync(target)) return
+  const response = await fetch(download.url)
+  if (!response.ok) throw new Error(`${download.url} answered ${response.status}`)
+  const bytes = Buffer.from(await response.arrayBuffer())
+  const digest = createHash('sha256').update(bytes).digest('hex')
+  if (digest !== download.sha256)
+    throw new Error(`${download.url} has sha256 ${digest}, expected ${download.sha256}`)
+  fs.mkdirSync(path.dirname(target), { recursive: true })
+  const partial = `${target}.${process.pid}.partial`
+  fs.writeFileSync(partial, bytes)
+  fs.renameSync(partial, target)
+}
+
+let toolchainReady: Promise<{ kotlinc: string; libraries: string[] }> | undefined
+
+// the pinned compiler and the coroutines klibs, fetched once and checked
+// against toolchain.json
+function ensureToolchain(
+  toolchain: KotlinToolchain,
+): Promise<{ kotlinc: string; libraries: string[] }> {
+  toolchainReady ??= (async () => {
+    const dir = path.join(kotlinHome(), toolchain.compiler.version)
+    const kotlinc = path.join(dir, 'kotlinc', 'bin', 'kotlinc-wasm')
+    if (!fs.existsSync(kotlinc)) {
+      const zip = path.join(dir, 'kotlin-compiler.zip')
+      await fetchVerified(toolchain.compiler, zip)
+      await run('unzip', ['-q', '-o', zip, '-d', dir])
+      fs.rmSync(zip)
+    }
+    // kotlinc runs on the JVM an android build already needs; it finds it
+    // through JAVA_HOME or PATH, as gradle does
+    const java = process.env.JAVA_HOME
+      ? path.join(process.env.JAVA_HOME, 'bin', 'java')
+      : 'java'
+    await run(java, ['-version']).catch(() => {
+      throw new Error(
+        `Kotlin in Peach compiles with kotlinc, which needs a Java runtime (17 or newer, as android builds use); ${process.env.JAVA_HOME ? `JAVA_HOME ${process.env.JAVA_HOME} has none` : 'set JAVA_HOME or put java on PATH'}`,
+      )
+    })
+    const libraries = [path.join(dir, 'kotlinc', 'lib', 'kotlin-stdlib-wasm-js.klib')]
+    for (const library of toolchain.libraries) {
+      const target = path.join(dir, library.name)
+      await fetchVerified(library, target)
+      libraries.push(target)
+    }
+    return { kotlinc, libraries }
+  })().catch((error: unknown) => {
+    toolchainReady = undefined
+    throw error
+  })
+  return toolchainReady
+}
+
+// the kotlin language the device compiles the app with: react native's
+// android gradle build pins it, and the wasm compile holds the app to it
+function appKotlinLanguage(root: string): string {
+  const reactNative = path.dirname(
+    createRequire(path.join(root, 'package.json')).resolve('react-native/package.json'),
+  )
+  const versions = fs.readFileSync(
+    path.join(reactNative, 'gradle', 'libs.versions.toml'),
+    'utf8',
+  )
+  const match = /^kotlin\s*=\s*"(\d+)\.(\d+)/m.exec(versions)
+  if (!match)
+    throw new Error(`${reactNative}/gradle/libs.versions.toml names no kotlin version`)
+  return `${match[1]}.${match[2]}`
+}
+
+// the app's Kotlin sources, walked as One's android prebuild walks them into
+// the app (its swift walk covers package dirs with a narrower skip set)
+const SKIP_DIRS = new Set([
+  'node_modules',
+  'ios',
+  'android',
+  'dist',
+  'types',
+  'build',
+  'tests',
+  '__tests__',
+  'scripts',
+])
+
+export function kotlinSources(root: string): 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
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) walk(full)
+      else if (entry.isFile() && entry.name.endsWith('.kt')) sources.push(full)
+    }
+  }
+  walk(root)
+  return sources.sort()
+}
+
+// the process's entry: One's android host (HybridOneNativeModules) finds a
+// package's dispatch by its class name, checks the contract hash, and runs
+// the call as a coroutine on the main dispatcher; a thrown error rejects as
+// "<module>.<method>: <message>", and a missing class names itself, as
+// ClassNotFoundException does. wasm has no reflection, so the class names
+// are a table here.
+function entrySource(ids: string[]): string {
+  return [
+    'import kotlin.js.JsAny',
+    'import kotlin.js.Promise',
+    'import kotlinx.coroutines.CoroutineStart',
+    'import kotlinx.coroutines.Dispatchers',
+    'import kotlinx.coroutines.GlobalScope',
+    'import kotlinx.coroutines.promise',
+    'import dev.onejs.one.OneNativeSourceDispatch',
+    'import org.json.JSONObject',
+    '',
+    'private val instances = mutableMapOf<String, OneNativeSourceDispatch>()',
+    '',
+    'private fun dispatcher(packageName: String): OneNativeSourceDispatch? = instances[packageName] ?: when (packageName) {',
+    ...ids.map((id) => `    ${JSON.stringify(id)} -> OneNativeSource_${id}()`),
+    '    else -> null',
+    '}?.also { instances[packageName] = it }',
+    '',
+    '@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) {',
+    '        val reply = JSONObject()',
+    '        try {',
+    '            val packageName = module.substringBefore(\'.\', "")',
+    '            val dispatch = dispatcher(packageName)',
+    "            if (packageName.isEmpty() || !module.contains('.')) {",
+    '                reply.put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "invalid module $module")',
+    '            } else if (dispatch == null) {',
+    '                reply.put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "$module.$method: OneNativeSource_$packageName")',
+    '            } else if (dispatch.contractHash != contractHash) {',
+    '                reply.put("ok", false).put("code", "E_NATIVE_SOURCE_REBUILD").put("error", "native module $module changed; rebuild the app")',
+    '            } else {',
+    '                reply.put("ok", true).put("value", dispatch.call(module, method, argsJson))',
+    '            }',
+    '        } catch (error: Exception) {',
+    '            reply.put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "$module.$method: ${error.message}")',
+    '        }',
+    '        reply.toString().toJsString()',
+    '    }',
+    '',
+  ].join('\n')
+}
+
+const BUILD_FORMAT = 1
+const builds = new Map<string, Promise<KotlinArtifact>>()
+
+function buildsDir(): string {
+  return path.join(kotlinHome(), 'builds')
+}
+
+// compiles the app's Kotlin sources, keyed by everything that goes into the
+// module, and answers where the seam imports it from
+export async function kotlinArtifact(
+  root: string,
+  moduleRoot: string,
+  origin: string,
+): Promise<KotlinArtifact> {
+  const { kotlinSourceId, nativeSourceContract, renderKotlinSourceGlue } =
+    await import('vxrn/native-source-contract')
+  const toolchain = readToolchain(moduleRoot)
+  const language = appKotlinLanguage(root)
+  const sources = kotlinSources(root)
+  if (sources.length === 0) throw new Error(`${root} holds no Kotlin sources`)
+  const generated: Record<string, string> = {}
+  const ids: string[] = []
+  for (const file of sources) {
+    const contract = nativeSourceContract(file, fs.readFileSync(file, 'utf8'))
+    if (contract.modules.length === 0) continue
+    const id = kotlinSourceId(root, file)
+    ids.push(id)
+    generated[`OneNativeSource_${id}.kt`] = renderKotlinSourceGlue(id, contract).source
+  }
+  generated['PeachEntry.kt'] = entrySource(ids)
+  const shims = kotlinSources(path.join(moduleRoot, 'Sources'))
+  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 }))
+  for (const file of [...shims, ...sources])
+    digest.update(`${path.relative(root, file)}\0${fs.readFileSync(file, 'utf8')}\0`)
+  for (const [name, text] of Object.entries(generated))
+    digest.update(`${name}\0${text}\0`)
+  const hash = digest.digest('hex').slice(0, 24)
+  const artifact = { url: `${origin}${KOTLIN_ARTIFACT_PREFIX}${hash}/app.mjs`, hash }
+  const out = path.join(buildsDir(), hash)
+  if (fs.existsSync(path.join(out, 'js', 'app.wasm'))) return artifact
+  const pending = builds.get(hash)
+  if (pending) return pending
+  const build = (async () => {
+    const { kotlinc, libraries } = await ensureToolchain(toolchain)
+    fs.mkdirSync(buildsDir(), { recursive: true })
+    const work = fs.mkdtempSync(path.join(buildsDir(), `${hash}-`))
+    const generatedDir = path.join(work, 'generated')
+    fs.mkdirSync(generatedDir)
+    for (const [name, text] of Object.entries(generated))
+      fs.writeFileSync(path.join(generatedDir, name), text)
+    const common = ['-Xwasm-target=js', '-libraries', libraries.join(path.delimiter)]
+    try {
+      await run(
+        kotlinc,
+        [
+          ...common,
+          '-language-version',
+          language,
+          '-api-version',
+          language,
+          '-nowarn',
+          '-nopack',
+          '-ir-output-dir',
+          path.join(work, 'klib'),
+          '-ir-output-name',
+          'app',
+          ...shims,
+          ...sources,
+          ...Object.keys(generated).map((name) => path.join(generatedDir, name)),
+        ],
+        { maxBuffer: 16 * 1024 * 1024 },
+      )
+      await run(
+        kotlinc,
+        [
+          ...common,
+          '-nowarn',
+          `-Xinclude=${path.join(work, 'klib')}`,
+          '-Xir-produce-js',
+          '-ir-output-dir',
+          path.join(work, 'js'),
+          '-ir-output-name',
+          'app',
+        ],
+        { maxBuffer: 16 * 1024 * 1024 },
+      )
+    } catch (error) {
+      fs.rmSync(work, { recursive: true, force: true })
+      const output = isRecord(error)
+        ? `${String(error.stderr ?? '')}${String(error.stdout ?? '')}`
+        : ''
+      throw new Error(
+        `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)
+      }
+    }
+    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))
+  builds.set(hash, build)
+  return build
+}
+
+const CONTENT_TYPES: Record<string, string> = {
+  '.mjs': 'text/javascript',
+  '.wasm': 'application/wasm',
+}
+
+// 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 {
+  if (!pathname.startsWith(KOTLIN_ARTIFACT_PREFIX)) return false
+  const [hash, file, ...rest] = pathname.slice(KOTLIN_ARTIFACT_PREFIX.length).split('/')
+  const type = file ? CONTENT_TYPES[path.extname(file)] : undefined
+  if (
+    !hash ||
+    !/^[0-9a-f]+$/.test(hash) ||
+    !file ||
+    rest.length > 0 ||
+    !type ||
+    file.includes('..')
+  ) {
+    res.statusCode = 404
+    res.end('not a kotlin artifact')
+    return true
+  }
+  const target = path.join(buildsDir(), hash, 'js', file)
+  if (!fs.existsSync(target)) {
+    res.statusCode = 404
+    res.end(`kotlin artifact ${hash}/${file} was not built`)
+    return true
+  }
+  res.setHeader('access-control-allow-origin', '*')
+  res.setHeader('content-type', type)
+  res.setHeader('cache-control', 'public, max-age=31536000, immutable')
+  res.end(fs.readFileSync(target))
+  return true
+}