peachsim 0.1.629 → 0.1.631

package/src/{vite-plugin-kotlin.ts → kotlin-host.ts}

@@ -1,8 +1,8 @@
 // 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.
+// any http host loads this on the first /__peach/kotlin request and answers
+// it with serveKotlinRequest, so an app with no Kotlin never evaluates it.
 
 import { execFile } from 'node:child_process'
 import { createHash } from 'node:crypto'
@@ -26,6 +26,14 @@ interface Download {
 interface KotlinToolchain {
   compiler: Download & { version: string }
   libraries: (Download & { name: string })[]
+  composeLibraries: (Download & { name: string })[]
+  composeRuntime: Download & { name: string }
+  composeJsLibraries: (Download & {
+    name: string
+    module: string
+    file: string
+    archiveEntry: string
+  })[]
 }
 
 export interface KotlinArtifact {
@@ -49,17 +57,49 @@ function readToolchain(moduleRoot: string): KotlinToolchain {
       )
     return { url: value.url, sha256: value.sha256 }
   }
-  if (!isRecord(parsed) || !isRecord(parsed.compiler) || !Array.isArray(parsed.libraries))
+  if (
+    !isRecord(parsed) ||
+    !isRecord(parsed.compiler) ||
+    !Array.isArray(parsed.libraries) ||
+    !Array.isArray(parsed.composeLibraries) ||
+    !Array.isArray(parsed.composeJsLibraries) ||
+    !isRecord(parsed.composeRuntime) ||
+    typeof parsed.composeRuntime.name !== 'string'
+  )
     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) => {
+  const libraries = (values: unknown[]) =>
+    values.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 }
+    })
+  return {
+    compiler: { ...download(parsed.compiler), version },
+    libraries: libraries(parsed.libraries),
+    composeLibraries: libraries(parsed.composeLibraries),
+    composeRuntime: {
+      ...download(parsed.composeRuntime),
+      name: parsed.composeRuntime.name,
+    },
+    composeJsLibraries: parsed.composeJsLibraries.map((library) => {
+      if (
+        !isRecord(library) ||
+        typeof library.name !== 'string' ||
+        typeof library.module !== 'string' ||
+        typeof library.file !== 'string' ||
+        typeof library.archiveEntry !== 'string'
+      )
+        throw new Error('peachsim kotlin/toolchain.json has an incomplete JS library')
+      return {
+        ...download(library),
+        name: library.name,
+        module: library.module,
+        file: library.file,
+        archiveEntry: library.archiveEntry,
+      }
     }),
   }
 }
@@ -207,7 +247,7 @@ function entrySource(ids: string[]): string {
     '            } else {',
     '                reply.put("ok", true).put("value", dispatch.call(module, method, argsJson))',
     '            }',
-    '        } catch (error: Exception) {',
+    '        } catch (error: Throwable) {',
     '            reply.put("ok", false).put("code", "E_NATIVE_SOURCE").put("error", "$module.$method: ${error.message}")',
     '        }',
     '        reply.toString().toJsString()',
@@ -216,7 +256,7 @@ function entrySource(ids: string[]): string {
   ].join('\n')
 }
 
