peachsim 0.1.2199 → 0.1.2200

package/src/react-native-core-build.ts

@@ -0,0 +1,176 @@
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { cacheDir } from './home-paths'
+import { describeNativeEntry, nativeEntryCache, nativeEntryKey } from './native-prebuilt'
+import {
+  reactNativeCoreEntry,
+  reactNativeCoreFloor,
+  type ReactNativeCoreMode,
+} from './react-native-core'
+import { compileSwiftProjectUnit } from './swift-compile'
+import { swiftModuleToolchain } from './swift-distribution'
+import { isSwiftNativeTranslationUnit, swiftManifestTargets } from './swift-package'
+import { withSwiftRootLock } from './swift-root-lock'
+import { collectTurboCompileInput } from './turbo-compile'
+import { collectTurboSources, prepareTurboSourceDependencies } from './turbo-source'
+
+/** builds the React Native core for an installed app into the local
+ *  native-prebuilt cache, the directory a published entry downloads into, and
+ *  returns that directory. an entry already in the cache is returned as is. */
+export async function buildReactNativeCore(
+  project: string,
+  reactNativeRoot: string,
+  mode: ReactNativeCoreMode,
+  moduleRoot: string,
+): Promise<string> {
+  const entry = reactNativeCoreEntry(reactNativeRoot, moduleRoot, mode)
+  const directory = nativeEntryCache('react-native', entry.name, entry.key)
+  const work = path.join(cacheDir(), 'react-native-core-build', entry.key)
+  return withSwiftRootLock(work, async () => {
+    if (fs.existsSync(path.join(directory, 'descriptor.json'))) return directory
+    const module = { root: moduleRoot, ...swiftModuleToolchain(moduleRoot) }
+    const floor = reactNativeCoreFloor(reactNativeRoot)
+    await prepareTurboSourceDependencies(reactNativeRoot)
+    const codegenDir = path.join(work, 'codegen')
+    fs.mkdirSync(work, { recursive: true })
+    fs.rmSync(codegenDir, { recursive: true, force: true })
+    const collection = await collectTurboSources({
+      appRoot: project,
+      projectRoot: project,
+      reactNativeRoot,
+      providers: [],
+      codegenDir,
+      ...(mode === 'turbo-cxx'
+        ? { reactNativeCore: true }
+        : { reactNativeProvider: true }),
+      ...(mode === 'turbo' ? { turboDispatch: true } : {}),
+    })
+    const producer = {
+      ...collection,
+      files: { ...collection.files },
+      targets: [...collection.targets],
+    }
+    if (mode === 'turbo') {
+      // only the producer executable supplies this host callback; it is absent from the archives.
+      producer.targets.push({
+        name: 'PeachCoreProducerHost',
+        path: 'Sources/PeachCoreProducerHost',
+        executable: false,
+        languageMode: 5,
+        mainActorIsolation: false,
+        resources: false,
+        clangSettings: [{ tool: 'c', flags: ['-fblocks'] }],
+      })
+      producer.files['Sources/PeachCoreProducerHost/include/PeachCoreProducerHost.h'] =
+        '#pragma once\n'
+      producer.files['Sources/PeachCoreProducerHost/Dispatch.m'] =
+        '#import <dispatch/dispatch.h>\nvoid peachTurboDispatchAsync(dispatch_block_t block) { dispatch_async(dispatch_get_main_queue(), block); }\n'
+    }
+    const input = collectTurboCompileInput(producer, null, floor)
+    const { compiler: _compiler, recipe: _recipe, ...nativeInputs } = entry.inputs
+    const buildRoot = path.join(
+      cacheDir(),
+      'react-native-core-products',
+      nativeEntryKey(nativeInputs),
+    )
+    await compileSwiftProjectUnit(input, {
+      ...module,
+      moduleRoot: module.root,
+      buildRoot,
+      intermediates: true,
+    })
+    const products = path.join(buildRoot, '.build/wasm32-unknown-wasip1/release')
+    const emitted = swiftManifestTargets(
+      fs.readFileSync(path.join(buildRoot, 'Package.swift'), 'utf8'),
+    )
+    const libraries: Record<string, string> = {}
+    const binaryModules: Record<string, string> = {}
+    for (const target of collection.targets) {
+      const objects = emitted
+        .filter((product) => !product.executable && product.path === target.path)
+        .flatMap((product) => {
+          const built = path.join(products, `${product.name}.build`)
+          return fs
+            .readdirSync(built, { recursive: true, encoding: 'utf8' })
+            .filter((file) => file.endsWith('.o'))
+            .map((file) => path.join(built, file))
+        })
+        .sort()
+      if (objects.length === 0)
+        throw new Error(`${target.name}: core build produced no objects`)
+      const members = path.join(work, 'members', target.name)
+      fs.rmSync(members, { recursive: true, force: true })
+      fs.mkdirSync(members, { recursive: true })
+      const stripped = objects.map((file, index) => {
+        const output = path.join(members, `${index}-${path.basename(file)}`)
+        execFileSync(path.join(module.toolchainBin, 'llvm-objcopy'), [
+          '--strip-debug',
+          file,
+          output,
+        ])
+        return output
+      })
+      const archive = path.join(work, `lib${target.name}.a`)
+      fs.rmSync(archive, { force: true })
+      execFileSync(path.join(module.toolchainBin, 'llvm-ar'), [
+        'rcsD',
+        archive,
+        ...stripped,
+      ])
+      libraries[target.name] = fs.readFileSync(archive).toString('base64')
+      const swiftModule = path.join(products, 'Modules', `${target.name}.swiftmodule`)
+      if (fs.existsSync(swiftModule)) {
+        binaryModules[target.name] = fs.readFileSync(swiftModule).toString('base64')
+        collection.files[
+          `Sources/TurboCore/include/${target.name}/${target.name}-Swift.h`
+        ] = fs.readFileSync(
+          path.join(buildRoot, '.build/peach-cxx-headers', `${target.name}-Swift.h`),
+          'utf8',
+        )
+      }
+      // keep textually included implementations available to the preprocessor.
+      target.exclude = [
+        ...new Set([
+          ...(target.exclude ?? []),
+          ...Object.keys(collection.files)
+            .filter(
+              (file) =>
+                file.startsWith(`${target.path}/`) &&
+                (isSwiftNativeTranslationUnit(file) || file.endsWith('.swift')),
+            )
+            .map((file) => file.slice(target.path.length + 1)),
+        ]),
+      ]
+      collection.files[`${target.path}/PeachPrebuiltCore.c`] = '\n'
+      collection.files[`${target.path}/include/PeachPrebuiltCore.h`] = '#pragma once\n'
+    }
+    const prebuilt = collectTurboCompileInput(collection, null, floor)
+    const core = {
+      files: prebuilt.files,
+      entry: prebuilt.entry,
+      libraries,
+      binaryModules,
+      staticClangTargets: prebuilt.staticClangTargets ?? [],
+      ...(prebuilt.headerAliases ? { headerAliases: prebuilt.headerAliases } : {}),
+      ...(prebuilt.nativeTargets ? { nativeTargets: prebuilt.nativeTargets } : {}),
+    }
+    // the descriptor lands last, by rename, so a reader never sees a partial entry.
+    const staging = `${directory}.${process.pid}.building`
+    fs.rmSync(staging, { recursive: true, force: true })
+    fs.mkdirSync(staging, { recursive: true })
+    const coreFile = path.join(staging, 'core.json')
+    fs.writeFileSync(coreFile, JSON.stringify(core))
+    const descriptor = describeNativeEntry('react-native', entry.name, entry.inputs, [
+      coreFile,
+    ])
+    fs.writeFileSync(path.join(staging, 'descriptor.json'), JSON.stringify(descriptor))
+    fs.mkdirSync(path.dirname(directory), { recursive: true })
+    fs.rmSync(directory, { recursive: true, force: true })
+    fs.renameSync(staging, directory)
+    console.error(
+      `[peach] React Native core ${entry.name}: built ${collection.targets.length} targets locally`,
+    )
+    return directory
+  })
+}

