peachsim 0.1.2228 → 0.1.2231

package/scripts/dev-server-scanner.ts

@@ -48,6 +48,7 @@ import {
   parseSwiftHostDiscovery,
 } from '../src/swiftDiscoveryContract'
 import { loadOptionalDemoApps, optionalDemoAppsSync } from './optional-demo-registry.ts'
+import type { ConfiguredOneWidget } from '../src/oneWidgetContract'
 import type { DiscoveredServer } from '../src/serverDiscoveryContract'
 
 export type { DiscoveredServer } from '../src/serverDiscoveryContract'
@@ -1187,6 +1188,38 @@ const knownNonPatched = new Set<number>()
 // same invalidation rules as knownNonPatched: cleared on port
 // disappearance, owning-pid change, and __resetScannerCache.
 const knownOne = new Set<number>()
+const oneNativeApps = new Map<number, { root: string; bundleId: string }>()
+
+function oneNativeWidgetFromScan(
+  scan: unknown,
+  result: DiscoveredServer,
+  identity: { root: string; bundleId: string },
+): ConfiguredOneWidget | null {
+  if (!Array.isArray(scan)) return null
+  for (const entry of scan) {
+    if (!entry || typeof entry !== 'object' || entry.port !== result.port) continue
+    if (typeof entry.bundleUrl !== 'string') continue
+    let advertised: URL
+    try {
+      advertised = new URL(entry.bundleUrl)
+    } catch {
+      continue
+    }
+    if (!isLoopbackHost(advertised.hostname) || advertised.port !== String(result.port))
+      continue
+    const widget = configuredWidgetFromScan(scan, advertised.href)
+    if (
+      widget?.projectRoot === identity.root &&
+      widget.metadata.bundleId === identity.bundleId
+    )
+      return {
+        ...widget,
+        bundleUrl: result.bundleUrl,
+        packageUrl: new URL('/__peach/swift-package/OneWidgets', result.bundleUrl).href,
+      }
+  }
+  return null
+}
 
 // fire signature probes in waves and pick the best match by precedence:
 //   1. expo manifest   (JSON manifest at /)