-const BUILD_FORMAT = 1
+const BUILD_FORMAT = 4
 const builds = new Map<string, Promise<KotlinArtifact>>()
 
 function buildsDir(): string {
@@ -238,8 +278,11 @@ export async function kotlinArtifact(
   if (sources.length === 0) throw new Error(`${root} holds no Kotlin sources`)
   const generated: Record<string, string> = {}
   const ids: string[] = []
+  let usesCompose = false
   for (const file of sources) {
-    const contract = nativeSourceContract(file, fs.readFileSync(file, 'utf8'))
+    const source = fs.readFileSync(file, 'utf8')
+    if (/\bandroidx\.compose\./.test(source)) usesCompose = true
+    const contract = nativeSourceContract(file, source)
     if (contract.modules.length === 0) continue
     const id = kotlinSourceId(root, file)
     ids.push(id)
@@ -255,25 +298,54 @@ export async function kotlinArtifact(
   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 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)
+    const ready = await ensureToolchain(toolchain)
+    const { kotlinc } = ready
+    const libraries = [...ready.libraries]
+    const composeRuntime = path.join(
+      kotlinHome(),
+      toolchain.compiler.version,
+      toolchain.composeRuntime.name,
+    )
+    if (usesCompose) {
+      for (const library of toolchain.composeLibraries) {
+        const target = path.join(kotlinHome(), toolchain.compiler.version, library.name)
+        await fetchVerified(library, target)
+        libraries.push(target)
+      }
+      await fetchVerified(toolchain.composeRuntime, composeRuntime)
+    }
     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)]
+    const common = [
+      // the full upstream Compose graph exceeds kotlinc's 512 mib default heap.
+      '-J-Xmx2g',
+      '-Xwasm-target=js',
+      '-libraries',
+      libraries.join(path.delimiter),
+    ]
     try {
       await run(
         kotlinc,
         [
           ...common,
+          ...(usesCompose
+            ? [
+                `-Xplugin=${path.resolve(path.dirname(kotlinc), '../lib/compose-compiler-plugin.jar')}`,
+              ]
+            : []),
           '-language-version',
           language,
           '-api-version',
@@ -304,6 +376,45 @@ export async function kotlinArtifact(
         ],
         { maxBuffer: 16 * 1024 * 1024 },
       )
+      if (usesCompose)
+        await run('unzip', [
+          '-q',
+          '-j',
+          composeRuntime,
+          'skiko.mjs',
+          'skiko.wasm',
+          '-d',
+          path.join(work, 'js'),
+        ])
+      // kotlin's npm externals remain bare imports after linking. publish the
+      // exact upstream ES modules beside the generated loader for workers.
+      if (usesCompose) {
+        for (const library of toolchain.composeJsLibraries) {
+          for (const file of fs.readdirSync(path.join(work, 'js'))) {
+            if (!file.endsWith('.mjs')) continue
+            const target = path.join(work, 'js', file)
+            const source = fs.readFileSync(target, 'utf8')
+            let next = source
+            for (const quote of ["'", '"'])
+              next = next.replaceAll(
+                `from ${quote}${library.module}${quote}`,
+                `from ${quote}./${library.file}${quote}`,
+              )
+            if (next === source) continue
+            const archive = path.join(
+              kotlinHome(),
+              toolchain.compiler.version,
+              library.name,
+            )
+            await fetchVerified(library, archive)
+            const { stdout } = await run('tar', ['-xOf', archive, library.archiveEntry], {
+              maxBuffer: 16 * 1024 * 1024,
+            })
+            fs.writeFileSync(path.join(work, 'js', library.file), stdout)
+            fs.writeFileSync(target, next)
+          }
+        }
+      }
     } catch (error) {
       fs.rmSync(work, { recursive: true, force: true })
       const output = isRecord(error)
@@ -374,3 +485,35 @@ export function serveKotlinArtifact(pathname: string, res: ServerResponse): bool
   res.end(fs.readFileSync(target))
   return true
 }
+
+export 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')
+}
+
+// answers one /__peach/kotlin* request: the app's compiled module description,
+// then the files it names. false leaves the request to the host.
+export async function serveKotlinRequest(
+  pathname: string,
+  res: ServerResponse,
+  app: { root: string; moduleRoot: string; origin: string; hmrPath: string },
+): 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)
+    res.setHeader('content-type', 'application/json')
+    res.end(JSON.stringify({ ...artifact, hmrPath: app.hmrPath }))
+  } catch (error) {
+    res.statusCode = 500
+    res.end(error instanceof Error ? error.message : String(error))
+  }
+  return true
+}

package/src/menu.ts

