peachsim 0.1.1625 → 0.1.1640

package/src/vite-plugin.ts

@@ -47,7 +47,10 @@ import {
   isReactNativeEnvironmentSetupModule,
 } from '../../peach-engine/src/guest-module-overrides.ts'
 import { readPeachWarmManifest } from '../../peach-engine/src/peach-warm-manifest.ts'
-import { resolveSootsimBridgePort } from './bridge-constants.ts'
+import {
+  assertPeachPortEnvironment,
+  resolveSootsimBridgePort,
+} from './bridge-constants.ts'
 import { isRecord } from './is-record.ts'
 import {
   SHELL_BRIDGE_IDENTITY_PATH,
@@ -1321,6 +1324,7 @@ const viteBridgeProcesses = (globalThis.__sootsimViteBridgeProcesses ??= new Map
 // installs it explicitly and owns the one shared bridge; sootsim() never
 // does, so an isolated dev server cannot bind the shared default port.
 export function wsBridgePlugin(options: { ownedBridgePort?: number } = {}): Plugin {
+  assertPeachPortEnvironment(process.env)
   if (
     options.ownedBridgePort !== undefined &&
     (!Number.isInteger(options.ownedBridgePort) ||
@@ -1652,6 +1656,13 @@ function sootsimConfigPlugin(
                   return nativeLibraryStub ? { id: nativeLibraryStub } : null
                 },
               },
+              {
+                name: 'peach-one-native-backend',
+                resolveId(source: string, importer: string | undefined) {
+                  const backend = resolveOneNativeBackend(source, importer)
+                  return backend ? { id: backend } : null
+                },
+              },
               {
                 name: 'sootsim-published-browser-internals',
                 resolveId(source: string, importer: string | undefined) {

package/src/worker-system-chunks.ts

@@ -242,10 +242,16 @@ const linkedChunks = new Set();
 function chunkBody(url) {
   let body = chunkBodies.get(url);
   if (!body) {
-    body = fetchWorkerChunk(url, { credentials: 'same-origin' }).then(response => {
+    body = (async () => {
+      if (deliveredChunkList && (await deliveredChunkList.promise).has(url)) {
+        const bytes = await deliveredChunk(url).promise;
+        deliveredChunks.delete(url);
+        return new TextDecoder().decode(bytes);
+      }
+      const response = await fetchWorkerChunk(url, { credentials: 'same-origin' });
       if (!response.ok) throw new Error(url + ': HTTP ' + response.status);
       return response.text();
-    });
+    })();
     body.catch(() => chunkBodies.delete(url));
     chunkBodies.set(url, body);
   }
@@ -261,16 +267,9 @@ const importModule = specifier => import(specifier);
 System.importModule = importModule;
 System.instantiate = async function(url) {
   if (url === workerEntryUrl) return workerEntryRegistration;
-  let source;
-  if (deliveredChunkList && (await deliveredChunkList.promise).has(url)) {
-    const body = await deliveredChunk(url).promise;
-    deliveredChunks.delete(url);
-    source = new TextDecoder().decode(body);
-  } else {
-    source = await chunkBody(url);
-    chunkBodies.delete(url);
-    linkedChunks.add(url);
-  }
+  const source = await chunkBody(url);
+  chunkBodies.delete(url);
+  linkedChunks.add(url);
   let registration;
   // minified module chunks assume strict block-scoped function semantics.
   new Function('System', '"use strict";\\n' + source)({

package/src/worklet-executable.ts

@@ -92,6 +92,7 @@ interface Scope {
 
 type Binding =
   | { kind: 'value'; init: SyntaxNode; scope: Scope }
+  | { kind: 'uninitialized' }
   // `key` is set when the parameter is a destructured member of that argument.
   | { kind: 'param'; fn: SyntaxNode; index: number; key?: string }
   | { kind: 'opaque' }
@@ -106,6 +107,9 @@ interface InitCollection {
   writes: Array<{ name: string; scope: Scope; value?: SyntaxNode }>
   // bindings written after their declaration; their value is not static.
   reassigned: Set<Binding>
+  // rolldown hoists declarations out of esm initializers. a single plain
+  // assignment still identifies the literal; multiple writes remain opaque.
+  assigned: Map<Binding, { value: SyntaxNode; scope: Scope } | null>
   // names the parsed source never declares but writes exactly once with a plain
   // assignment. a bundler that hoists a module's declarations out of its
   // initializer leaves only that write in the initializer.
@@ -227,6 +231,8 @@ function enter(node: SyntaxNode, scope: Scope): Scope {
         const name = identifierName(id)
         if (name !== undefined && isNode(init))
           declare(target, name, { kind: 'value', init, scope })
+        else if (name !== undefined && init === null)
+          declare(target, name, { kind: 'uninitialized' })
         else declareOpaque(target, patternNames(id))
       }
       return scope
@@ -311,12 +317,18 @@ function collectInitData(root: SyntaxNode): InitCollection {
     immediate: new Map(),
     writes: [],
     reassigned: new Set(),
+    assigned: new Map(),
     free: new Map(),
   }
   visit(root, newScope(undefined, true), collection)
   for (const { name, scope, value } of collection.writes) {
     const binding = lookup(scope, name)
-    if (binding) collection.reassigned.add(binding)
+    if (binding?.kind === 'uninitialized')
+      collection.assigned.set(
+        binding,
+        collection.assigned.has(binding) || !value ? null : { value, scope },
+      )
+    else if (binding) collection.reassigned.add(binding)
     else
       collection.free.set(
         name,
@@ -415,6 +427,12 @@ function resolveObject(
         : undefined
     }
     if (collection.reassigned.has(binding)) return undefined
+    if (binding.kind === 'uninitialized') {
+      const assigned = collection.assigned.get(binding)
+      return assigned
+        ? resolveObject(assigned.value, assigned.scope, collection, depth + 1)
+        : undefined
+    }
     if (binding.kind === 'value')
       return resolveObject(binding.init, binding.scope, collection, depth + 1)
     if (binding.kind === 'param') {

package/src/xcode-project.ts

@@ -1,11 +1,14 @@
 // reads an xcode project's application target the way xcode builds it: the
 // swift sources and resources that are members of the target, the local
 // swift packages its products come from, the remote package products it links,
-// and the build settings that change how its swift compiles. never runs xcode
-// or evaluates a build phase; the project file is data: project.pbxproj, or
+// and the build settings that change how its swift compiles. project opening
+// prepares declared generated swift sources without running xcode. the project
+// file is data: project.pbxproj, or
 // xcode 27.2's json project.xcproj, which xcode-json-project.ts reads into
 // the same object table.
 
+import { execFileSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
 import plist from 'plist'
@@ -45,6 +48,19 @@ export interface XcodeModuleTarget {
   mainActorIsolation: boolean
   /** the compilation conditions the build configuration defines, as `-D` passes them. */
   defines: string[]
+  /** the resolved source iOS minimum, including for native package dependencies. */
+  iosDeploymentTarget: string | null
+  /** original implementation inputs and clang settings, before any declaration import. */
+  objc?: {
+    headers: string[]
+    prefixHeader: string | null
+    bridgingHeader: string | null
+    headerSearchPaths: string[]
+    frameworkSearchPaths: string[]
+    flags: string[]
+    cxxFlags: string[]
+    fileFlags: Record<string, string[]>
+  }
 }
 
 /** an application target, resolved to files on disk with everything it builds. */
@@ -72,8 +88,8 @@ export interface XcodeAppTarget extends XcodeModuleTarget {
   localPackageDirs: string[]
   /** prebuilt frameworks and xcframeworks the projects vendor and link, at their path when it resolves. */
   binaryFrameworks: { name: string; path: string | null }[]
-  /** the Package.resolved pinning the remote packages' revisions, when resolved. */
-  packageResolved: string | null
+  /** workspace pins, or local package locks when the workspace has no lock. */
+  packageResolved: string[]
   /** every application target in the workspace, for a chooser. */
   appTargets: string[]
   /** the build configuration every target's settings are read in. */
@@ -498,14 +514,17 @@ function expand(value: string, lookup: (name: string) => string): string {
   )
 }
 
+const preparedSourcePhases = new Map<string, string>()
+
 // the swift sources and resources that are members of a target.
-// run script phases never execute here; their declared swift outputs are
-// compile inputs xcode generates before compiling, so a missing one names
-// the script instead of silently dropping the file.
+// metadata-only reads never execute scripts. opening a project prepares the
+// declared swift outputs with the project's own shell and build settings.
 function targetMembers(
   ref: TargetRef,
   settings: (key: string) => string,
-  options: { requireSources?: boolean } = {},
+  options: { requireSources?: boolean; prepareGeneratedSources?: boolean },
+  settingKeys: Set<string>,
+  projectInputs: Set<string>,
 ): {
   sources: string[]
   resources: string[]
@@ -517,30 +536,137 @@ function targetMembers(
   const allSources = new Set<string>()
   const resources = new Set<string>()
   const scriptForOutput = new Map<string, string>()
-  const noteScriptOutput = (raw: string, script: string) => {
-    const expanded = expand(raw, settings)
-    if (!expanded.endsWith('.swift')) return
-    const absolute = path.isAbsolute(expanded)
-      ? path.normalize(expanded)
-      : path.resolve(project.projectDir, expanded)
-    if (!scriptForOutput.has(absolute)) scriptForOutput.set(absolute, script)
-  }
   for (const phaseId of list(target.buildPhases)) {
     const phase = project.object(phaseId)
     if (phase?.isa !== 'PBXShellScriptBuildPhase') continue
     const script = str(phase.name) ?? phaseId
-    for (const raw of list(phase.outputPaths)) noteScriptOutput(raw, script)
-    for (const listPath of list(phase.outputFileListPaths)) {
-      const expandedList = expand(listPath, settings)
-      const absoluteList = path.isAbsolute(expandedList)
-        ? expandedList
-        : path.resolve(project.projectDir, expandedList)
-      if (!fs.existsSync(absoluteList)) continue
-      for (const line of fs.readFileSync(absoluteList, 'utf8').split('\n')) {
-        const trimmed = line.trim()
-        if (trimmed === '' || trimmed.startsWith('#')) continue
-        noteScriptOutput(trimmed, script)
+    const absolute = (raw: string) =>
+      path.resolve(project.projectDir, expand(raw, settings))
+    const inputs = list(phase.inputPaths).map(absolute)
+    const outputs = list(phase.outputPaths).map(absolute)
+    const fileLists = new Map<string, { file: string; entries: string[] }[]>()
+    for (const kind of ['INPUT', 'OUTPUT']) {
+      const lists = list(
+        kind === 'INPUT' ? phase.inputFileListPaths : phase.outputFileListPaths,
+      ).map((raw) => {
+        const file = absolute(raw)
+        if (!fs.existsSync(file)) {
+          return { file, entries: [] }
+        }
+        const entries = fs
+          .readFileSync(file, 'utf8')
+          .split(/\r?\n/)
+          .map((line) => line.trim())
+          .filter((line) => line !== '' && !line.startsWith('#'))
+          .map(absolute)
+        return { file, entries }
+      })
+      fileLists.set(kind, lists)
+    }
+    const allOutputs = [
+      ...outputs,
+      ...fileLists.get('OUTPUT')!.flatMap((item) => item.entries),
+    ]
+    for (const output of allOutputs)
+      if (output.endsWith('.swift') && !scriptForOutput.has(output))
+        scriptForOutput.set(output, script)
+    const inputFiles = [
+      ...inputs,
+      ...fileLists.get('INPUT')!.flatMap((item) => [item.file, ...item.entries]),
+      ...fileLists.get('OUTPUT')!.map((item) => item.file),
+    ]
+    if (allOutputs.some((file) => file.endsWith('.swift')))
+      for (const file of inputFiles) if (fs.existsSync(file)) projectInputs.add(file)
+    if (
+      options.prepareGeneratedSources &&
+      options.requireSources !== false &&
+      allOutputs.some((file) => file.endsWith('.swift'))
+    ) {
+      const phaseDir = path.join(settings('TARGET_TEMP_DIR'), `Script-${phaseId}`)
+      for (const lists of fileLists.values())
+        for (const { file } of lists)
+          if (!fs.existsSync(file))
+            throw new Error(
+              `${targetName}: Run Script "${script}" missing file list ${file}`,
+            )
+      const env = {
+        ...process.env,
+        ...Object.fromEntries(
+          [...settingKeys]
+            .filter((key) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            .map((key) => [key, settings(key)]),
+        ),
+      }
+      const declared = { INPUT: inputs, OUTPUT: outputs }
+      for (const kind of ['INPUT', 'OUTPUT'] satisfies (keyof typeof declared)[]) {
+        env[`SCRIPT_${kind}_FILE_COUNT`] = String(declared[kind].length)
+        declared[kind].forEach((file, index) => {
+          env[`SCRIPT_${kind}_FILE_${index}`] = file
+        })
+        const lists = fileLists.get(kind)!
+        env[`SCRIPT_${kind}_FILE_LIST_COUNT`] = String(lists.length)
+        lists.forEach((_item, index) => {
+          env[`SCRIPT_${kind}_FILE_LIST_${index}`] = path.join(
+            phaseDir,
+            `${kind}-${index}.xcfilelist`,
+          )
+        })
+      }
+      const signature = createHash('sha256').update(
+        JSON.stringify([phase, [...settingKeys].map((key) => [key, settings(key)])]),
+      )
+      for (const file of inputFiles) {
+        signature.update(file)
+        if (fs.existsSync(file)) {
+          const stat = fs.statSync(file)
+          signature.update(`${stat.mtimeMs}:${stat.ctimeMs}:${stat.size}`)
+        } else signature.update('missing')
+      }
+      const stamp = signature.digest('hex')
+      const key = `${project.projectFile}:${targetId}:${phaseId}:${settings('CONFIGURATION')}`
+      if (
+        preparedSourcePhases.get(key) === stamp &&
+        allOutputs.every((file) => fs.existsSync(file))
+      )
+        continue
+      fs.mkdirSync(phaseDir, { recursive: true })
+      fs.mkdirSync(settings('BUILT_PRODUCTS_DIR'), { recursive: true })
+      fs.mkdirSync(settings('DERIVED_FILE_DIR'), { recursive: true })
+      for (const [kind, lists] of fileLists)
+        lists.forEach((item, index) => {
+          fs.writeFileSync(
+            env[`SCRIPT_${kind}_FILE_LIST_${index}`]!,
+            `${item.entries.join('\n')}\n`,
+          )
+        })
+      try {
+        execFileSync(
+          str(phase.shellPath) ?? '/bin/sh',
+          ['-c', str(phase.shellScript) ?? ''],
+          {
+            cwd: project.projectDir,
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: 120_000,
+          },
+        )
+      } catch (error) {
+        const output =
+          error instanceof Error
+            ? `${error.message}\n${'stdout' in error ? String(error.stdout) : ''}${'stderr' in error ? String(error.stderr) : ''}`
+            : String(error)
+        throw new Error(
+          `${targetName}: Run Script "${script}" failed preparing generated Swift sources:\n${output}`,
+        )
       }
+      const missing = allOutputs.filter(
+        (file) => file.endsWith('.swift') && !fs.existsSync(file),
+      )
+      if (missing.length > 0)
+        throw new Error(
+          `${targetName}: Run Script "${script}" did not produce ${missing.join(', ')}`,
+        )
+      preparedSourcePhases.set(key, stamp)
     }
   }
   visitXcodeTargetMembers(
@@ -769,7 +895,7 @@ export function readXcodeAppTarget(
   input: string,
   targetName?: string,
   configurationName?: string,
-  options: { requireSources?: boolean } = {},
+  options: { requireSources?: boolean; prepareGeneratedSources?: boolean } = {},
 ): XcodeAppTarget {
   // canonical, so every path returned agrees with the host's realpath checks
   const xcodeprojOrWorkspace = fs.realpathSync(input)
@@ -881,22 +1007,112 @@ export function readXcodeAppTarget(
         SRCROOT: ref.project.projectDir,
         SOURCE_ROOT: ref.project.projectDir,
         PROJECT_DIR: ref.project.projectDir,
+        SYMROOT: path.join(ref.project.projectDir, '.build/peach-xcode/Build/Products'),
+        BUILD_DIR: '$(SYMROOT)',
+        OBJROOT: path.join(
+          ref.project.projectDir,
+          '.build/peach-xcode/Build/Intermediates.noindex',
+        ),
+        CONFIGURATION_BUILD_DIR:
+          '$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)',
+        BUILT_PRODUCTS_DIR: '$(CONFIGURATION_BUILD_DIR)',
+        TARGET_BUILD_DIR: '$(CONFIGURATION_BUILD_DIR)',
+        PROJECT_TEMP_DIR: '$(OBJROOT)/$(PROJECT_NAME).build',
+        CONFIGURATION_TEMP_DIR:
+          '$(PROJECT_TEMP_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)',
+        TARGET_TEMP_DIR: '$(CONFIGURATION_TEMP_DIR)/$(TARGET_NAME).build',
+        DERIVED_FILE_DIR: '$(TARGET_TEMP_DIR)/DerivedSources',
+        DERIVED_FILES_DIR: '$(DERIVED_FILE_DIR)',
+        PLATFORM_NAME: 'iphonesimulator',
+        EFFECTIVE_PLATFORM_NAME: '-iphonesimulator',
+        CURRENT_ARCH: 'arm64',
+        ARCHS: 'arm64',
+        ACTION: 'build',
         DEVELOPMENT_LANGUAGE: str(ref.project.project.developmentRegion) ?? 'en',
       },
       options,
     )
     for (const file of read) xcconfigs.add(file)
     const swiftVersion = Number.parseFloat(settings('SWIFT_VERSION') || '5')
+    const members = targetMembers(ref, settings, options, keys, xcconfigs)
+    const implementations = members.allSources.filter((file) =>
+      /\.(c|cc|cpp|cxx|m|mm)$/.test(file),
+    )
+    const absolute = (file: string) => path.resolve(ref.project.projectDir, file)
+    const fileFlags: Record<string, string[]> = {}
+    for (const phaseId of list(ref.target.buildPhases)) {
+      const phase = ref.project.object(phaseId)
+      if (phase?.isa !== 'PBXSourcesBuildPhase') continue
+      for (const id of list(phase.files)) {
+        const file = ref.project.object(id)
+        const resolved = ref.project.resolvePath(str(file?.fileRef) ?? '')
+        if (resolved && implementations.includes(resolved))
+          fileFlags[resolved] = settingList(
+            expand(
+              str(isDict(file?.settings) ? file.settings.COMPILER_FLAGS : undefined) ??
+                '',
+              settings,
+            ),
+          )
+      }
+    }
     return {
       settings,
       keys,
       module: {
         name,
         moduleName: applyOperator(settings('PRODUCT_MODULE_NAME'), 'c99extidentifier'),
-        ...targetMembers(ref, settings, options),
+        ...members,
         languageMode: swiftVersion >= 6 ? 6 : 5,
         mainActorIsolation: settings('SWIFT_DEFAULT_ACTOR_ISOLATION') === 'MainActor',
         defines: compilationConditions(settings),
+        iosDeploymentTarget: settings('IPHONEOS_DEPLOYMENT_TARGET') || null,
+        ...(implementations.some((file) => /\.mm?$/.test(file))
+          ? {
+              objc: {
+                headers: Object.keys(ref.project.objects).flatMap((id) => {
+                  const file = ref.project.resolvePath(id)
+                  return file && /\.(h|hh|hpp|hxx|pch)$/.test(file) && fs.existsSync(file)
+                    ? [file]
+                    : []
+                }),
+                prefixHeader: settings('GCC_PREFIX_HEADER')
+                  ? absolute(settings('GCC_PREFIX_HEADER'))
+                  : null,
+                bridgingHeader: settings('SWIFT_OBJC_BRIDGING_HEADER')
+                  ? absolute(settings('SWIFT_OBJC_BRIDGING_HEADER'))
+                  : null,
+                headerSearchPaths: [
+                  ...settingList(settings('HEADER_SEARCH_PATHS')),
+                  ...settingList(settings('USER_HEADER_SEARCH_PATHS')),
+                ].map(absolute),
+                frameworkSearchPaths: settingList(settings('FRAMEWORK_SEARCH_PATHS')).map(
+                  absolute,
+                ),
+                flags: [
+                  ...(settings('CLANG_ENABLE_OBJC_ARC') === 'YES' ? ['-fobjc-arc'] : []),
+                  ...(settings('CLANG_ENABLE_OBJC_WEAK') === 'YES'
+                    ? ['-fobjc-weak']
+                    : []),
+                  ...(settings('CLANG_ENABLE_MODULES') === 'YES' ? ['-fmodules'] : []),
+                  ...(settings('GCC_C_LANGUAGE_STANDARD')
+                    ? [`-std=${settings('GCC_C_LANGUAGE_STANDARD')}`]
+                    : []),
+                  ...settingList(settings('GCC_PREPROCESSOR_DEFINITIONS')).map(
+                    (value) => `-D${value}`,
+                  ),
+                  ...settingList(settings('OTHER_CFLAGS')),
+                ],
+                cxxFlags: [
+                  ...(settings('CLANG_CXX_LANGUAGE_STANDARD')
+                    ? [`-std=${settings('CLANG_CXX_LANGUAGE_STANDARD')}`]
+                    : []),
+                  ...settingList(settings('OTHER_CPLUSPLUSFLAGS')),
+                ],
+                fileFlags,
+              },
+            }
+          : {}),
       } satisfies XcodeModuleTarget,
     }
   }
@@ -967,6 +1183,23 @@ export function readXcodeAppTarget(
     ...projects.flatMap((project) =>
       Object.entries(project.objects).flatMap(([id, entry]) => {
         if (!isDict(entry)) return []
+        if (entry.isa === 'PBXFileSystemSynchronizedRootGroup') {
+          const folder = project.resolvePath(id)
+          const pending = folder ? [folder] : []
+          const packages: string[] = []
+          while (pending.length > 0) {
+            const dir = pending.pop()!
+            if (fs.existsSync(path.join(dir, 'Package.swift'))) {
+              packages.push(dir)
+              continue
+            }
+            if (!isDirectory(dir)) continue
+            for (const child of fs.readdirSync(dir, { withFileTypes: true }))
+              if (child.isDirectory() && !child.name.startsWith('.'))
+                pending.push(path.join(dir, child.name))
+          }
+          return packages
+        }
         const candidate =
           entry.isa === 'XCLocalSwiftPackageReference'
             ? path.resolve(project.projectDir, str(entry.relativePath) ?? '')
@@ -1046,6 +1279,13 @@ export function readXcodeAppTarget(
     'Package.resolved',
   )
 
+  const packageResolved = fs.existsSync(resolvedFile)
+    ? [fs.realpathSync(resolvedFile)]
+    : [...new Set(localPackageDirs.map((dir) => path.join(dir, 'Package.resolved')))]
+        .filter((file) => fs.existsSync(file))
+        .map((file) => fs.realpathSync(file))
+        .sort()
+
   // the app is last in its own dependency order
   const used = order.map((ref) => ref.project)
   return {
@@ -1074,7 +1314,7 @@ export function readXcodeAppTarget(
     binaryFrameworks: [...binaryFrameworks]
       .map(([name, file]) => ({ name, path: file }))
       .sort((left, right) => left.name.localeCompare(right.name)),
-    packageResolved: fs.existsSync(resolvedFile) ? resolvedFile : null,
+    packageResolved,
     appTargets: appTargetNames,
     configuration,
     settings,