@@ -1260,6 +1293,25 @@ export async function probePort(
   const manifestParsed = manifestRes ? safeParseManifest(manifestRes.body) : null
   const { launchUrl: manifestLaunchUrl, client: manifestClient } =
     readExpoManifestFields(manifestParsed)
+  const metadata = manifestParsed?.metadata
+  const extra = manifestParsed?.extra
+  const expoGo = extra && typeof extra === 'object' ? Reflect.get(extra, 'expoGo') : null
+  const developer =
+    expoGo && typeof expoGo === 'object' ? Reflect.get(expoGo, 'developer') : null
+  const projectRoot =
+    developer && typeof developer === 'object'
+      ? Reflect.get(developer, 'projectRoot')
+      : null
+  const bundleId = manifestClient.ios?.bundleIdentifier
+  if (
+    metadata &&
+    typeof metadata === 'object' &&
+    Reflect.get(metadata, 'oneNativeApp') === true &&
+    typeof projectRoot === 'string' &&
+    typeof bundleId === 'string'
+  )
+    oneNativeApps.set(port, { root: projectRoot, bundleId })
+  else if (manifestRes) oneNativeApps.delete(port)
   // `manifestRes === null` means the probe got NO answer — it timed out or the
   // connection failed. that is not the same fact as a server that answered and
   // turned out to have no manifest, and only the second one licenses the
@@ -1636,6 +1688,7 @@ export function __resetScannerCache() {
   portCache.clear()
   knownNonPatched.clear()
   knownOne.clear()
+  oneNativeApps.clear()
   enrichmentCache.clear()
   enrichmentInFlight.clear()
   portCacheInvalidatedAt.clear()
@@ -1692,6 +1745,9 @@ export async function scanDevServers(
   for (const p of [...knownOne]) {
     if (!currentPorts.has(p)) knownOne.delete(p)
   }
+  for (const p of [...oneNativeApps.keys()]) {
+    if (!currentPorts.has(p)) oneNativeApps.delete(p)
+  }
   for (const p of [...enrichmentCache.keys()]) {
     if (!currentPorts.has(p)) enrichmentCache.delete(p)
   }
@@ -1726,6 +1782,7 @@ export async function scanDevServers(
     if (cached && cached.pid !== pid) {
       knownNonPatched.delete(port)
       knownOne.delete(port)
+      oneNativeApps.delete(port)
       // a restarted process may be a different app — drop its captured name/icon.
       enrichmentCache.delete(port)
       localIconPathCache.delete(port)
@@ -1765,7 +1822,8 @@ export async function scanDevServers(
   // "no widget".
   await Promise.all(
     results.map(async (result) => {
-      if (result.framework !== 'one' && result.framework !== 'vxrn') {
+      const nativeIdentity = oneNativeApps.get(result.port)
+      if (result.framework !== 'one' && result.framework !== 'vxrn' && !nativeIdentity) {
         result.widget = null
         return
       }
@@ -1780,10 +1838,13 @@ export async function scanDevServers(
         result.widget ??= null
         return
       }
-      result.widget =
+      const scan =
         scanRes.statusCode === 200 && scanRes.contentType?.includes('json')
-          ? configuredWidgetFromScan(safeParseManifest(scanRes.body), result.bundleUrl)
+          ? safeParseManifest(scanRes.body)
           : null
+      result.widget = nativeIdentity
+        ? oneNativeWidgetFromScan(scan, result, nativeIdentity)
+        : configuredWidgetFromScan(scan, result.bundleUrl)
     }),
   )
 

package/src/appPackageContract.ts

@@ -1,4 +1,4 @@
-import { DESKTOP_RENDER_RESOLUTION } from './menu'
+import { DESKTOP_RENDER_RESOLUTION } from './menuContract'
 import {
   isSettingKey,
   isValidSettingValue,

package/src/conformance-pixel-comparison.ts

@@ -1,3 +1,4 @@
+import { Buffer } from 'node:buffer'
 import pixelmatch from 'pixelmatch'
 import {
   CONFORMANCE_FLAT_SHADE_FLATNESS,
@@ -123,13 +124,17 @@ export function compareConformancePixels(options: {
 
   // identical frames need no shade or neighborhood search, but still use
   // the same region and rounded-display exclusions for their pixel count.
-  let identical = true
-  for (let index = 0; index < options.reference.length; index++) {
-    if (options.reference[index] !== options.result[index]) {
-      identical = false
-      break
-    }
-  }
+  const identical = Buffer.from(
+    options.reference.buffer,
+    options.reference.byteOffset,
+    options.reference.byteLength,
+  ).equals(
+    Buffer.from(
+      options.result.buffer,
+      options.result.byteOffset,
+      options.result.byteLength,
+    ),
+  )
   if (identical) {
     options.diff?.fill(0)
     const columns = Math.ceil(options.width)

package/src/menu.ts

@@ -1,107 +1,25 @@
+import {
+  type SootSimMenuPlatform,
+  type SootSimScaleMode,
+  type SootSimAmbientGlowLevel,
+  SOOTSIM_AMBIENT_GLOW_LEVELS,
+  SOOTSIM_AMBIENT_GLOW_LABELS,
+  type SootSimStageBackground,
+  SOOTSIM_STAGE_BACKGROUNDS,
+  SOOTSIM_STAGE_BACKGROUND_LABELS,
+  type SootSimRenderResolution,
+  SOOTSIM_RENDER_RESOLUTION_LEVELS,
+  SOOTSIM_RENDER_RESOLUTION_LABELS,
+  type SootSimScreenEffect,
+  SOOTSIM_SCREEN_EFFECTS,
+  SOOTSIM_SCREEN_EFFECT_LABELS,
+} from './menuContract'
 import { rnxPublicBrand } from './public-brand'
 
 // public sootsim menu protocol. this file is deliberately pure data and pure
 // functions so hosts can import it without pulling the engine or canvaskit graph.
 
-export const SOOTSIM_ENGINE_EVENT_NAME = 'sootsim:engine-event'
-export const SOOTSIM_SHELL_COMMAND_NAME = 'sootsim:shell-command'
-
-export type SootSimMenuPlatform = 'browser' | 'electron'
-export type SootSimScaleMode = 'physical' | 'point' | 'pixel' | 'fit'
-
-// ambient glow strength. one setting with three states rather than an on/off
-// pair plus a separate strength: every host that carries the preference (the
-// menus, the persisted setting, the ?ambientGlow= boot seed, the live
-// set-ambient-glow push, electron's shared config) then carries exactly one
-// value and cannot end up half-configured.
-export type SootSimAmbientGlowLevel = 'off' | 'soft' | 'full'
-export const SOOTSIM_AMBIENT_GLOW_LEVELS = ['off', 'soft', 'full'] as const
-
-export function isSootSimAmbientGlowLevel(
-  value: unknown,
-): value is SootSimAmbientGlowLevel {
-  return value === 'off' || value === 'soft' || value === 'full'
-}
-
-export const SOOTSIM_AMBIENT_GLOW_LABELS: Record<SootSimAmbientGlowLevel, string> = {
-  off: 'Off',
-  soft: 'Soft',
-  full: 'Full',
-}
-
-// the stage behind the device: system follows the mac's appearance (white in
-// light mode, black in dark), or one pinned color. one value per host, like
-// the glow level above.
-export type SootSimStageBackground = 'system' | 'light' | 'dark' | 'gray'
-export const SOOTSIM_STAGE_BACKGROUNDS = ['system', 'light', 'dark', 'gray'] as const
-
-export function isSootSimStageBackground(
-  value: unknown,
-): value is SootSimStageBackground {
-  return value === 'system' || value === 'light' || value === 'dark' || value === 'gray'
-}
-
-export const SOOTSIM_STAGE_BACKGROUND_LABELS: Record<SootSimStageBackground, string> = {
-  system: 'System',
-  light: 'Light',
-  dark: 'Dark',
-  gray: 'Gray',
-}
-
-// render resolution: how many pixels peach renders per iphone point. one
-// setting with three states, carried by every host exactly like the ambient
-// glow level above: the menus, the persisted setting, the ?renderResolution=
-// boot seed, the live set-render-resolution push, electron's shared config.
-export type SootSimRenderResolution = 'high' | 'medium' | 'low'
-export const SOOTSIM_RENDER_RESOLUTION_LEVELS = ['high', 'medium', 'low'] as const
-
-// the installed desktop app presents the phone scaled to fit its window, so a
-// fixed 2 px/pt canvas is browser-resampled and its icons read soft. its
-// default is the level that tracks the pixels on screen; browsers and capture
-// keep medium, whose 2 px/pt is the deterministic capture contract.
-export const DESKTOP_RENDER_RESOLUTION: SootSimRenderResolution = 'low'
-
-export function isSootSimRenderResolution(
-  value: unknown,
-): value is SootSimRenderResolution {
-  return value === 'high' || value === 'medium' || value === 'low'
-}
-
-export const SOOTSIM_RENDER_RESOLUTION_LABELS: Record<SootSimRenderResolution, string> = {
-  high: 'High',
-  medium: 'Medium',
-  low: 'Low',
-}
-
-// screen effect: the real rendering, or one of the presentation looks the
-// engine's wireframe store draws. 'wireframe' is the clean structural sketch;
-// the others are its screen-space styles that ship as named effects.
-export type SootSimScreenEffect = 'none' | 'wireframe' | 'blueprint' | 'panel' | 'green'
-export const SOOTSIM_SCREEN_EFFECTS = [
-  'none',
-  'wireframe',
-  'blueprint',
-  'panel',
-  'green',
-] as const
-
-export function isSootSimScreenEffect(value: unknown): value is SootSimScreenEffect {
-  return (
-    value === 'none' ||
-    value === 'wireframe' ||
-    value === 'blueprint' ||
-    value === 'panel' ||
-    value === 'green'
-  )
-}
-
-export const SOOTSIM_SCREEN_EFFECT_LABELS: Record<SootSimScreenEffect, string> = {
-  none: 'None',
-  wireframe: 'Wireframe',
-  blueprint: 'Blueprint',
-  panel: 'Panel',
-  green: 'Green',
-}
+export * from './menuContract'
 
 export type SootSimMenuItemDef =
   | { type: 'separator' }

package/src/menuContract.ts

@@ -0,0 +1,102 @@
+// the values and event names the menu protocol carries. kept apart from the menu builder so a
+// runtime that only validates a setting or names an event does not carry the menus at boot.
+
+export const SOOTSIM_ENGINE_EVENT_NAME = 'sootsim:engine-event'
+export const SOOTSIM_SHELL_COMMAND_NAME = 'sootsim:shell-command'
+
+export type SootSimMenuPlatform = 'browser' | 'electron'
+export type SootSimScaleMode = 'physical' | 'point' | 'pixel' | 'fit'
+
+// ambient glow strength. one setting with three states rather than an on/off
+// pair plus a separate strength: every host that carries the preference (the
+// menus, the persisted setting, the ?ambientGlow= boot seed, the live
+// set-ambient-glow push, electron's shared config) then carries exactly one
+// value and cannot end up half-configured.
+export type SootSimAmbientGlowLevel = 'off' | 'soft' | 'full'
+export const SOOTSIM_AMBIENT_GLOW_LEVELS = ['off', 'soft', 'full'] as const
+
+export function isSootSimAmbientGlowLevel(
+  value: unknown,
+): value is SootSimAmbientGlowLevel {
+  return value === 'off' || value === 'soft' || value === 'full'
+}
+
+export const SOOTSIM_AMBIENT_GLOW_LABELS: Record<SootSimAmbientGlowLevel, string> = {
+  off: 'Off',
+  soft: 'Soft',
+  full: 'Full',
+}
+
+// the stage behind the device: system follows the mac's appearance (white in
+// light mode, black in dark), or one pinned color. one value per host, like
+// the glow level above.
+export type SootSimStageBackground = 'system' | 'light' | 'dark' | 'gray'
+export const SOOTSIM_STAGE_BACKGROUNDS = ['system', 'light', 'dark', 'gray'] as const
+
+export function isSootSimStageBackground(
+  value: unknown,
+): value is SootSimStageBackground {
+  return value === 'system' || value === 'light' || value === 'dark' || value === 'gray'
+}
+
+export const SOOTSIM_STAGE_BACKGROUND_LABELS: Record<SootSimStageBackground, string> = {
+  system: 'System',
+  light: 'Light',
+  dark: 'Dark',
+  gray: 'Gray',
+}
+
+// render resolution: how many pixels peach renders per iphone point. one
+// setting with three states, carried by every host exactly like the ambient
+// glow level above: the menus, the persisted setting, the ?renderResolution=
+// boot seed, the live set-render-resolution push, electron's shared config.
+export type SootSimRenderResolution = 'high' | 'medium' | 'low'
+export const SOOTSIM_RENDER_RESOLUTION_LEVELS = ['high', 'medium', 'low'] as const
+
+// the installed desktop app presents the phone scaled to fit its window, so a
+// fixed 2 px/pt canvas is browser-resampled and its icons read soft. its
+// default is the level that tracks the pixels on screen; browsers and capture
+// keep medium, whose 2 px/pt is the deterministic capture contract.
+export const DESKTOP_RENDER_RESOLUTION: SootSimRenderResolution = 'low'
+
+export function isSootSimRenderResolution(
+  value: unknown,
+): value is SootSimRenderResolution {
+  return value === 'high' || value === 'medium' || value === 'low'
+}
+
+export const SOOTSIM_RENDER_RESOLUTION_LABELS: Record<SootSimRenderResolution, string> = {
+  high: 'High',
+  medium: 'Medium',
+  low: 'Low',
+}
+
+// screen effect: the real rendering, or one of the presentation looks the
+// engine's wireframe store draws. 'wireframe' is the clean structural sketch;
+// the others are its screen-space styles that ship as named effects.
+export type SootSimScreenEffect = 'none' | 'wireframe' | 'blueprint' | 'panel' | 'green'
+export const SOOTSIM_SCREEN_EFFECTS = [
+  'none',
+  'wireframe',
+  'blueprint',
+  'panel',
+  'green',
+] as const
+
+export function isSootSimScreenEffect(value: unknown): value is SootSimScreenEffect {
+  return (
+    value === 'none' ||
+    value === 'wireframe' ||
+    value === 'blueprint' ||
+    value === 'panel' ||
+    value === 'green'
+  )
+}
+
+export const SOOTSIM_SCREEN_EFFECT_LABELS: Record<SootSimScreenEffect, string> = {
+  none: 'None',
+  wireframe: 'Wireframe',
+  blueprint: 'Blueprint',
+  panel: 'Panel',
+  green: 'Green',
+}

package/src/react-native-coverage/native-typescript-parser.ts

@@ -61,14 +61,24 @@ export async function withTypeScriptSourceParser<T>(
       if (!project) throw new Error('native TypeScript parser found no program')
       // the program retains every input for resolution; transfer only the ASTs
       // the caller analyzes across the native compiler's RPC boundary.
-      for (const path of requestedSources) {
-        const virtualPath = sourcePaths.get(path)
-        if (!virtualPath) throw new Error(`requested parser source is missing: ${path}`)
-        const sourceFile = await project.program.getSourceFile(virtualPath)
-        if (!sourceFile)
-          throw new Error(`native TypeScript parser did not return ${path}`)
-        parsed.set(path, sourceFile)
-        projects.set(path, project)
+      const requestedPaths = Array.from(requestedSources)
+      for (let start = 0; start < requestedPaths.length; start += 64) {
+        const sources = await Promise.allSettled(
+          requestedPaths.slice(start, start + 64).map(async (path) => {
+            const virtualPath = sourcePaths.get(path)
+            if (!virtualPath)
+              throw new Error(`requested parser source is missing: ${path}`)
+            const sourceFile = await project.program.getSourceFile(virtualPath)
+            if (!sourceFile)
+              throw new Error(`native TypeScript parser did not return ${path}`)
+            return { path, sourceFile }
+          }),
+        )
+        for (const source of sources) {
+          if (source.status === 'rejected') throw source.reason
+          parsed.set(source.value.path, source.value.sourceFile)
+          projects.set(source.value.path, project)
+        }
       }
       return await analyze(parsed, projects)
     } finally {

package/src/settingsContract.ts

@@ -2,14 +2,6 @@ import {
   DEFAULT_PROFILER_CATEGORIES,
   formatProfilerCategories,
 } from '@peach/globals/profiler'
-import {
-  SOOTSIM_AMBIENT_GLOW_LEVELS,
-  SOOTSIM_RENDER_RESOLUTION_LEVELS,
-  SOOTSIM_STAGE_BACKGROUNDS,
-  type SootSimAmbientGlowLevel,
-  type SootSimRenderResolution,
-  type SootSimStageBackground,
-} from 'peachsim/menu'
 import {
   type DeviceModel,
   type DevicePosture,
@@ -19,6 +11,14 @@ import {
   DYNAMIC_WINDOW_LIMITS,
   devices,
 } from './device-catalog.ts'
+import {
+  SOOTSIM_AMBIENT_GLOW_LEVELS,
+  SOOTSIM_RENDER_RESOLUTION_LEVELS,
+  SOOTSIM_STAGE_BACKGROUNDS,
+  type SootSimAmbientGlowLevel,
+  type SootSimRenderResolution,
+  type SootSimStageBackground,
+} from './menuContract'
 import { DEFAULT_REACT_NATIVE_CONFIGURATION } from './reactNativeConfigurationContract.ts'
 import {
   BACKGROUND_PRESET_NAMES,

package/src/swift-host.ts

@@ -132,8 +132,10 @@ import {
 } from './swiftContract'
 import {
   enclosingXcodeWorkspace,
+  expandXcodeBuildSetting,
   readXcodeAppTarget,
   resolveXcodeSwiftPackages,
+  xcodeFileListEntries,
   type XcodeAppTarget,
   type XcodeModuleTarget,
 } from './xcode-project'
@@ -2312,11 +2314,34 @@ export function buildSwiftBundleFiles(
           CONTENTS_FOLDER_PATH: wrapper,
           UNLOCALIZED_RESOURCES_FOLDER_PATH: wrapper,
           INFOPLIST_PATH: `${wrapper}/Info.plist`,
-          SCRIPT_INPUT_FILE_COUNT: '0',
-          SCRIPT_INPUT_FILE_LIST_COUNT: '0',
+          SCRIPT_INPUT_FILE_COUNT: String(phase.inputPaths.length),
+          SCRIPT_INPUT_FILE_LIST_COUNT: String(phase.inputFileListPaths.length),
           SCRIPT_OUTPUT_FILE_COUNT: '0',
           SCRIPT_OUTPUT_FILE_LIST_COUNT: '0',
         }
+        const inputPath = (raw: string) => {
+          const file = path.resolve(
+            phase.directory,
+            expandXcodeBuildSetting(raw, (key) => env[key] ?? ''),
+          )
+          if (!fs.existsSync(file))
+            throw new Error(
+              `${xcode.app.name}: Run Script "${phase.name}" missing input ${file}`,
+            )
+          if (!file.startsWith(`${dir}${path.sep}`))
+            watched.push(path.relative(packagePath, file).split(path.sep).join('/'))
+          return file
+        }
+        phase.inputPaths.forEach((raw, index) => {
+          env[`SCRIPT_INPUT_FILE_${index}`] = inputPath(raw)
+        })
+        phase.inputFileListPaths.forEach((raw, index) => {
+          const source = inputPath(raw)
+          const entries = xcodeFileListEntries(source, inputPath)
+          const expanded = path.join(dir, `Input-${index}.xcfilelist`)
+          fs.writeFileSync(expanded, `${entries.join('\n')}\n`)
+          env[`SCRIPT_INPUT_FILE_LIST_${index}`] = expanded
+        })
         try {
           const [shell, ...args] = phase.command
           execFileSync(shell, args, {

package/src/vite-plugin-one.ts

@@ -46,6 +46,7 @@ import {
 } from './runtime-assets'
 import { ensureRuntimePackFor } from './runtime-packs'
 import { SWIFT_HMR_PATH, SWIFT_PACKAGE_PATH } from './swift-submit'
+import { privateSwiftDistributionRoot } from './swift-toolchain'
 import { swiftViteLifetime } from './swift-vite-lifetime'
 import type { OneWidgetPackage } from './oneWidgetContract'
 import type { PeachPluginOptions } from './vite'
@@ -235,6 +236,7 @@ export function peachPlugin(options: PeachPluginOptions = {}): Plugin {
       // npm install has none (null), and its packages compile on Contrast.
       let swiftModuleRoot: string | null | undefined
       const moduleRootFor = (): string | undefined => {
+        if (privateSwiftDistributionRoot()) return undefined
         if (swiftModuleRoot === undefined) {
           // src/ or dist-lib/ → .. is peachsim; the module sits beside it
           const moduleRoot = path.resolve(

package/src/vite-plugin.ts

@@ -2542,23 +2542,23 @@ function externalAppResolvePlugin(
 // convert require() calls and handle JSX in .js files from external app sources
 function externalAppTransformPlugin(isAppSource: (p: string) => boolean): Plugin {
   const defines: Record<string, string> = {}
+  let isBuild = false
   return {
     name: 'sootsim-external-app-transform',
     enforce: 'pre',
     configResolved(config) {
+      isBuild = config.command === 'build'
       for (const [name, value] of Object.entries(config.define ?? {}))
         defines[name] = typeof value === 'string' ? value : JSON.stringify(value)
     },
     transform: {
       filter: { code: /require\(|</ },
       async handler(code, id) {
-        // expo's winter polyfills use Metro-local requires in lazy getters.
-        // their module imports must never reach the host's native-package registry.
-        if (!isAppSource(id) && !/\/node_modules\/expo\/(?:src|build)\/winter\//.test(id))
-          return null
+        const isExpoWinter = /\/node_modules\/expo\/(?:src|build)\/winter\//.test(id)
+        if (!isAppSource(id) && !isExpoWinter) return null
 
-        // prune upstream's disabled native branches before lifting module imports.
-        let result = /\/node_modules\/expo\/(?:src|build)\/winter\//.test(id)
+        // prune disabled native branches before resolving their requires.
+        let result = isExpoWinter
           ? minifySync(
               stripViteQuery(id),
               transformSync(stripViteQuery(id), code, { define: defines }).code,
@@ -2567,9 +2567,10 @@ function externalAppTransformPlugin(isAppSource: (p: string) => boolean): Plugin
           : code
         let imports = ''
         let importCounter = 0
-        let hasChanges = false
+        let hasChanges = isExpoWinter
 
-        if (code.includes('require(')) {
+        // rolldown keeps winter's lazy requires at their call sites in builds.
+        if (code.includes('require(') && !(isBuild && isExpoWinter)) {
           const replacements: Array<{ start: number; end: number; varName: string }> = []
           const seenPaths = new Map<string, string>()
           const pending: unknown[] = [parseSync(stripViteQuery(id), result).program]

package/src/xcode-project.ts

@@ -180,6 +180,8 @@ export interface XcodeAppTarget extends XcodeModuleTarget {
     command: [string, ...string[]]
     directory: string
     environment: Record<string, string>
+    inputPaths: string[]
+    inputFileListPaths: string[]
   }[]
   appIconName: string
   /** the app project PBXProject developmentRegion, xcode's "en" when it declares none. */
@@ -890,6 +892,8 @@ function compilationConditions(settings: (key: string) => string): string[] {
   ]
 }
 
+export { expand as expandXcodeBuildSetting }
+
 function expand(value: string, lookup: (name: string) => string): string {
   return value.replace(
     /\$(?:\(([A-Za-z_][A-Za-z0-9_]*)((?::[^)]*)?)\)|\{([A-Za-z_][A-Za-z0-9_]*)((?::[^}]*)?)\}|([A-Za-z_][A-Za-z0-9_]*))/g,
@@ -1013,6 +1017,8 @@ function shellCopies(
 }
 
 // an xcfilelist names one path per line; blank lines and comments are skipped.
+export { fileListEntries as xcodeFileListEntries }
+
 function fileListEntries(file: string, absolute: (raw: string) => string): string[] {
   return fs
     .readFileSync(file, 'utf8')
@@ -2851,8 +2857,6 @@ export function readXcodeAppTarget(
     const phase = app.project.object(id)
     if (
       phase?.isa !== 'PBXShellScriptBuildPhase' ||
-      list(phase.inputPaths).length ||
-      list(phase.inputFileListPaths).length ||
       list(phase.outputPaths).length ||
       list(phase.outputFileListPaths).length
     )
@@ -2864,6 +2868,8 @@ export function readXcodeAppTarget(
         str(phase.shellScript) ?? '',
       ),
       directory: app.project.projectDir,
+      inputPaths: list(phase.inputPaths),
+      inputFileListPaths: list(phase.inputFileListPaths),
       environment: Object.fromEntries(
         [...settingKeys]
           .filter((key) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key))