peachsim 0.1.656 → 0.1.658

package/src/host/replacement-module-handler.ts

@@ -1,3 +1,4 @@
+import { statSync } from 'node:fs'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import {
@@ -33,6 +34,31 @@ function sendJavaScript(req: IncomingMessage, res: ServerResponse, source: strin
   res.end(req.method === 'HEAD' ? undefined : source)
 }
 
+// a relative import resolves the way the app's own files do: the exact path
+// when it names an allowed extension, else each extension in turn, else the
+// directory's index file.
+function resolveLocalImport(fromFile: string, specifier: string): string {
+  const base = path.resolve(path.dirname(fromFile), specifier)
+  const candidates = [
+    ...(REPLACEMENT_MODULE_EXTENSIONS.some(
+      (ext) => ext === path.extname(base).toLowerCase(),
+    )
+      ? [base]
+      : []),
+    ...REPLACEMENT_MODULE_EXTENSIONS.map((ext) => base + ext),
+    ...REPLACEMENT_MODULE_EXTENSIONS.map((ext) => path.join(base, `index${ext}`)),
+  ]
+  const found = candidates.find((candidate) =>
+    statSync(candidate, { throwIfNoEntry: false })?.isFile(),
+  )
+  if (!found) {
+    throw new Error(
+      `'${specifier}' imported by ${fromFile} matches no ${REPLACEMENT_MODULE_EXTENSIONS.join(', ')} file`,
+    )
+  }
+  return found
+}
+
 export function isReplacementModuleRequestUrl(rawUrl?: string): boolean {
   if (!rawUrl) return false
   try {
@@ -140,6 +166,13 @@ export async function handleReplacementModuleRequest(
       filePath: resolvedTargetPath,
       source: await fs.readFile(resolvedTargetPath, 'utf8'),
       runtimePackages,
+      // the imported file's url is this request's with only its path changed,
+      // so the token, cache key and runtime packages carry over.
+      localModuleUrl: (specifier) => {
+        const local = new URL(url.href)
+        local.searchParams.set('path', resolveLocalImport(targetPath, specifier))
+        return `${local.pathname}${local.search}`
+      },
     })
     // inline the map: the file is the app author's own source, and the
     // simulator page is the only thing that ever loads it.

package/src/index.ts

@@ -33,6 +33,7 @@ export type {
   SimSemanticQueryResult,
   SimSemanticResolveResult,
   SimSemanticResolveSelector,
+  SimSemanticTargetSelector,
   SimSemanticSelector,
 } from './bridge-contract'
 export {

package/src/kotlin-app.ts

@@ -5,6 +5,9 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { readResourceValues, resolveThemeAttribute } from './android-theme'
+import { parseXml, type XmlElement } from './android-xml'
+import frameworkThemes from './generated/android-framework-themes.json' with { type: 'json' }
 
 export interface KotlinAppProject {
   projectDir: string
@@ -14,7 +17,16 @@ export interface KotlinAppProject {
   packageName: string
   namespace: string
   targetSdk: number
-  optOutEdgeToEdge: boolean
+  // the launched activity's window as its theme and target SDK configure it;
+  // statusBarColor is ARGB
+  window: {
+    edgeToEdgeEnforced: boolean
+    statusBarColor: number
+    statusBarContrastEnforced: boolean
+    navigationBarContrastEnforced: boolean
+    lightStatusBar: boolean
+    lightNavigationBar: boolean
+  }
   applicationClass: string | null
   launcher: { name: string; targetClass: string }
 }
@@ -48,44 +60,6 @@ const COMPOSE_PIN: Record<string, keyof ComposeAndroidPins> = {
   '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)
@@ -189,29 +163,69 @@ function checkModuleGradle(
   }
 }
 
-function themeOptsOut(moduleDir: string, theme: string | undefined): boolean {
-  const name = theme?.startsWith('@style/') ? theme.slice('@style/'.length) : null
-  if (!name) return false
+// Resources.selectDefaultTheme: the theme a context without one gets for its
+// target SDK
+function defaultTheme(targetSdk: number): string {
+  if (targetSdk < 11) return '@android:style/Theme'
+  if (targetSdk < 14) return '@android:style/Theme.Holo'
+  if (targetSdk < 24) return '@android:style/Theme.DeviceDefault'
+  return '@android:style/Theme.DeviceDefault.Light.DarkActionBar'
+}
+
+// PhoneWindow.generateLayout's status bar reads from the activity's theme.
+// enforcement is isEdgeToEdgeEnforced: target 35 and up unless the theme opts
+// out, which only target 35 may. an enforced window's status bar is
+// transparent and setStatusBarColor does nothing. an unset or @null value
+// reads as the default PhoneWindow passes, as TypedArray returns it.
+function readWindowTheme(
+  moduleDir: string,
+  theme: string | undefined,
+  targetSdk: number,
+): KotlinAppProject['window'] {
   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 ?? '',
-      )
-    }
+  const app = readResourceValues(
+    fs.existsSync(values)
+      ? fs
+          .readdirSync(values)
+          .filter((entry) => entry.endsWith('.xml'))
+          .map((entry) => {
+            const file = path.join(values, entry)
+            return { file, text: fs.readFileSync(file, 'utf8') }
+          })
+      : [],
+  )
+  const sources = { android: frameworkThemes, app }
+  const name = theme ?? defaultTheme(targetSdk)
+  const flag = (attribute: string, fallback = false) => {
+    const value = resolveThemeAttribute(name, attribute, sources)
+    if (value === undefined || value === null) return fallback
+    if (typeof value !== 'boolean')
+      throw new Error(`${name}: ${attribute} is not a boolean`)
+    return value
+  }
+  const optOut = flag('windowOptOutEdgeToEdgeEnforcement')
+  const edgeToEdgeEnforced = targetSdk > 35 || (targetSdk === 35 && !optOut)
+  // from target Q the contrast flags read from the theme, navigation on by
+  // default; before it both stay off
+  const targetQ = targetSdk >= 29
+  const window = {
+    edgeToEdgeEnforced,
+    statusBarContrastEnforced: targetQ && flag('enforceStatusBarContrast'),
+    navigationBarContrastEnforced: targetQ && flag('enforceNavigationBarContrast', true),
+    lightStatusBar: flag('windowLightStatusBar'),
+    lightNavigationBar: flag('windowLightNavigationBar'),
   }
-  throw new Error(`${theme} names no style in ${values}`)
+  // PhoneWindow enforces edge to edge apart from whether the theme draws bar
+  // backgrounds: either way the bar is transparent
+  if (edgeToEdgeEnforced) return { ...window, statusBarColor: 0 }
+  if (!flag('windowDrawsSystemBarBackgrounds'))
+    throw new Error(
+      `${name} does not draw system bar backgrounds; peach kotlin draws only theme status bar colors`,
+    )
+  const color = resolveThemeAttribute(name, 'statusBarColor', sources)
+  if (typeof color === 'boolean')
+    throw new Error(`${name}: statusBarColor is not a color`)
+  return { ...window, statusBarColor: color ?? 0xff000000 }
 }
 
 function enabled(element: XmlElement): boolean {
@@ -404,7 +418,7 @@ export function readKotlinApp(
     packageName: applicationId ?? base,
     namespace: base,
     targetSdk,
-    optOutEdgeToEdge: themeOptsOut(moduleDir, theme),
+    window: readWindowTheme(moduleDir, theme, targetSdk),
     applicationClass: applicationName ? className(applicationName) : null,
     launcher: { name: launcherName, targetClass },
   }

package/src/kotlin-host.ts

@@ -337,16 +337,20 @@ export async function kotlinAppArtifact(
       '',
       '@JsExport',
       'fun peachAppMount(density: Float, fontScale: Float, locale: String, backend: String, stencilBits: Int,',
-      '    regular: String, medium: String, bold: String, statusBar: Int, navigationBar: Int,',
+      '    regular: String, medium: String, bold: String, statusBar: Int, navigationBar: Int, night: Boolean,',
       '    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},`,
+      '        android.view.WindowTheme(',
+      `            ${app.window.edgeToEdgeEnforced}, 0x${app.window.statusBarColor.toString(16).padStart(8, '0')}.toInt(),`,
+      `            ${app.window.statusBarContrastEnforced}, ${app.window.navigationBarContrastEnforced},`,
+      `            ${app.window.lightStatusBar}, ${app.window.lightNavigationBar},`,
+      '        ),',
       `        { ${app.applicationClass ?? 'android.app.Application'}() },`,
       `        { ${app.launcher.targetClass}() },`,
       '    ),',
-      '    density, fontScale, locale, backend, stencilBits, regular, medium, bold, statusBar, navigationBar, invalidate,',
+      '    density, fontScale, locale, backend, stencilBits, regular, medium, bold, statusBar, navigationBar, night, invalidate,',
       ')',
       '',
     ].join('\n'),

package/src/metro-plugin.ts

@@ -1,4 +1,4 @@
-// peach metro plugin for dev shell and bundle module identity annotation.
+// peach metro plugin for dev shell and bundle identity metadata.
 // shell assets come from an engine runtime under ~/.peach/runtimes/, fetched
 // by `peach runtime install`. ordinary localhost requests
 // follow active; a version-owned localhost origin stays on its exact directory
@@ -24,7 +24,13 @@ import {
   toRNXProductionBundleUrl,
   type RNXMetroModuleIdentityMetadata,
 } from './metro-production-bundle'
+import {
+  canExtractNativeAppIdentity,
+  extractNativeAppIdentityFromFiles,
+  insertNativeAppIdentityFooter,
+} from './native-app-identity'
 import { readNativeFirebaseConfig } from './native-firebase-config'
+import { parsePlistSource } from './plist'
 import {
   isRootRuntimeAssetPath,
   resolveRuntimeFilePath,
@@ -49,6 +55,7 @@ type MetroSerializerModule = {
 
 type MetroSerializerGraph = {
   dependencies?: ReadonlyMap<unknown, MetroSerializerModule>
+  transformOptions?: { platform?: string | null }
 }
 
 type MetroSerializerOptions = {
@@ -122,7 +129,7 @@ function createMetroDefaultSerializer(projectRoot: string): MetroSerializer {
   }
 }
 
-// the only thing peach adds to an ordinary Metro bundle. production needs the
+// module identity accompanies an ordinary Metro bundle. production needs the
 // footer because Metro drops the fourth `__d` argument when `dev` is false;
 // development keeps that verbose name and receives the same identity without
 // changing resolution, transforms, or the trailing source map.
@@ -215,7 +222,43 @@ export function withRNX<T extends Record<string, unknown>>(config: T): T {
           existingSerializer ||
           (defaultSerializer ||= createMetroDefaultSerializer(cfgProjectRoot))
         const result = await serializer(entryPoint, preModules, graph, serializerOptions)
-        return appendRNXModulePaths(result, graph, serializerOptions, cfgProjectRoot)
+        let annotated = appendRNXModulePaths(
+          result,
+          graph,
+          serializerOptions,
+          cfgProjectRoot,
+        )
+        const iosRoot = path.join(cfgProjectRoot, 'ios')
+        const bundlePlatform = graph.transformOptions?.platform
+        if (canExtractNativeAppIdentity(bundlePlatform) && fs.existsSync(iosRoot)) {
+          const files: Record<string, string> = {}
+          for (const entry of fs.readdirSync(iosRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name === 'Pods') continue
+            const names = entry.name.endsWith('.xcodeproj')
+              ? ['project.pbxproj']
+              : ['Info.plist', 'AppDelegate.swift', 'AppDelegate.mm', 'AppDelegate.m']
+            for (const name of names) {
+              const relative = `ios/${entry.name}/${name}`
+              const file = path.join(cfgProjectRoot, relative)
+              if (fs.existsSync(file)) files[relative] = fs.readFileSync(file, 'utf8')
+            }
+          }
+          const identity = extractNativeAppIdentityFromFiles(
+            files,
+            bundlePlatform,
+            parsePlistSource,
+          )
+          if (identity) {
+            annotated =
+              typeof annotated === 'string'
+                ? insertNativeAppIdentityFooter(annotated, identity)
+                : {
+                    ...annotated,
+                    code: insertNativeAppIdentityFooter(annotated.code, identity),
+                  }
+          }
+        }
+        return annotated
       },
     },
   }

package/src/native-app-identity.ts

@@ -17,6 +17,7 @@ export interface NativeAppIdentity {
   buildVersion: string
   bundleIdentifier: string
   platform: NativeAppIdentityPlatform
+  permissionUsageDescriptions?: Readonly<Record<string, unknown>>
 }
 
 export type NativeAppIdentityFiles = Record<string, string>
@@ -39,6 +40,8 @@ function nonEmptyString(value: unknown): string | null {
 
 export function isNativeAppIdentity(value: unknown): value is NativeAppIdentity {
   if (!isRecord(value)) return false
+  const descriptions = value.permissionUsageDescriptions
+  if (descriptions !== undefined && !isRecord(descriptions)) return false
   const platform = value.platform
   if (platform !== 'ios' && platform !== 'android') return false
   const applicationName = value.applicationName
@@ -64,6 +67,11 @@ export function readNativeAppIdentity(value: unknown): NativeAppIdentity | null
     buildVersion: value.buildVersion,
     bundleIdentifier: value.bundleIdentifier,
     platform: value.platform,
+    ...(value.permissionUsageDescriptions === undefined
+      ? {}
+      : {
+          permissionUsageDescriptions: { ...value.permissionUsageDescriptions },
+        }),
   }
 }
 
@@ -230,7 +238,7 @@ function readBuildSettingsBlock(source: string, start: number): string {
 
 function parseBuildSettings(block: string): Record<string, string> {
   const settings: Record<string, string> = {}
-  const matchPattern = /([A-Z0-9_]+) = ("(?:[^"\\]|\\.)*"|[^;{}]*);/g
+  const matchPattern = /([A-Za-z0-9_]+) = ("(?:[^"\\]|\\.)*"|[^;{}]*);/g
   let match: RegExpExecArray | null
   while ((match = matchPattern.exec(block)) !== null) {
     const raw = match[2].trim()
@@ -287,31 +295,39 @@ function appTargetReleaseSettings(
 
 function nativeAppIdentityFromIos(
   files: NativeAppIdentityFiles,
+  parseInfoPlist: (source: string) => unknown,
 ): NativeAppIdentity | null {
+  const pbxprojPath = Object.keys(files).find((path) =>
+    /(?:^|\/)ios\/[^/]+\.xcodeproj\/project\.pbxproj$/.test(path),
+  )
+  if (!pbxprojPath) return null
+  const pbxproj = files[pbxprojPath]
+  // the installed app is the target Xcode builds as an application. an App
+  // Clip or extension carries its own AppDelegate and Info.plist, so a target
+  // directory alone cannot say which binary is the app.
+  const applicationTargets = new Set(
+    [
+      ...pbxproj.matchAll(
+        /isa = PBXNativeTarget;[^}]*?name = "?([^";]+)"?;[^}]*?productType = "com\.apple\.product-type\.application";/g,
+      ),
+    ].map((match) => match[1]),
+  )
   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
-    }
-  }
+  const targetName =
+    Object.keys(files)
+      .filter((path) => !path.includes('/Pods/'))
+      .map((path) => path.match(appDelegatePattern)?.[1])
+      .find((name) => name !== undefined && applicationTargets.has(name)) ?? null
   if (!targetName) return null
 
-  const plistPath = Object.keys(files).find(
-    (path) => path === `ios/${targetName}/Info.plist`,
-  )
-  const plist = plistPath ? files[plistPath] : null
+  const plist = files[`ios/${targetName}/Info.plist`]
   if (!plist) return null
 
-  const pbxprojPath = Object.keys(files).find((path) =>
-    /(?:^|\/)ios\/[^/]+\.xcodeproj\/project\.pbxproj$/.test(path),
+  const settings = appTargetReleaseSettings(
+    pbxproj,
+    targetName,
+    `${targetName}/Info.plist`,
   )
-  const settings = pbxprojPath
-    ? appTargetReleaseSettings(files[pbxprojPath], targetName, `${targetName}/Info.plist`)
-    : null
   if (!settings) return null
 
   const bundleIdentifier = identityFieldFrom(
@@ -344,22 +360,54 @@ function nativeAppIdentityFromIos(
     resolvedIdentityField(targetName)
   if (!applicationName) return null
 
+  // only native privacy purpose strings travel here, not an invented Bundle
+  // dictionary. parse XML with the build-side parser so entities and empty
+  // strings survive; the browser identity transport has no XML dependency.
+  const dictionary = parseInfoPlist(plist)
+  if (!isRecord(dictionary)) throw new Error('native app Info.plist is not a dictionary')
+  const permissionUsageDescriptions: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(dictionary)) {
+    if (!/^NS.*UsageDescription$/.test(key)) continue
+    // retain non-string plist values: the native factory checks key presence.
+    if (typeof value !== 'string') {
+      permissionUsageDescriptions[key] = value
+      continue
+    }
+    const resolved = resolveBuildSetting(value, settings)
+    if (resolved === null) throw new Error(`native app Info.plist ${key} is unresolved`)
+    permissionUsageDescriptions[key] = resolved
+  }
+
+  // Xcode's generated Info.plist uses these build settings only when enabled.
+  // source: developer.apple.com/documentation/xcode/build-settings-reference.
+  if (settings.GENERATE_INFOPLIST_FILE === 'YES') {
+    for (const [setting, value] of Object.entries(settings)) {
+      if (!/^INFOPLIST_KEY_NS.*UsageDescription$/.test(setting)) continue
+      const key = setting.slice('INFOPLIST_KEY_'.length)
+      const resolved = resolveBuildSetting(value, settings)
+      if (resolved === null)
+        throw new Error(`native app build setting ${setting} is unresolved`)
+      permissionUsageDescriptions[key] = resolved
+    }
+  }
+
   return {
     applicationName,
     appVersion,
     buildVersion,
     bundleIdentifier,
     platform: 'ios',
+    permissionUsageDescriptions,
   }
 }
 
-// Android's shipped identity requires resolving the selected flavor and
+// 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
+// resolution exists. unsupported or absent bundle platforms ship no footer.
+export function canExtractNativeAppIdentity(platform: unknown): platform is 'ios' {
+  return platform === 'ios'
 }
 
 // read the identity a bundle builder transports. files are project-relative
@@ -369,8 +417,9 @@ function nativeAppIdentityFromAndroid(): NativeAppIdentity | null {
 export function extractNativeAppIdentityFromFiles(
   files: NativeAppIdentityFiles,
   platform: NativeAppIdentityPlatform,
+  parseInfoPlist: (source: string) => unknown,
 ): NativeAppIdentity | null {
-  return platform === 'android'
-    ? nativeAppIdentityFromAndroid()
-    : nativeAppIdentityFromIos(files)
+  return canExtractNativeAppIdentity(platform)
+    ? nativeAppIdentityFromIos(files, parseInfoPlist)
+    : null
 }

package/src/sim-client.ts

@@ -58,7 +58,7 @@ import type {
   ResetResult,
   SimSemanticNode,
   SimSemanticResolveResult,
-  SimSemanticResolveSelector,
+  SimSemanticTargetSelector,
   SimStateOptions,
   SimStateResult,
   WsBridgeCommand,
@@ -400,9 +400,7 @@ export class SimClient implements WsBridge, InspectBridge {
     return Array.isArray(tree) ? tree : []
   }
 
-  resolve(
-    selector: SimSemanticResolveSelector,
-  ): Promise<SimSemanticResolveResult | null> {
+  resolve(selector: SimSemanticTargetSelector): Promise<SimSemanticResolveResult | null> {
     return this.send({ type: 'resolve', selector })
   }