@@ -81,6 +81,7 @@ export interface SootSimMenuState {
   developmentMode: boolean
   showBezels: boolean
   showTouches: boolean
+  slowAnimations: boolean
   showMenuBar: boolean
   showRail: boolean
   solidWindow: boolean
@@ -379,6 +380,16 @@ function debugMenu(state: SootSimMenuState): SootSimMenuDef {
   return {
     label: 'Debug',
     items: [
+      {
+        label: 'Slow Animations',
+        type: 'checkbox',
+        checked: state.slowAnimations,
+        accelerator: 'Shift+Alt+S',
+        action: 'toggle-slow-animations',
+        browserAccelerator: true,
+        showInShortcutDocs: true,
+      },
+      { type: 'separator' },
       // both toggles are stateful in the browser, where the open state lives
       // in the same document. electron's menu process cannot see it, so it
       // keeps the plain (stateless) items rather than a permanently

package/src/metro-plugin.ts

@@ -24,6 +24,7 @@ import {
   toRNXProductionBundleUrl,
   type RNXMetroModuleIdentityMetadata,
 } from './metro-production-bundle'
+import { readNativeFirebaseConfig } from './native-firebase-config'
 import {
   isRootRuntimeAssetPath,
   resolveRuntimeFilePath,
@@ -249,6 +250,23 @@ export function withRNX<T extends Record<string, unknown>>(config: T): T {
           return
         }
 
+        if ((req.url || '').split('?')[0] === '/__peach-native-firebase-config') {
+          try {
+            res.setHeader('Content-Type', 'application/json')
+            res.setHeader('Cache-Control', 'no-store')
+            res.setHeader('Access-Control-Allow-Origin', '*')
+            res.end(JSON.stringify(readNativeFirebaseConfig(cfgProjectRoot)))
+          } catch (error) {
+            res.statusCode = 400
+            res.end(
+              JSON.stringify({
+                error: error instanceof Error ? error.message : String(error),
+              }),
+            )
+          }
+          return
+        }
+
         const url = req.url || ''
         const pathname = url.split('?')[0]
 

package/src/native-app-identity.ts

@@ -0,0 +1,376 @@
+// generic native app identity: the values an installed iOS/Android binary
+// carries, read from the app's own native project (`Info.plist` resolved
+// against the Xcode Release build settings, or `android/app/build.gradle`), so
+// a simulator tenant reports the same identity the native Release build does.
+//
+// the values travel in a footer a bundle builder appends to the artifact — the
+// same transport shape the Metro module identity footer already uses — and the
+// tenant boot reads it from the bundle text before the guest evaluates, then
+// stores it on the tenant realm for the native app-information seams. a bundle
+// with no native identity footer leaves every seam exactly where it was.
+
+export type NativeAppIdentityPlatform = 'ios' | 'android'
+
+export interface NativeAppIdentity {
+  applicationName: string | null
+  appVersion: string
+  buildVersion: string
+  bundleIdentifier: string
+  platform: NativeAppIdentityPlatform
+}
+
+export type NativeAppIdentityFiles = Record<string, string>
+
+const NATIVE_APP_IDENTITY_PREFIX = 'globalThis.__sootsimNativeAppIdentity='
+const METRO_MODULE_PATHS_PREFIX = 'globalThis.__sootsimModulePaths='
+const APPLIED_NATIVE_APP_IDENTITY_KEY = '__sootsim_native_app_identity'
+
+interface NativeAppIdentityGlobals {
+  __sootsim_native_app_identity?: NativeAppIdentity | null
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function nonEmptyString(value: unknown): string | null {
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
+export function isNativeAppIdentity(value: unknown): value is NativeAppIdentity {
+  if (!isRecord(value)) return false
+  const platform = value.platform
+  if (platform !== 'ios' && platform !== 'android') return false
+  const applicationName = value.applicationName
+  if (applicationName !== null && nonEmptyString(applicationName) === null) return false
+  if (nonEmptyString(value.appVersion) === null) return false
+  if (nonEmptyString(value.bundleIdentifier) === null) return false
+  const buildVersion = nonEmptyString(value.buildVersion)
+  if (buildVersion === null) return false
+  if (platform === 'android' && !/^[1-9][0-9]*$/.test(buildVersion)) return false
+  return true
+}
+
+// read a host-supplied identity. absent/null clears it; a present value that is
+// neither is a contract violation the caller must not paper over.
+export function readNativeAppIdentity(value: unknown): NativeAppIdentity | null {
+  if (value === undefined || value === null) return null
+  if (!isNativeAppIdentity(value)) {
+    throw new Error('native app identity is malformed')
+  }
+  return {
+    applicationName: value.applicationName,
+    appVersion: value.appVersion,
+    buildVersion: value.buildVersion,
+    bundleIdentifier: value.bundleIdentifier,
+    platform: value.platform,
+  }
+}
+
+// the one realm store every seam reads. set by the tenant boot before the
+// guest evaluates, cleared on a boot without an identity so a previous app's
+// identity can never leak into the next load.
+export function applyNativeAppIdentity(identity: NativeAppIdentity | null): void {
+  const globals = globalThis as NativeAppIdentityGlobals
+  if (identity) globals.__sootsim_native_app_identity = identity
+  else delete globals.__sootsim_native_app_identity
+}
+
+export function getAppliedNativeAppIdentity(): NativeAppIdentity | null {
+  const value = (globalThis as NativeAppIdentityGlobals).__sootsim_native_app_identity
+  return isNativeAppIdentity(value) ? value : null
+}
+
+// one line, so the footer survives a bundle whose last statement is the Metro
+// module identity footer and can be found again by reading the text.
+export function createNativeAppIdentityFooter(identity: NativeAppIdentity): string {
+  const payload = JSON.stringify(identity)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/<\//g, '<\\/')
+  return `\n${NATIVE_APP_IDENTITY_PREFIX}${payload};`
+}
+
+function nativeAppIdentityFooterStart(source: string): number {
+  return source.lastIndexOf(`\n${NATIVE_APP_IDENTITY_PREFIX}`)
+}
+
+export function readNativeAppIdentityFooter(source: string): NativeAppIdentity | null {
+  const start = nativeAppIdentityFooterStart(source)
+  if (start < 0) return null
+  const lineEnd = source.indexOf('\n', start + 1)
+  const line = source.slice(start + 1, lineEnd < 0 ? undefined : lineEnd)
+  if (!line.endsWith(';')) {
+    throw new Error('native app identity footer is truncated')
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(line.slice(NATIVE_APP_IDENTITY_PREFIX.length, -1))
+  } catch {
+    throw new Error('native app identity footer is not valid JSON')
+  }
+  if (!isNativeAppIdentity(parsed)) {
+    throw new Error('native app identity footer is malformed')
+  }
+  return parsed
+}
+
+// remove the canonical footer from a bundle builder's input, returning the
+// identity it carried. the cloud artifact normalizer detaches before
+// minifying — a minifier rewrites the payload (`{key:…}`, joined statements) —
+// and reattaches the same canonical statement afterwards.
+export function detachNativeAppIdentityFooter(source: string): {
+  source: string
+  identity: NativeAppIdentity | null
+} {
+  const start = nativeAppIdentityFooterStart(source)
+  if (start < 0) return { source, identity: null }
+  const identity = readNativeAppIdentityFooter(source)
+  const lineEnd = source.indexOf('\n', start + 1)
+  const end = lineEnd < 0 ? source.length : lineEnd
+  return { source: source.slice(0, start) + source.slice(end), identity }
+}
+
+// insert the footer ahead of the Metro module identity footer when the bundle
+// carries one: readers of that contract slice the bundle at its start, and the
+// native identity has to stay in the text they hand to the guest. no footer
+// present (a development or legacy artifact) appends.
+export function insertNativeAppIdentityFooter(
+  source: string,
+  identity: NativeAppIdentity,
+): string {
+  const existing = nativeAppIdentityFooterStart(source)
+  const existingEnd =
+    existing < 0
+      ? -1
+      : source.includes('\n', existing + 1)
+        ? source.indexOf('\n', existing + 1)
+        : -1
+  const withoutExisting =
+    existing < 0
+      ? source
+      : source.slice(0, existing) +
+        source.slice(existingEnd < 0 ? source.length : existingEnd)
+  const moduleFooter = withoutExisting.lastIndexOf(`\n${METRO_MODULE_PATHS_PREFIX}`)
+  const footer = createNativeAppIdentityFooter(identity)
+  if (moduleFooter < 0) return withoutExisting + footer
+  return (
+    withoutExisting.slice(0, moduleFooter) + footer + withoutExisting.slice(moduleFooter)
+  )
+}
+
+// ── native project extraction ────────────────────────────────────────────────
+
+function plistString(plist: string, key: string): string | null {
+  const match = plist.match(new RegExp(`<key>${key}</key>\\s*<string>([^<]*)</string>`))
+  return match ? match[1].trim() : null
+}
+
+// Xcode build settings support `$(VAR)` references, so a plist value can only
+// be read against the settings of the configuration the binary ships with.
+// references recurse because a setting may itself reference another, and a
+// value whose reference cannot be fully resolved — an unknown variable or a
+// modifier this reader does not implement — is rejected rather than asserted.
+function resolveBuildSetting(
+  value: string,
+  settings: Record<string, string>,
+  depth = 0,
+): string | null {
+  if (depth > 8) return null
+  let unresolved = false
+  const resolved = value.replace(/\$\(([^()]+)\)/g, (_match, reference: string) => {
+    const separator = reference.indexOf(':')
+    if (separator >= 0) {
+      unresolved = true
+      return ''
+    }
+    const replacement = settings[reference]
+    if (replacement === undefined) {
+      unresolved = true
+      return ''
+    }
+    return replacement
+  })
+  if (unresolved) return null
+  if (resolved.includes('$(')) return resolveBuildSetting(resolved, settings, depth + 1)
+  return resolved
+}
+
+// an identity field is only usable when it is a real value: non-empty and free
+// of any unresolved build-setting syntax.
+function resolvedIdentityField(value: string | null): string | null {
+  const trimmed = value?.trim() ?? ''
+  if (!trimmed || trimmed.includes('$(')) return null
+  return trimmed
+}
+
+function identityFieldFrom(
+  settings: Record<string, string>,
+  raw: string | null,
+  fallbackSetting: string | undefined,
+): string | null {
+  if (raw !== null) return resolvedIdentityField(resolveBuildSetting(raw, settings))
+  return resolvedIdentityField(nonEmptyString(fallbackSetting ?? null))
+}
+
+function readBuildSettingsBlock(source: string, start: number): string {
+  // start is the index of `{`; walk to its matching close so nested arrays and
+  // dictionaries inside buildSettings stay part of the block.
+  let depth = 0
+  for (let index = start; index < source.length; index++) {
+    const character = source[index]
+    if (character === '{') depth++
+    else if (character === '}') {
+      depth--
+      if (depth === 0) return source.slice(start, index + 1)
+    }
+  }
+  return source.slice(start)
+}
+
+function parseBuildSettings(block: string): Record<string, string> {
+  const settings: Record<string, string> = {}
+  const matchPattern = /([A-Z0-9_]+) = ("(?:[^"\\]|\\.)*"|[^;{}]*);/g
+  let match: RegExpExecArray | null
+  while ((match = matchPattern.exec(block)) !== null) {
+    const raw = match[2].trim()
+    settings[match[1]] = raw.startsWith('"') ? raw.slice(1, -1) : raw.trim()
+  }
+  return settings
+}
+
+// the Release XCBuildConfiguration of the app target: the configuration whose
+// INFOPLIST_FILE is the plist being resolved, else the one whose PRODUCT_NAME
+// names the target directory. Debug settings (suffixes, dev bundle ids) must
+// never win.
+function appTargetReleaseSettings(
+  pbxproj: string,
+  targetName: string,
+  infoPlistRelativePath: string,
+): Record<string, string> | null {
+  const configurationPattern = /\/\* (Release|Debug) \*\/ = \{/g
+  const candidates: Array<{ name: string; settings: Record<string, string> }> = []
+  let match: RegExpExecArray | null
+  while ((match = configurationPattern.exec(pbxproj)) !== null) {
+    const blockStart = pbxproj.indexOf('{', match.index)
+    if (blockStart < 0) continue
+    const block = readBuildSettingsBlock(pbxproj, blockStart)
+    const buildSettingsStart = block.indexOf('buildSettings = {')
+    if (buildSettingsStart < 0) continue
+    const settings = parseBuildSettings(
+      readBuildSettingsBlock(block, block.indexOf('{', buildSettingsStart)),
+    )
+    candidates.push({ name: match[1], settings })
+  }
+  const plistMatch = (settings: Record<string, string>): boolean => {
+    const plist = settings.INFOPLIST_FILE
+    if (!plist) return false
+    const normalized = plist.replace(/^"|"$/g, '')
+    return (
+      normalized === infoPlistRelativePath ||
+      infoPlistRelativePath.endsWith(`/${normalized}`) ||
+      normalized.endsWith(`/${infoPlistRelativePath}`)
+    )
+  }
+  const named = (settings: Record<string, string>): boolean =>
+    resolveBuildSetting(settings.PRODUCT_NAME ?? '', settings) === targetName
+  return (
+    candidates.find(
+      (candidate) => candidate.name === 'Release' && plistMatch(candidate.settings),
+    )?.settings ??
+    candidates.find(
+      (candidate) => candidate.name === 'Release' && named(candidate.settings),
+    )?.settings ??
+    null
+  )
+}
+
+function nativeAppIdentityFromIos(
+  files: NativeAppIdentityFiles,
+): NativeAppIdentity | null {
+  const appDelegatePattern = /(?:^|\/)ios\/([^/]+)\/AppDelegate\.(?:swift|mm|m)$/
+  let targetName: string | null = null
+  for (const path of Object.keys(files)) {
+    if (path.includes('/Pods/')) continue
+    const match = path.match(appDelegatePattern)
+    if (match) {
+      targetName = match[1]
+      break
+    }
+  }
+  if (!targetName) return null
+
+  const plistPath = Object.keys(files).find(
+    (path) => path === `ios/${targetName}/Info.plist`,
+  )
+  const plist = plistPath ? files[plistPath] : null
+  if (!plist) return null
+
+  const pbxprojPath = Object.keys(files).find((path) =>
+    /(?:^|\/)ios\/[^/]+\.xcodeproj\/project\.pbxproj$/.test(path),
+  )
+  const settings = pbxprojPath
+    ? appTargetReleaseSettings(files[pbxprojPath], targetName, `${targetName}/Info.plist`)
+    : null
+  if (!settings) return null
+
+  const bundleIdentifier = identityFieldFrom(
+    settings,
+    plistString(plist, 'CFBundleIdentifier'),
+    settings.PRODUCT_BUNDLE_IDENTIFIER,
+  )
+  if (!bundleIdentifier) return null
+
+  const appVersion = identityFieldFrom(
+    settings,
+    plistString(plist, 'CFBundleShortVersionString'),
+    settings.MARKETING_VERSION,
+  )
+  const buildVersion = identityFieldFrom(
+    settings,
+    plistString(plist, 'CFBundleVersion'),
+    settings.CURRENT_PROJECT_VERSION,
+  )
+  if (!appVersion || !buildVersion) return null
+
+  const applicationName =
+    identityFieldFrom(settings, plistString(plist, 'CFBundleDisplayName'), undefined) ??
+    identityFieldFrom(
+      settings,
+      plistString(plist, 'CFBundleName'),
+      settings.PRODUCT_NAME,
+    ) ??
+    resolvedIdentityField(resolveBuildSetting(settings.PRODUCT_NAME ?? '', settings)) ??
+    resolvedIdentityField(targetName)
+  if (!applicationName) return null
+
+  return {
+    applicationName,
+    appVersion,
+    buildVersion,
+    bundleIdentifier,
+    platform: 'ios',
+  }
+}
+
+// Android's shipped identity requires resolving the selected flavor and
+// buildType overrides (`productFlavors.prod`, `buildTypes.release`), which a
+// text reader of `defaultConfig` cannot distinguish from the defaults it
+// overrides. an Android project therefore ships no footer until that
+// resolution exists — never a guessed identity.
+function nativeAppIdentityFromAndroid(): NativeAppIdentity | null {
+  return null
+}
+
+// read the identity a bundle builder transports. files are project-relative
+// paths to their text, so both a checked-out app directory and a stored
+// project file map resolve identically. null when the project carries no
+// resolvable native config — the builder then ships no footer.
+export function extractNativeAppIdentityFromFiles(
+  files: NativeAppIdentityFiles,
+  platform: NativeAppIdentityPlatform,
+): NativeAppIdentity | null {
+  return platform === 'android'
+    ? nativeAppIdentityFromAndroid()
+    : nativeAppIdentityFromIos(files)
+}