package/src/react-native-core-digest.ts

@@ -10,7 +10,7 @@ export const REACT_NATIVE_CORE_SOURCES = [
   'nitro-dependencies.ts',
   'nitroAdapterContract.ts',
   'podspec-sources.ts',
-  '../../../scripts/lib/react-native-core.ts',
+  'react-native-core-build.ts',
 ]
 
 export function reactNativeCoreDigest(directory: string): string {

package/src/react-native-core.ts

@@ -152,17 +152,34 @@ export function reactNativeCoreEntry(
   return { name, inputs, key: nativeEntryKey(inputs) }
 }
 
-export function prebuiltReactNativeCore(
+// the published core is a cache of this build: a cli whose compiler or a
+// runtime whose distribution has no published entry yet builds it once into the
+// same local cache instead of refusing the app.
+const building = new Map<string, Promise<string>>()
+
+export async function prebuiltReactNativeCore(
+  project: string,
   reactNativeRoot: string,
   moduleRoot: string,
   mode: ReactNativeCoreMode,
-): ReactNativeCoreInput {
+): Promise<ReactNativeCoreInput> {
   const entry = reactNativeCoreEntry(reactNativeRoot, moduleRoot, mode)
-  const dir = fetchNativeEntry('react-native', entry.name, entry.key)
-  if (!dir)
-    throw new Error(
-      `no prebuilt React Native ${entry.inputs['react-native']} ${mode} core for headers ${entry.inputs.headers}; publish ${NATIVE_PREBUILT_ORIGIN}/${nativeEntryPrefix('react-native', entry.name, entry.key)}/descriptor.json before opening this app`,
-    )
+  let dir = fetchNativeEntry('react-native', entry.name, entry.key)
+  if (!dir) {
+    let pending = building.get(entry.key)
+    if (!pending) {
+      console.error(
+        `[peach] no published React Native ${entry.name} core at ${NATIVE_PREBUILT_ORIGIN}/${nativeEntryPrefix('react-native', entry.name, entry.key)}; building it locally`,
+      )
+      pending = import('./react-native-core-build')
+        .then(({ buildReactNativeCore }) =>
+          buildReactNativeCore(project, reactNativeRoot, mode, moduleRoot),
+        )
+        .finally(() => building.delete(entry.key))
+      building.set(entry.key, pending)
+    }
+    dir = await pending
+  }
   const file = path.join(dir, 'core.json')
   const descriptor: unknown = JSON.parse(
     fs.readFileSync(path.join(dir, 'descriptor.json'), 'utf8'),

package/src/swift-standin-emit.ts

@@ -1296,8 +1296,16 @@ export function emitSwiftStandin(
         [...superChain(owner.get(member.identifier.precise) ?? '')].some((at) =>
           options.requiredInits?.has(`${pathOf(byId.get(at)!)}.init()`),
         )
+      // clang imports an init a class takes from a protocol requirement as
+      // required, which a non-final class must declare to conform
+      const protocolInit =
+        member.kind.identifier === 'swift.init' &&
+        /^c:objc\(pl\)\w+\(im\).*::SYNTHESIZED::c:objc\(cs\)/.test(
+          member.identifier.precise,
+        )
       const required =
-        context.inClass && (flags.has('required') || requiredInit || restatesRequired)
+        context.inClass &&
+        (flags.has('required') || requiredInit || restatesRequired || protocolInit)
       const final = context.inClass && flags.has('final') ? 'final ' : ''
       const mutating = flags.has('mutating')
         ? 'mutating '

package/src/swift-wasm-prune.ts

@@ -1070,6 +1070,32 @@ function getModulePrefix(file: string): string {
   return dash > 0 ? base.slice(0, dash) : base
 }
 
+// protocol descriptors of the SwiftUI protocols whose conformers declare @State, @Environment and other DynamicProperty fields
+const SWIFTUI_WRAPPER_HOST_PROTOCOLS = new Set(
+  [
+    'View',
+    'ViewModifier',
+    'App',
+    'Scene',
+    'Gesture',
+    'ToolbarContent',
+    'Commands',
+    'DynamicProperty',
+  ].map((name) => `$s7SwiftUI${name.length}${name}Mp`),
+)
+
+/** SwiftUI and Combine own the wrappers; any other object keeps its field descriptors when its conformance records reference a protocol whose conformers hold them. */
+export function keepsSwiftUIReflection(
+  file: string,
+  undefinedSymbols: Iterable<string>,
+): boolean {
+  if (/^(SwiftUI|Combine|_[A-Za-z0-9]+_SwiftUI)-/.test(path.basename(file))) return true
+  for (const name of undefinedSymbols) {
+    if (SWIFTUI_WRAPPER_HOST_PROTOCOLS.has(name)) return true
+  }
+  return false
+}
+
 export function pruneSwiftWasmLink(
   directory: string,
   toolchainBin: string,
@@ -1121,11 +1147,23 @@ export function pruneSwiftWasmLink(
   const distDir = path.join(moduleRoot, 'lib')
   // the app's own struct and class field descriptors stay: SwiftUI attaches
   // @State and @StateObject by reflecting the app's view structs.
-  // the shim reflects its own wrappers and views (State, ObservedObject, Published), so SwiftUI and Combine keep their descriptors.
-  // a framework's SwiftUI overlay (_StoreKit_SwiftUI) declares views whose @State and @Environment attach the same way.
+  // the shim reflects its own wrappers (State, ObservedObject, Published), so SwiftUI, Combine and framework SwiftUI overlays (_StoreKit_SwiftUI) keep their descriptors.
+  // any other object keeps them when it conforms to a SwiftUI protocol whose conformers hold property wrappers: its record references the protocol descriptor.
+  const keepsReflection = new Map<ParsedObject, boolean>()
+  const declaresSwiftUIConformers = (obj: ParsedObject) => {
+    let keeps = keepsReflection.get(obj)
+    if (keeps === undefined) {
+      keeps = keepsSwiftUIReflection(
+        obj.file,
+        obj.symNames.filter((n, i) => n && (obj.symFlags[i]! & 0x10) !== 0),
+      )
+      keepsReflection.set(obj, keeps)
+    }
+    return keeps
+  }
   const dropsReflection = (obj: ParsedObject, name: string | undefined) =>
     !!name &&
-    !/^(SwiftUI|Combine|_[A-Za-z0-9]+_SwiftUI)-/.test(path.basename(obj.file)) &&
+    !declaresSwiftUIConformers(obj) &&
     (name.startsWith('l__swift5_reflection_descriptor') ||
       (name.startsWith('$s') &&
         (name.endsWith('CMF') || name.endsWith('VMF')) &&

package/src/turbo-compile.ts

@@ -416,7 +416,8 @@ export async function compileTurboModule(options: {
   await options.prepareReactNativeCore?.(collection.coreMode, options.moduleRoot)
   linkReactNativeCore(
     collection,
-    prebuiltReactNativeCore(
+    await prebuiltReactNativeCore(
+      options.projectRoot,
       options.reactNativeRoot,
       options.moduleRoot,
       collection.coreMode,