peachsim 0.1.1625 → 0.1.1640

package/src/output-lock-stdio.ts

@@ -0,0 +1,36 @@
+import { fstatSync } from 'node:fs'
+import type { IOType, StdioOptions } from 'node:child_process'
+
+// lock identities name actual inherited descriptors, never paths to reopen.
+export function outputLockStdio(
+  standard: [IOType, IOType, IOType],
+  env: NodeJS.ProcessEnv = process.env,
+): StdioOptions {
+  const stdio: StdioOptions = [...standard]
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith('REMOTE_OUTPUT_LOCK_') && env[key] !== value)
+      throw new Error(`inherited output lock identity changed for ${key}`)
+  }
+  for (const [key, value] of Object.entries(env)) {
+    if (!key.startsWith('REMOTE_OUTPUT_LOCK_')) continue
+    const fd = Number(value)
+    if (
+      !/^REMOTE_OUTPUT_LOCK_[a-f0-9]{64}$/.test(key) ||
+      !value ||
+      !/^\d+$/.test(value) ||
+      !Number.isSafeInteger(fd) ||
+      fd < 3
+    )
+      throw new Error(`invalid inherited output lock descriptor for ${key}`)
+    try {
+      fstatSync(fd)
+    } catch (cause) {
+      throw new Error(`inherited output lock descriptor ${fd} unavailable for ${key}`, {
+        cause,
+      })
+    }
+    while (stdio.length <= fd) stdio.push('ignore')
+    stdio[fd] = fd
+  }
+  return stdio
+}

package/src/process-group.ts

@@ -13,6 +13,7 @@ import { setTimeout as sleep } from 'node:timers/promises'
 
 const GRACEFUL_TIMEOUT_MS = 3_000
 const FORCED_EXIT_TIMEOUT_MS = 1_000
