peachsim 0.1.668 → 0.1.670

package/src/native-firebase-config.ts

@@ -1,4 +1,4 @@
-// the native installer reads Expo's googleServicesFile before Firebase starts.
+// read native default initialization inputs before the guest Firebase SDK starts.
 // expose only FirebaseOptions, never a partner-specific extra configuration.
 import fs from 'node:fs'
 import { createRequire } from 'node:module'
@@ -6,29 +6,210 @@ import path from 'node:path'
 import { isRecord } from './is-record'
 import { parsePlistSource } from './plist'
 
-export function readNativeFirebaseConfig(projectRoot: string) {
+export function readNativeFirebaseConfig(
+  projectRoot: string,
+  platforms: readonly string[] = ['ios', 'android'],
+) {
   const result: Record<string, unknown> = {}
+  let config: Record<string, unknown> = {}
+  const appJsonPath = path.join(projectRoot, 'app.json')
+  const appJson: unknown = fs.existsSync(appJsonPath)
+    ? JSON.parse(fs.readFileSync(appJsonPath, 'utf8'))
+    : null
+  const staticExpo =
+    isRecord(appJson) &&
+    (isRecord(appJson.expo) ||
+      [appJson.ios, appJson.android].some(
+        (value) => isRecord(value) && typeof value.googleServicesFile === 'string',
+      ))
+  const dynamicExpo = [
+    'app.config.js',
+    'app.config.ts',
+    'app.config.cjs',
+    'app.config.mjs',
+  ].some((name) => fs.existsSync(path.join(projectRoot, name)))
+  if (staticExpo || dynamicExpo) {
+    const require = createRequire(path.join(projectRoot, 'package.json'))
+    const configModule: unknown = require('@expo/config')
+    if (!isRecord(configModule) || typeof configModule.getConfig !== 'function')
+      throw new Error('Expo native configuration is unavailable.')
+    const resolved: unknown = Reflect.apply(configModule.getConfig, configModule, [
+      projectRoot,
+      { skipSDKVersionRequirement: true },
+    ])
+    config = isRecord(resolved) && isRecord(resolved.exp) ? resolved.exp : {}
+  }
+  const ios = config.ios
   if (
-    ![
-      'app.json',
-      'app.config.js',
-      'app.config.ts',
-      'app.config.cjs',
-      'app.config.mjs',
-    ].some((name) => fs.existsSync(path.join(projectRoot, name)))
-  )
-    return result
-  const require = createRequire(path.join(projectRoot, 'package.json'))
-  const configModule: unknown = require('@expo/config')
-  if (!isRecord(configModule) || typeof configModule.getConfig !== 'function') {
-    throw new Error('Expo native configuration is unavailable.')
+    platforms.includes('ios') &&
+    (!isRecord(ios) || typeof ios.googleServicesFile !== 'string')
+  ) {
+    const iosRoot = path.join(projectRoot, 'ios')
+    if (fs.existsSync(iosRoot)) {
+      const projects = fs
+        .readdirSync(iosRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.endsWith('.xcodeproj'))
+      if (projects.length > 1)
+        throw new Error('native Firebase configuration requires a selected Xcode project')
+      if (projects.length === 1) {
+        const require = createRequire(path.join(projectRoot, 'package.json'))
+        const xcode: unknown = require('xcode')
+        if (!isRecord(xcode) || typeof xcode.project !== 'function')
+          throw new Error('native Xcode project parser is unavailable')
+        const project: unknown = Reflect.apply(xcode.project, xcode, [
+          path.join(iosRoot, projects[0].name, 'project.pbxproj'),
+        ])
+        if (!isRecord(project) || typeof project.parseSync !== 'function')
+          throw new Error('native Xcode project is malformed')
+        Reflect.apply(project.parseSync, project, [])
+        const hash = project.hash
+        const native = isRecord(hash) ? hash.project : null
+        const objects = isRecord(native) ? native.objects : null
+        if (!isRecord(objects)) throw new Error('native Xcode objects are malformed')
+        const unquote = (value: unknown) =>
+          typeof value === 'string' ? value.replace(/^"|"$/g, '') : ''
+        const targets = isRecord(objects.PBXNativeTarget)
+          ? Object.values(objects.PBXNativeTarget).filter(
+              (target) =>
+                isRecord(target) &&
+                unquote(target.productType) === 'com.apple.product-type.application',
+            )
+          : []
+        if (targets.length > 1)
+          throw new Error('native Firebase configuration requires a selected app target')
+        const target = targets[0]
+        if (isRecord(target) && Array.isArray(target.buildPhases)) {
+          const buildPhases: readonly unknown[] = target.buildPhases
+          const filePaths = new Map<string, Set<string>>()
+          const groups = isRecord(objects.PBXGroup) ? objects.PBXGroup : {}
+          const references = isRecord(objects.PBXFileReference)
+            ? objects.PBXFileReference
+            : {}
+          const nativeProjects = isRecord(objects.PBXProject)
+            ? Object.values(objects.PBXProject)
+            : []
+          const roots = nativeProjects.filter(isRecord).map((value) => value.mainGroup)
+          const pending = roots
+            .filter((id): id is string => typeof id === 'string')
+            .map((id) => ({ id, base: iosRoot }))
+          const visited = new Map<string, string>()
+          while (pending.length) {
+            const item = pending.pop()
+            if (!item) break
+            const previous = visited.get(item.id)
+            if (previous !== undefined) {
+              if (previous !== item.base)
+                throw new Error('native Xcode group has ambiguous parents')
+              continue
+            }
+            visited.set(item.id, item.base)
+            const group = groups[item.id]
+            if (!isRecord(group) || !Array.isArray(group.children)) continue
+            const sourceTree = unquote(group.sourceTree)
+            if (sourceTree && sourceTree !== '<group>' && sourceTree !== 'SOURCE_ROOT')
+              continue
+            const directory = path.resolve(
+              sourceTree === 'SOURCE_ROOT' ? iosRoot : item.base,
+              unquote(group.path),
+            )
+            for (const child of group.children) {
+              if (!isRecord(child) || typeof child.value !== 'string') continue
+              if (isRecord(groups[child.value])) {
+                pending.push({ id: child.value, base: directory })
+                continue
+              }
+              const file = references[child.value]
+              if (!isRecord(file)) continue
+              const tree = unquote(file.sourceTree)
+              if (tree !== '<group>' && tree !== 'SOURCE_ROOT') continue
+              const filePath = path.resolve(
+                tree === 'SOURCE_ROOT' ? iosRoot : directory,
+                unquote(file.path),
+              )
+              const values = filePaths.get(child.value) ?? new Set<string>()
+              values.add(filePath)
+              filePaths.set(child.value, values)
+            }
+          }
+          const buildFiles = isRecord(objects.PBXBuildFile) ? objects.PBXBuildFile : {}
+          const filesInPhase = (section: unknown, name: RegExp): string[] => {
+            if (!isRecord(section)) return []
+            const paths: string[] = []
+            for (const phase of buildPhases) {
+              if (!isRecord(phase) || typeof phase.value !== 'string') continue
+              const value = section[phase.value]
+              if (!isRecord(value) || !Array.isArray(value.files)) continue
+              for (const entry of value.files) {
+                if (!isRecord(entry) || typeof entry.value !== 'string') continue
+                const file = buildFiles[entry.value]
+                if (!isRecord(file) || typeof file.fileRef !== 'string') continue
+                const reference = references[file.fileRef]
+                if (
+                  !isRecord(reference) ||
+                  !name.test(path.basename(unquote(reference.path)))
+                )
+                  continue
+                const candidates = filePaths.get(file.fileRef)
+                if (!candidates || candidates.size !== 1)
+                  throw new Error('native Firebase build resource path is unresolved')
+                paths.push(...candidates)
+              }
+            }
+            return paths
+          }
+          const delegates = filesInPhase(
+            objects.PBXSourcesBuildPhase,
+            /^AppDelegate\.(swift|mm|m)$/,
+          )
+          const defaultConfigured = delegates.some((file) => {
+            const source = fs
+              .readFileSync(file, 'utf8')
+              .replace(/\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:\\.|[^"\\])*"/g, (token) =>
+                token.startsWith('"') ? '""' : token.replace(/[^\n]/g, ' '),
+              )
+            const launch =
+              /(?:\bfunc\s+application\s*\([\s\S]*?didFinishLaunchingWithOptions[\s\S]*?\)\s*->\s*Bool|^-\s*\(BOOL\)\s*application\s*:[\s\S]*?didFinishLaunchingWithOptions[^\{]*)\s*\{/m.exec(
+                source,
+              )
+            if (!launch) return false
+            const body = source.slice(launch.index + launch[0].length)
+            const configure =
+              /^\s*(?:FirebaseApp\s*\.\s*configure\s*\(\s*\)|\[FIRApp\s+configure\])/m.exec(
+                body,
+              )
+            if (!configure) return false
+            const before = body.slice(0, configure.index)
+            let depth = 1
+            for (const token of before) {
+              if (token === '{') depth += 1
+              if (token === '}') depth -= 1
+              if (depth === 0) return false
+            }
+            if (
+              depth !== 1 ||
+              /\b(?:return|throw)\b|^\s*#(?:if|elseif|else)/m.test(before)
+            )
+              throw new Error(
+                'native Firebase initialization must be unconditional in the app launch method',
+              )
+            return true
+          })
+          if (defaultConfigured) {
+            const resources = filesInPhase(
+              objects.PBXResourcesBuildPhase,
+              /^GoogleService-Info\.plist$/,
+            )
+            if (resources.length !== 1)
+              throw new Error(
+                'native Firebase default initialization requires one GoogleService-Info.plist build resource',
+              )
+            config.ios = { googleServicesFile: path.relative(projectRoot, resources[0]) }
+          }
+        }
+      }
+    }
   }
-  const resolved: unknown = Reflect.apply(configModule.getConfig, configModule, [
-    projectRoot,
-    { skipSDKVersionRequirement: true },
-  ])
-  const config = isRecord(resolved) && isRecord(resolved.exp) ? resolved.exp : {}
-  for (const platform of ['ios', 'android']) {
+  for (const platform of platforms) {
     const native = config[platform]
     if (!isRecord(native) || typeof native.googleServicesFile !== 'string') continue
     try {

package/src/native-firebase-metadata.ts

@@ -0,0 +1,114 @@
+// native Firebase options travel before the Metro module identity footer.
+// the guest SDK snapshots these constants before its first getApp call.
+export interface NativeFirebaseOptions {
+  apiKey: string
+  appId: string
+  projectId: string
+  databaseURL?: string
+  gaTrackingId?: string
+  storageBucket?: string
+  messagingSenderId?: string
+  clientId?: string
+  androidClientID?: string
+  deepLinkUrlScheme?: string
+}
+
+export type NativeFirebaseConfig = Partial<
+  Record<'ios' | 'android', NativeFirebaseOptions>
+>
+
+const PREFIX = 'globalThis.__peachNativeFirebaseConfig='
+const MODULE_PREFIX = 'globalThis.__sootsimModulePaths='
+const PLATFORMS = ['ios', 'android'] as const
+
+export function readNativeFirebaseMetadata(value: unknown): NativeFirebaseConfig | null {
+  if (value === null || value === undefined) return null
+  if (typeof value !== 'object' || Array.isArray(value))
+    throw new Error('native Firebase configuration is malformed')
+  if (Object.keys(value).some((key) => !PLATFORMS.some((name) => name === key)))
+    throw new Error('native Firebase configuration has an invalid platform')
+  const result: NativeFirebaseConfig = {}
+  for (const platform of PLATFORMS) {
+    const options: unknown = Reflect.get(value, platform)
+    if (options === undefined) continue
+    if (!options || typeof options !== 'object' || Array.isArray(options))
+      throw new Error('native Firebase options are malformed')
+    const error: unknown = Reflect.get(options, 'error')
+    if (typeof error === 'string')
+      throw new Error(`native Firebase configuration: ${error}`)
+    const apiKey: unknown = Reflect.get(options, 'apiKey')
+    const appId: unknown = Reflect.get(options, 'appId')
+    const projectId: unknown = Reflect.get(options, 'projectId')
+    if (
+      typeof apiKey !== 'string' ||
+      !apiKey ||
+      typeof appId !== 'string' ||
+      !appId ||
+      typeof projectId !== 'string' ||
+      !projectId
+    )
+      throw new Error('native Firebase options require apiKey, appId and projectId')
+    const native: NativeFirebaseOptions = { apiKey, appId, projectId }
+    for (const key of [
+      'databaseURL',
+      'gaTrackingId',
+      'storageBucket',
+      'messagingSenderId',
+      'clientId',
+      'androidClientID',
+      'deepLinkUrlScheme',
+    ] as const) {
+      const field: unknown = Reflect.get(options, key)
+      if (field === undefined) continue
+      if (typeof field !== 'string')
+        throw new Error(`native Firebase option ${key} is malformed`)
+      native[key] = field
+    }
+    result[platform] = native
+  }
+  return result
+}
+
+export function createNativeFirebaseFooter(config: NativeFirebaseConfig): string {
+  const json = JSON.stringify(config)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/<\//g, '<\\/')
+  return `\n${PREFIX}${json};`
+}
+
+export function readNativeFirebaseFooter(source: string): NativeFirebaseConfig | null {
+  const start = source.lastIndexOf(`\n${PREFIX}`)
+  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 Firebase footer is truncated')
+  const parsed: unknown = JSON.parse(line.slice(PREFIX.length, -1))
+  const config = readNativeFirebaseMetadata(parsed)
+  if (config === null) throw new Error('native Firebase footer has no configuration')
+  return config
+}
+
+export function detachNativeFirebaseFooter(source: string): {
+  source: string
+  config: NativeFirebaseConfig | null
+} {
+  const config = readNativeFirebaseFooter(source)
+  if (config === null) return { source, config }
+  const start = source.lastIndexOf(`\n${PREFIX}`)
+  const lineEnd = source.indexOf('\n', start + 1)
+  const end = lineEnd < 0 ? source.length : lineEnd
+  return { source: source.slice(0, start) + source.slice(end), config }
+}
+
+export function insertNativeFirebaseFooter(
+  source: string,
+  config: NativeFirebaseConfig,
+): string {
+  const detached = detachNativeFirebaseFooter(source).source
+  const start = detached.lastIndexOf(`\n${MODULE_PREFIX}`)
+  const footer = createNativeFirebaseFooter(config)
+  return start < 0
+    ? detached + footer
+    : detached.slice(0, start) + footer + detached.slice(start)
+}

package/src/swift-host.ts

@@ -600,16 +600,11 @@ async function compile(
       stamp,
       package: content,
     }
-  const toolchain: unknown = JSON.parse(
-    fs.readFileSync(path.join(moduleRoot, 'toolchain.json'), 'utf8'),
-  )
-  const release =
-    toolchain && typeof toolchain === 'object'
-      ? Reflect.get(toolchain, 'release')
-      : undefined
-  if (typeof release !== 'string') {
-    throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`)
-  }
+  const toolchain = localSwiftToolchain(moduleRoot)
+  if (!toolchain)
+    throw new Error(
+      `the Swift toolchain ${moduleRoot}/toolchain.json names is not installed under ~/Library/Developer/Toolchains`,
+    )
   const artifact = await compileSwiftProjectUnit(snapshotCompileInput(snapshot, entry), {
     // the compile rewrites Sources/App in its root before swiftpm builds, and
     // its lock orders one process only: two vites on one root (a lane's dev
@@ -627,15 +622,35 @@ async function compile(
           .slice(0, 16),
       ),
     moduleRoot,
-    release,
-    toolchainBin: path.join(
-      os.homedir(),
-      `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`,
-    ),
+    ...toolchain,
   })
   return { ...artifact, stamp, package: content }
 }
 
+// the release a SwiftUI module checkout builds with and its installed
+// toolchain; null when the checkout or the toolchain is missing.
+export function localSwiftToolchain(
+  moduleRoot: string,
+): { release: string; toolchainBin: string } | null {
+  const manifest = path.join(moduleRoot, 'toolchain.json')
+  if (!fs.existsSync(manifest)) return null
+  const toolchain: unknown = JSON.parse(fs.readFileSync(manifest, 'utf8'))
+  const release =
+    toolchain && typeof toolchain === 'object'
+      ? Reflect.get(toolchain, 'release')
+      : undefined
+  if (typeof release !== 'string') {
+    throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`)
+  }
+  const toolchainBin = path.join(
+    os.homedir(),
+    `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`,
+  )
+  return fs.existsSync(path.join(toolchainBin, 'swift'))
+    ? { release, toolchainBin }
+    : null
+}
+
 // an npm-installed peachsim ships neither the SwiftUI module nor a toolchain,
 // so the package compiles where a Contrast project's does: Contrast's compile
 // route, authorized by `peach login` or PEACH_API_KEY. the service renders the

package/src/vite-plugin.ts

@@ -33,6 +33,7 @@ import {
 } from '../../peach-compat/src/stub-manifest.ts'
 import { isExpoHostSocketModule } from '../../peach-engine/src/guest-module-overrides.ts'
 import { resolveSootsimBridgePort } from './bridge-constants.ts'
+import { isRecord } from './is-record.ts'
 import {
   SHELL_BRIDGE_IDENTITY_PATH,
   type ShellBridgeIdentity,
@@ -2023,17 +2024,39 @@ async function getDomBabelCore() {
   return domBabelCorePromise
 }
 
+export const PEACH_DOM_SOURCE_MANIFEST = 'peach-dom-sources.json'
+
 export function expoDomComponentsPlugin(
   options: {
     appDir?: string
     projectRoot?: string
+    sourceManifests?: string[]
   } = {},
 ): Plugin {
   let isProduction = false
   const appDir = options.appDir ? path.resolve(options.appDir) : ''
-  const projectRoot = options.projectRoot ?? appDir ?? workspaceRoot
+  const projectRoot = options.projectRoot ?? (appDir || workspaceRoot)
   const domHashMap = new Map<string, string>()
   const domWebModuleIds = new Set<string>()
+  const deliveredSources = new Map<string, string>()
+  let sourcesLoaded = false
+
+  function loadDeliveredSources() {
+    if (sourcesLoaded) return
+    for (const manifest of options.sourceManifests ?? []) {
+      const sources: unknown = JSON.parse(fs.readFileSync(manifest, 'utf8'))
+      if (!isRecord(sources)) throw new Error(`invalid DOM source manifest: ${manifest}`)
+      for (const [reference, relativePath] of Object.entries(sources)) {
+        if (typeof relativePath !== 'string' || path.isAbsolute(relativePath)) {
+          throw new Error(`invalid DOM source path: ${reference}`)
+        }
+        const localUrl = pathToFileURL(path.resolve(projectRoot, relativePath)).href
+        deliveredSources.set(reference, localUrl)
+        domHashMap.set(crypto.createHash('md5').update(reference).digest('hex'), localUrl)
+      }
+    }
+    sourcesLoaded = true
+  }
 
   // specifiers that must stay runtime requires served by the page's
   // window.require shim instead of becoming static imports:
@@ -2133,6 +2156,24 @@ export function expoDomComponentsPlugin(
         (config.mode === 'production' || config.isProduction) &&
         process.env.SOOTSIM_TENANT_BUILD_MODE !== 'development'
     },
+    generateBundle() {
+      const sources = Object.fromEntries(
+        [...domHashMap.values()]
+          .sort()
+          .map((reference) => [
+            reference,
+            path
+              .relative(projectRoot, fileURLToPath(reference))
+              .split(path.sep)
+              .join('/'),
+          ]),
+      )
+      this.emitFile({
+        type: 'asset',
+        fileName: PEACH_DOM_SOURCE_MANIFEST,
+        source: JSON.stringify(sources),
+      })
+    },
     configureServer(server) {
       server.middlewares.use((req, res, next) => {
         if (!req.url) return next()
@@ -2142,6 +2183,7 @@ export function expoDomComponentsPlugin(
           rawUrl.startsWith('/www.bundle') ||
           rawUrl.startsWith('www.bundle')
         if (!isDomRoute) return next()
+        loadDeliveredSources()
 
         const url = new URL(
           rawUrl.startsWith('/') ? rawUrl : '/' + rawUrl,
@@ -2499,7 +2541,9 @@ export default NoopMetroHMRClient;
       if (id.startsWith(`${virtualIdPrefix}_expo_dom_entry`)) {
         const query = id.slice(`${virtualIdPrefix}_expo_dom_entry`.length)
         const params = new URLSearchParams(query)
-        const fileUrl = params.get('file')
+        loadDeliveredSources()
+        const reference = params.get('file')
+        const fileUrl = reference && (deliveredSources.get(reference) ?? reference)
         if (!fileUrl) {
           throw new Error(`Missing file query param in DOM component entry: ${id}`)
         }

package/kotlin/AppSources/androidx/activity/Cancellable.kt

@@ -1,5 +0,0 @@
-package androidx.activity
-
-internal interface Cancellable {
-    fun cancel()
-}