+const FREEZE_GUARD_NAME = 'process-freeze-guard'
 
 // keep this self-contained: the detached browser host embeds its source.
 export function listProcessChildren(parents: number[], timeoutMs = 3_000): number[] {
@@ -107,7 +108,7 @@ async function protectProcessFreeze(rootPid: number) {
     printf 'ready\n'
     if ! IFS= read -r command || [ "$command" != disarm ]; then cleanup; fi
   `,
-      'process-freeze-guard',
+      FREEZE_GUARD_NAME,
       journal,
     ],
     {
@@ -151,6 +152,28 @@ async function protectProcessFreeze(rootPid: number) {
   }
 }
 
+// a nested capture's guard is a descendant of this tree but must keep running
+// to resume its own targets, so a freeze never reaches it. ps exits 1 when
+// some pids already vanished, so only a spawn failure or timeout is an error.
+function withoutFreezeGuards(pids: number[]): number[] {
+  if (pids.length === 0) return pids
+  const result = spawnSync('ps', ['-o', 'pid=,command=', '-p', pids.join(',')], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: FORCED_EXIT_TIMEOUT_MS,
+    killSignal: 'SIGKILL',
+  })
+  if (result.error || (result.status !== 0 && result.status !== 1))
+    throw new Error(result.error?.message || `ps exited ${result.status}`)
+  const guards = new Set(
+    result.stdout
+      .split('\n')
+      .filter((line) => line.includes(FREEZE_GUARD_NAME))
+      .map((line) => Number(line.trim().split(/\s+/)[0])),
+  )
+  return pids.filter((pid) => !guards.has(pid))
+}
+
 // reparented members remain in the group; detached descendants need their
 // recorded pids. both can leave zombies, which signal zero cannot distinguish
 // from running processes. inspect their states together before confirming exit.
@@ -243,7 +266,7 @@ export async function terminateProcessGroup(
       }
       let children: number[]
       try {
-        children = listProcessChildren(parents, remaining)
+        children = withoutFreezeGuards(listProcessChildren(parents, remaining))
       } catch (error) {
         inspectionError = new Error(`could not inspect descendants: ${String(error)}`)
         break

package/src/react-native-bridge-modules.ts

@@ -0,0 +1,431 @@
+// an app's own legacy React Native modules: the classes its Objective-C
+// sources register with RCT_EXPORT_MODULE or RCT_EXTERN_MODULE, read from the
+// app target Xcode builds. the macros' arguments are what clang records for
+// RCTBridge (RCTMethodInfo's js and objc names); the Swift host parses each
+// signature at runtime as RCTModuleMethod does (sootsim-swift React target).
+import fs from 'node:fs'
+import path from 'node:path'
+import { swiftCodeMask, swiftSourceClosure } from './swift-compile'
+import { listXcodeAppTargets, readXcodeAppTarget } from './xcode-project'
+import type { ExpoSwiftSourceUnit } from './expoSwiftContract'
+
+interface MethodInfo {
+  jsName: string
+  objcName: string
+  isSync: boolean
+}
+
+interface ModuleDeclaration {
+  className: string
+  jsName: string
+  // RCT_EXTERN_MODULE declares a class implemented elsewhere, usually Swift
+  extern: boolean
+  file: string
+}
+
+export interface ObjectiveCDeclarations {
+  modules: ModuleDeclaration[]
+  methods: Map<string, MethodInfo[]>
+  superclasses: Map<string, string>
+  // the instance selectors each class's @implementation blocks define
+  implementations: Map<string, Set<string>>
+}
+
+// Objective-C with its comments as spaces, offsets kept
+function stripComments(source: string): string {
+  let out = ''
+  let i = 0
+  while (i < source.length) {
+    const char = source[i]!
+    const next = source[i + 1]
+    if (char === '/' && next === '/') {
+      const end = source.indexOf('\n', i)
+      const stop = end === -1 ? source.length : end
+      out += ' '.repeat(stop - i)
+      i = stop
+    } else if (char === '/' && next === '*') {
+      const end = source.indexOf('*/', i + 2)
+      const stop = end === -1 ? source.length : end + 2
+      out += source.slice(i, stop).replace(/[^\n]/g, ' ')
+      i = stop
+    } else if (char === '"' || char === "'") {
+      let j = i + 1
+      while (j < source.length && source[j] !== char && source[j] !== '\n')
+        j += source[j] === '\\' ? 2 : 1
+      out += source.slice(i, j + 1)
+      i = j + 1
+    } else {
+      out += char
+      i++
+    }
+  }
+  return out
+}
+
+// a macro's arguments split at top-level commas, as the preprocessor does
+function macroArguments(
+  source: string,
+  open: number,
+): { args: string[]; end: number } | null {
+  const args: string[] = []
+  let depth = 0
+  let start = open + 1
+  for (let i = open; i < source.length; i++) {
+    const char = source[i]
+    if (char === '"' || char === "'") {
+      let j = i + 1
+      while (j < source.length && source[j] !== char) j += source[j] === '\\' ? 2 : 1
+      i = j
+    } else if (char === '(') depth++
+    else if (char === ')') {
+      depth--
+      if (depth === 0) {
+        args.push(source.slice(start, i))
+        return { args: args.map((arg) => arg.replace(/\s+/g, ' ').trim()), end: i + 1 }
+      }
+    } else if (char === ',' && depth === 1) {
+      args.push(source.slice(start, i))
+      start = i + 1
+    }
+  }
+  return null
+}
+
+// the selector a method definition's signature names, skipping its types
+function definitionSelector(signature: string): string {
+  let selector = ''
+  let rest = signature.trim()
+  for (;;) {
+    const part = /^([A-Za-z_]\w*)?\s*(:)?\s*/.exec(rest)
+    if (!part || (!part[1] && !part[2])) break
+    selector += (part[1] ?? '') + (part[2] ?? '')
+    rest = rest.slice(part[0].length)
+    if (!part[2]) break
+    if (rest.startsWith('(')) {
+      const type = macroArguments(rest, 0)
+      if (!type) break
+      rest = rest.slice(type.end).trimStart()
+    }
+    rest = rest.replace(/^[A-Za-z_]\w*\s*/, '')
+  }
+  return selector
+}
+
+const DIRECTIVE =
+  /@interface\b|@implementation\b|@end\b|\b(_RCT_EXTERN_REMAP_METHOD|RCT_EXTERN_REMAP_MODULE|RCT_EXTERN_MODULE|RCT_EXPORT_MODULE_NO_LOAD|RCT_EXPORT_MODULE|RCT_EXTERN_METHOD|RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD|RCT_EXPORT_METHOD|RCT_REMAP_METHOD|RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD|RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD|RCT_REMAP_BLOCKING_SYNCHRONOUS_METHOD)\s*\(/g
+
+export function parseObjectiveCModules(
+  sources: { file: string; text: string }[],
+): ObjectiveCDeclarations {
+  const declarations: ObjectiveCDeclarations = {
+    modules: [],
+    methods: new Map(),
+    superclasses: new Map(),
+    implementations: new Map(),
+  }
+  const addMethod = (className: string, method: MethodInfo) => {
+    const methods = declarations.methods.get(className) ?? []
+    methods.push(method)
+    declarations.methods.set(className, methods)
+  }
+  const addSelector = (className: string, selector: string) => {
+    declarations.implementations.get(className)?.add(selector)
+  }
+  for (const { file, text } of sources) {
+    const source = stripComments(text)
+    // the class whose @interface or @implementation encloses a macro
+    let owner: { className: string; implementation: boolean; start: number } | null = null
+    const closeImplementation = (end: number) => {
+      if (!owner?.implementation) return
+      // the instance methods the implementation defines: `- (type)selector {`
+      const body = source.slice(owner.start, end)
+      for (const match of body.matchAll(/^[ \t]*-\s*\(/gm)) {
+        const open = match.index + match[0].length - 1
+        const type = macroArguments(body, open)
+        if (!type) continue
+        const close = body.slice(type.end).search(/[{;]/)
+        if (close === -1) continue
+        const selector = definitionSelector(body.slice(type.end, type.end + close))
+        if (selector) addSelector(owner.className, selector)
+      }
+    }
+    for (const match of source.matchAll(DIRECTIVE)) {
+      const at = match.index
+      const directive = match[0]
+      if (directive === '@end') {
+        closeImplementation(at)
+        owner = null
+        continue
+      }
+      if (directive === '@interface' || directive === '@implementation') {
+        const rest = source.slice(at + directive.length)
+        const extern = /^\s*(RCT_EXTERN_REMAP_MODULE|RCT_EXTERN_MODULE)\s*\(/.exec(rest)
+        if (extern) {
+          const parsed = macroArguments(rest, extern[0].length - 1)
+          if (!parsed) continue
+          const [jsName, className, superclass] =
+            extern[1] === 'RCT_EXTERN_MODULE' ? ['', ...parsed.args] : parsed.args
+          if (!className) continue
+          declarations.modules.push({
+            className,
+            jsName: jsName ?? '',
+            extern: true,
+            file,
+          })
+          if (superclass) declarations.superclasses.set(className, superclass)
+          owner = { className, implementation: false, start: at }
+          continue
+        }
+        const named = /^\s*([A-Za-z_]\w*)\s*(?::\s*([A-Za-z_]\w*))?/.exec(rest)
+        if (!named) continue
+        if (named[2]) declarations.superclasses.set(named[1]!, named[2])
+        if (
+          directive === '@implementation' &&
+          !declarations.implementations.has(named[1]!)
+        )
+          declarations.implementations.set(named[1]!, new Set())
+        owner = {
+          className: named[1]!,
+          implementation: directive === '@implementation',
+          start: at + directive.length + named[0].length,
+        }
+        continue
+      }
+      if (!owner) continue
+      const parsed = macroArguments(source, at + directive.length - 1)
+      if (!parsed) continue
+      const args = parsed.args
+      switch (match[1]) {
+        case 'RCT_EXPORT_MODULE':
+          if (owner.implementation)
+            declarations.modules.push({
+              className: owner.className,
+              jsName: args[0] ?? '',
+              extern: false,
+              file,
+            })
+          break
+        case 'RCT_EXPORT_MODULE_NO_LOAD':
+          declarations.modules.push({
+            className: args[1] || owner.className,
+            jsName: args[0] ?? '',
+            extern: false,
+            file,
+          })
+          break
+        case 'RCT_EXTERN_METHOD':
+        case 'RCT_EXPORT_METHOD':
+          addMethod(owner.className, {
+            jsName: '',
+            objcName: args[0] ?? '',
+            isSync: false,
+          })
+          break
+        case 'RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD':
+        case 'RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD':
+          addMethod(owner.className, {
+            jsName: '',
+            objcName: args[0] ?? '',
+            isSync: true,
+          })
+          break
+        case 'RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD':
+          addMethod(owner.className, {
+            jsName: '',
+            objcName: args[1] ?? '',
+            isSync: true,
+          })
+          break
+        case 'RCT_REMAP_METHOD':
+          addMethod(owner.className, {
+            jsName: args[0] ?? '',
+            objcName: args[1] ?? '',
+            isSync: false,
+          })
+          break
+        case 'RCT_REMAP_BLOCKING_SYNCHRONOUS_METHOD':
+          addMethod(owner.className, {
+            jsName: args[0] ?? '',
+            objcName: args[2] ?? '',
+            isSync: true,
+          })
+          break
+        case '_RCT_EXTERN_REMAP_METHOD':
+          addMethod(owner.className, {
+            jsName: args[0] ?? '',
+            objcName: args[1] ?? '',
+            isSync: args[2] === 'YES',
+          })
+          break
+      }
+    }
+    closeImplementation(source.length)
+  }
+  return declarations
+}
+
+// the superclass Peach compiles that a class's chain reaches
+function compiledSuperclass(
+  className: string,
+  superclasses: Map<string, string>,
+): 'RCTEventEmitter' | 'NSObject' | null {
+  const seen = new Set<string>()
+  let current = superclasses.get(className)
+  while (current && !seen.has(current)) {
+    if (current === 'RCTEventEmitter' || current === 'NSObject') return current
+    seen.add(current)
+    current = superclasses.get(current)
+  }
+  return null
+}
+
+const swiftString = (value: string) => JSON.stringify(value)
+
+function methodsLiteral(methods: MethodInfo[]): string {
+  return `[${methods
+    .map(
+      (method) =>
+        `RCTMethodInfo(jsName: ${swiftString(method.jsName)}, objcName: ${swiftString(method.objcName)}, isSync: ${method.isSync})`,
+    )
+    .join(', ')}]`
+}
+
+// a Swift class exposed to Objective-C as `objcName`: `@objc(objcName)` on it,
+// else a class of that name
+function swiftClassFor(objcName: string, files: Record<string, string>): string | null {
+  const modifiers =
+    '(?:\\s*(?:@\\w+(?:\\([^)]*\\))?|public|open|final|internal|fileprivate|private))*'
+  const exposed = new RegExp(
+    `@objc\\s*\\(\\s*${objcName}\\s*\\)${modifiers}\\s*class\\s+([A-Za-z_]\\w*)`,
+  )
+  const named = new RegExp(`\\bclass\\s+${objcName}\\b`)
+  let fallback: string | null = null
+  for (const source of Object.values(files)) {
+    const code = swiftCodeMask(source)
+    const match = exposed.exec(code)
+    if (match) return match[1]!
+    if (named.test(code)) fallback = objcName
+  }
+  return fallback
+}
+
+export const BRIDGE_MODULE_FILE_PREFIX = '__peach_react_module_'
+
+/**
+ * the app target's legacy bridge modules, one compile unit each, or null
+ * when the app has no iOS project or registers none. a module the host
+ * cannot provide is a unit with a diagnostic instead of files.
+ */
+export function collectBridgeModuleSources(
+  appRoot: string,
+  signal?: AbortSignal,
+): {
+  units: ExpoSwiftSourceUnit[]
+  failures: { namespace: string; diagnostic: string }[]
+} | null {
+  signal?.throwIfAborted()
+  const iosRoot = path.join(appRoot, 'ios')
+  if (!fs.existsSync(iosRoot)) return null
+  const projectRoot = fs.realpathSync(appRoot)
+  const projects = fs
+    .readdirSync(iosRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.endsWith('.xcodeproj'))
+    .map((entry) => path.join(iosRoot, entry.name))
+  const targets = projects.flatMap((project) =>
+    listXcodeAppTargets(project, { requireSources: false }).map((name) => ({
+      project,
+      name,
+    })),
+  )
+  // RCTRegisterModule runs in the one app binary; several targets are
+  // several apps, and nothing here says which one this bundle runs in
+  if (targets.length !== 1) return null
+  const app = readXcodeAppTarget(targets[0]!.project, targets[0]!.name, 'Release', {
+    requireSources: false,
+  })
+  const own = (file: string) => {
+    const resolved = fs.realpathSync(file)
+    if (
+      [file, resolved].some((name) =>
+        name.split(path.sep).some((part) => part === 'Pods' || part === 'node_modules'),
+      )
+    )
+      return false
+    const relative = path.relative(projectRoot, resolved)
+    if (
+      relative === '..' ||
+      relative.startsWith(`..${path.sep}`) ||
+      path.isAbsolute(relative)
+    )
+      throw new Error(`${file}: app native source outside ${projectRoot}`)
+    return true
+  }
+  const objc = app.allSources.filter((file) => /\.mm?$/.test(file) && own(file))
+  if (objc.length === 0) return null
+  // headers declare the superclasses; they sit beside the sources that import them
+  const headers = [...new Set(objc.map((file) => path.dirname(file)))].flatMap((dir) =>
+    fs
+      .readdirSync(dir)
+      .filter((name) => name.endsWith('.h'))
+      .sort()
+      .map((name) => path.join(dir, name))
+      .filter(own),
+  )
+  const declarations = parseObjectiveCModules(
+    [...objc, ...headers].map((file) => ({ file, text: fs.readFileSync(file, 'utf8') })),
+  )
+  if (declarations.modules.length === 0) return null
+  const namespace = app.moduleName.replace(/[^A-Za-z0-9_]/g, '_')
+  const swiftFiles: Record<string, string> = {}
+  for (const file of app.sources.filter(own)) {
+    const relative = path.relative(projectRoot, fs.realpathSync(file))
+    swiftFiles[`Sources/${namespace}/${relative.split(path.sep).join('/')}`] =
+      `#sourceLocation(file: ${JSON.stringify(file)}, line: 1)\n${fs.readFileSync(file, 'utf8')}`
+  }
+  const units: ExpoSwiftSourceUnit[] = []
+  const failures: { namespace: string; diagnostic: string }[] = []
+  const seen = new Set<string>()
+  for (const module of declarations.modules) {
+    signal?.throwIfAborted()
+    if (seen.has(module.className)) continue
+    seen.add(module.className)
+    const moduleId = `${namespace}.${module.className}`
+    const methods = declarations.methods.get(module.className) ?? []
+    const swiftClass = module.extern ? swiftClassFor(module.className, swiftFiles) : null
+    const unit: ExpoSwiftSourceUnit = {
+      namespace,
+      moduleId,
+      classes: [],
+      bridgeModules: [],
+      files: {},
+      frameworks: [],
+      swiftLanguageMode: app.languageMode,
+    }
+    if (swiftClass) {
+      const register = `__peachReactModule_${module.className}`
+      unit.files = swiftSourceClosure(swiftFiles, [swiftClass])
+      unit.files[
+        `Sources/${namespace}/${BRIDGE_MODULE_FILE_PREFIX}${module.className}.swift`
+      ] =
+        `import React\n\n// ${module.file}: RCT_EXTERN_MODULE(${module.className})\npublic func ${register}() -> RCTModuleHost.Registration {\n  RCTModuleHost.Registration(className: ${swiftString(module.className)}, moduleName: ${swiftString(module.jsName)}, methods: ${methodsLiteral(methods)}, make: { ${swiftClass}() })\n}\n`
+      unit.bridgeModules = [`${namespace}.${register}()`]
+    } else {
+      const superclass = compiledSuperclass(module.className, declarations.superclasses)
+      const selectors = declarations.implementations.get(module.className)
+      if (!selectors || !superclass) {
+        failures.push({
+          namespace: moduleId,
+          diagnostic: !selectors
+            ? `${module.file}: no Swift class or Objective-C @implementation provides ${module.className}`
+            : `${module.file}: ${module.className}'s superclass ${declarations.superclasses.get(module.className) ?? '(none)'} is Objective-C, which Peach does not compile`,
+        })
+        continue
+      }
+      unit.bridgeModules = [
+        `RCTModuleHost.Registration(className: ${swiftString(module.className)}, moduleName: ${swiftString(module.jsName)}, methods: ${methodsLiteral(methods)}, objectiveCSelectors: ${JSON.stringify([...selectors].sort())}, superclass: { ${superclass}() })`,
+      ]
+    }
+    units.push(unit)
+  }
+  return { units, failures }
+}

package/src/react-native-host-modules.ts

@@ -18,6 +18,10 @@ export const REACT_NATIVE_PASSTHROUGH_SPECIFIERS: readonly string[] = [
   // expo's metro-runtime dials metro's message socket with this WebSocket,
   // which runs against the engine's WebSocketModule and BlobModule.
   'react-native/Libraries/WebSocket',
+  // that WebSocket extends upstream's EventTarget and builds its MessageEvent
+  // and CloseEvent from the same dom event classes; a stubbed class there is
+  // not a constructor to extend.
+  'react-native/src/private/webapis',
   'react-native/Libraries/Blob/Blob',
   'react-native/Libraries/Blob/BlobManager',
   'react-native/Libraries/Blob/BlobRegistry',
@@ -39,7 +43,10 @@ export const REACT_NATIVE_PASSTHROUGH_SPECIFIERS: readonly string[] = [
 ]
 
 export function isReactNativePassthroughSpecifier(specifier: string): boolean {
+  // checked in place: every module of a bundle asks at boot
   return REACT_NATIVE_PASSTHROUGH_SPECIFIERS.some(
-    (passthrough) => specifier === passthrough || specifier.startsWith(`${passthrough}/`),
+    (passthrough) =>
+      specifier.startsWith(passthrough) &&
+      (specifier.length === passthrough.length || specifier[passthrough.length] === '/'),
   )
 }

package/src/settings-bundle.ts

@@ -1,5 +1,6 @@
 import { readFile, readdir, stat } from 'node:fs/promises'
 import { join } from 'node:path'
+import { isRecord } from './is-record'
 import { parsePlistSource } from './plist.ts'
 import type { AppPreferenceValue, AppSettingsSpecifier } from '@peach/globals'
 
@@ -22,10 +23,6 @@ interface CachedSettingsBundle {
 
 const settingsBundleCache = new Map<string, CachedSettingsBundle>()
 
-function isRecord(value: unknown): value is PlistRecord {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
 function optionalString(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined
 }

package/src/swift-binary-modules.ts

@@ -6,11 +6,11 @@
 
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
+import { cacheDir as peachCacheDir } from './home-paths'
 import type { SwiftPackageBinary } from './swift-packages'
 
-const cacheDir = path.join(os.tmpdir(), 'peach-swift-binary-modules')
+const cacheDir = path.join(peachCacheDir(), 'swift-binary-modules')
 
 // the first `<name>.framework` segment of each path: a framework's own
 // nested frameworks and macOS Versions/ trees are not modules of the target