peachsim 0.1.939 → 0.1.1399

package/src/swift-standins.ts

@@ -25,6 +25,7 @@ import {
 } from './swift-compile'
 import {
   STANDIN_EMIT_VERSION,
+  STANDIN_IMPORTS,
   emitSwiftStandin,
   type SymbolGraph,
 } from './swift-standin-emit'
@@ -134,7 +135,10 @@ function locateXcframework(tree: string): string | null {
 // remote) keeps its bytes and unpacks again when they change. the digest,
 // not the path, keys the stand-in cache, so a replaced same-path zip
 // rebuilds instead of reusing stale output.
-function xcframework(binary: SwiftPackageBinary): { dir: string; digest: string } {
+function xcframework(binary: SwiftPackageBinary): {
+  dir: string
+  digest: string
+} {
   if (!binary.url && !binary.dir.endsWith('.zip'))
     return { dir: binary.dir, digest: treeDigest(binary.dir) }
   if (binary.url && (!binary.checksum || !/^[a-f0-9]{64}$/i.test(binary.checksum)))
@@ -213,6 +217,10 @@ function surfaces(xcframeworkDir: string): Surface[] {
     .readdirSync(xcframeworkDir)
     .filter((name) => /^ios-.+-simulator$/.test(name))
     .sort()[0]
+  // a plain .framework vendors one built framework, never xcframework
+  // slices; name the shape instead of asking for a layout it cannot have
+  if (!slice && xcframeworkDir.endsWith('.framework'))
+    throw new Error('a plain .framework has no .xcframework simulator slice')
   if (!slice) throw new Error('it has no iOS simulator slice')
   const root = path.join(xcframeworkDir, slice)
   const found: Surface[] = []
@@ -265,6 +273,11 @@ function peachModuleDirs(toolchain: Toolchain, imports: string[]): string[] {
   const { moduleRoot, toolchainBin } = toolchain
   if (swiftDistributionAt(moduleRoot)) return [path.join(moduleRoot, 'modules')]
   const peach = new Set(swiftPeachModules(moduleRoot))
+  // the generated source imports UIKit even when the interface names only
+  // sdk modules, so its imports, not the interface's, decide what builds
+  const targets = [...new Set([...STANDIN_IMPORTS, ...imports])].filter((name) =>
+    peach.has(name),
+  )
   const plugins = swiftMacroPlugins(moduleRoot)
   if (plugins.stale)
     exec('sh', [
@@ -272,11 +285,15 @@ function peachModuleDirs(toolchain: Toolchain, imports: string[]): string[] {
       toolchainBin,
       plugins.libraries[0]!,
     ])
-  for (const target of imports.filter((name) => peach.has(name)))
+  for (const target of targets)
     exec(
       path.join(toolchainBin, 'swift'),
       [
         'build',
+        '--build-system',
+        'native',
+        '-j',
+        '4',
         '--swift-sdk',
         swiftModuleSdk(moduleRoot).wasmSdkId,
         '-c',
@@ -314,8 +331,19 @@ function peachModuleDirs(toolchain: Toolchain, imports: string[]): string[] {
 // an iOS interface read for wasm: its own flags target wasm, and objective-c
 // attributes, which need a runtime wasm swift lacks, come off its
 // declarations; the declarations themselves stay as the vendor wrote them.
+// iOS declares NSObject in its ObjectiveC module, which interfaces name
+// (`ObjectiveC.NSObject`, or `ObjectiveC::NSObject` from swift 6.4); on wasm
+// Foundation declares it, so those references name Foundation.
 export function swiftInterfaceForWasm(text: string): string {
-  return text
+  const rooted = text.replace(
+    /\bObjectiveC(\.|::)(NSObject|NSObjectProtocol)\b/g,
+    'Foundation$1$2',
+  )
+  const foundation =
+    rooted !== text && !/^import[ \t]+Foundation\b/m.test(rooted)
+      ? rooted.replace(/^(?=import[ \t])/m, 'import Foundation\n')
+      : rooted
+  return foundation
     .replace(/^(\/\/ swift-module-flags:.*)$/m, (flags) =>
       flags
         .replace(/-target \S+/, `-target ${TRIPLE}`)
@@ -694,6 +722,229 @@ function cStandin(
   }
 }
 
+const RUST_TARGET = 'wasm32-wasip1'
+// directories a crate search never enters: build output and installed deps
+const UNSEARCHED = new Set([
+  'node_modules',
+  'Pods',
+  'target',
+  '.build',
+  '.git',
+  'DerivedData',
+])
+
+// the crate whose static library is `lib<name>.a`: its `[lib] name`, or its
+// package name with dashes as underscores, as cargo names the library.
+function crateFor(root: string, name: string): string | null {
+  const walk = (dir: string, depth: number): string | null => {
+    const manifest = path.join(dir, 'Cargo.toml')
+    if (fs.existsSync(manifest)) {
+      const text = fs.readFileSync(manifest, 'utf8')
+      const section = (title: string) =>
+        new RegExp(`^\\[${title}\\]\\s*$([\\s\\S]*?)(?=^\\[|(?![\\s\\S]))`, 'm').exec(
+          text,
+        )?.[1] ?? ''
+      const field = (body: string, key: string) =>
+        new RegExp(`^${key}\\s*=\\s*"([^"]+)"`, 'm').exec(body)?.[1]
+      const lib = section('lib')
+      const crate =
+        field(lib, 'name') ?? field(section('package'), 'name')?.replaceAll('-', '_')
+      if (crate === name) {
+        if (!/crate-type\s*=\s*\[[^\]]*"staticlib"/.test(lib))
+          throw new Error(
+            `${path.relative(root, manifest)} builds lib${name} without crate-type "staticlib"`,
+          )
+        return manifest
+      }
+    }
+    if (depth === 0) return null
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (
+        !entry.isDirectory() ||
+        UNSEARCHED.has(entry.name) ||
+        entry.name.endsWith('.xcframework')
+      )
+        continue
+      const found = walk(path.join(dir, entry.name), depth - 1)
+      if (found) return found
+    }
+    return null
+  }
+  return walk(root, 4)
+}
+
+/**
+ * the WebAssembly static library a c stand-in links in place of its traps,
+ * or null when it has none. a build the developer supplies in the
+ * xcframework (`wasm32-wasip1/lib<name>.a`) wins; otherwise the crate under
+ * `searchRoot` that builds the slice's library compiles with the developer's
+ * own cargo. peach ships no rust compiler.
+ */
+export function standinLibrary(
+  binary: SwiftPackageBinary,
+  searchRoot: string,
+): string | null {
+  const dir = xcframework(binary).dir
+  const slice = fs
+    .readdirSync(dir)
+    .filter((name) => /^ios-.+-simulator$/.test(name))
+    .sort()[0]
+  const library = slice
+    ? fs.readdirSync(path.join(dir, slice)).find((name) => /^lib.+\.a$/.test(name))
+    : undefined
+  const supplied = path.join(dir, RUST_TARGET)
+  if (fs.existsSync(supplied)) {
+    const found = fs.readdirSync(supplied).filter((name) => name.endsWith('.a'))
+    const chosen =
+      library && found.includes(library) ? library : found.length === 1 ? found[0] : null
+    if (!chosen)
+      throw new Error(
+        `${path.relative(searchRoot, supplied)} holds no single static library${library ? ` named ${library}` : ''}`,
+      )
+    return path.join(supplied, chosen)
+  }
+  if (!library) return null
+  const manifest = crateFor(searchRoot, library.slice('lib'.length, -'.a'.length))
+  if (!manifest) return null
+  const result = spawnSync(
+    'cargo',
+    [
+      'build',
+      '--release',
+      '--target',
+      RUST_TARGET,
+      '--message-format=json-render-diagnostics',
+      '--manifest-path',
+      manifest,
+    ],
+    {
+      encoding: 'utf8',
+      maxBuffer: 256 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    },
+  )
+  const crate = path.relative(searchRoot, path.dirname(manifest))
+  if (result.error)
+    throw new Error(
+      `${crate} is a rust crate and cargo is not installed; install rust (https://rustup.rs), then run again`,
+    )
+  if (result.status !== 0) {
+    if (
+      /target may not be installed|can't find crate for `(core|std)`/.test(result.stderr)
+    )
+      throw new Error(
+        `${crate} builds for ${RUST_TARGET}, which this rust lacks; run \`rustup target add ${RUST_TARGET}\`, then run again`,
+      )
+    throw new Error(
+      `cargo could not build ${crate} for ${RUST_TARGET}: ${failure(result)}`,
+    )
+  }
+  for (const line of result.stdout.split('\n')) {
+    if (!line.startsWith('{')) continue
+    const message: unknown = JSON.parse(line)
+    if (
+      !message ||
+      typeof message !== 'object' ||
+      !('filenames' in message) ||
+      !Array.isArray(message.filenames)
+    )
+      continue
+    const archive = message.filenames.find(
+      (file): file is string =>
+        typeof file === 'string' && path.basename(file) === library,
+    )
+    if (archive) return archive
+  }
+  throw new Error(`cargo built ${crate} for ${RUST_TARGET} but reported no ${library}`)
+}
+
+// source preflight shares project compilation's portable builder admission.
+// the complete resolved artifact travels as an input, including ignored local frameworks.
+function sourceBinaryStandins(
+  binary: SwiftPackageBinary,
+  toolchain: Toolchain,
+  provided: ReadonlySet<string>,
+): SwiftStandin[] | string {
+  const repo = path.resolve(toolchain.moduleRoot, '../..')
+  const work = fs.mkdtempSync(path.join(os.tmpdir(), 'peach-standin-request-'))
+  try {
+    const artifact = xcframework(binary)
+    const local = { ...binary, dir: artifact.dir, url: null, checksum: null }
+    const generation = standinGenerationInputs([local], toolchain)
+    const request = path.join(work, 'request.json')
+    const delivery = path.join(work, 'delivery')
+    fs.writeFileSync(
+      request,
+      JSON.stringify({
+        binary: local,
+        provided: [...provided],
+        generation,
+        release: toolchain.release,
+        callerToolchainBin: toolchain.toolchainBin,
+      }),
+    )
+    execFileSync(
+      'bash',
+      [
+        path.join(repo, 'scripts/build/remote.sh'),
+        // a deadline makes a busy pool wait for a slot; without one it refuses
+        // at once and the app reads as missing a module
+        '--timeout',
+        '1800',
+        '--delivery-dir',
+        delivery,
+        '--toolchain',
+        'packages/sootsim-swift/toolchain.json',
+        '--input',
+        request,
+        '--input',
+        artifact.dir,
+        'bun',
+        'scripts/build/swift-standins.ts',
+        '--request',
+        '.remote-inputs/request.json',
+        '--artifact',
+        `.remote-inputs/${path.basename(artifact.dir)}`,
+        '--output',
+        '.remote-out/standins.json',
+      ],
+      { cwd: repo, stdio: 'inherit' },
+    )
+    const receipt: unknown = JSON.parse(
+      fs.readFileSync(path.join(delivery, 'standins.json'), 'utf8'),
+    )
+    if (
+      !receipt ||
+      typeof receipt !== 'object' ||
+      !('generation' in receipt) ||
+      receipt.generation !== generation ||
+      !('result' in receipt)
+    )
+      throw new Error('Swift stand-in builder source differs from the caller')
+    const result = receipt.result
+    if (typeof result === 'string') return result
+    if (
+      !Array.isArray(result) ||
+      !result.every(
+        (item) =>
+          item &&
+          typeof item === 'object' &&
+          typeof item.module === 'string' &&
+          typeof item.target === 'string' &&
+          item.target === binary.target &&
+          item.files &&
+          typeof item.files === 'object' &&
+          !Array.isArray(item.files) &&
+          Object.values(item.files).every((text) => typeof text === 'string'),
+      )
+    )
+      throw new Error('invalid Swift stand-in builder result')
+    return result
+  } finally {
+    fs.rmSync(work, { recursive: true, force: true })
+  }
+}
+
 const built = new Map<string, SwiftStandin[] | string>()
 
 /** what stand-ins are generated from besides the surfaces' files: the
@@ -792,18 +1043,26 @@ function binaryStandins(
   const work = fs.mkdtempSync(path.join(os.tmpdir(), 'peach-standin-'))
   let result: SwiftStandin[] | string
   try {
-    result = found.map((surface) => {
-      const dir = path.join(work, surface.module)
-      try {
-        return surface.kind === 'swift'
-          ? swiftStandin(surface, binary, toolchain, dir)
-          : cStandin(surface, binary, toolchain, dir)
-      } catch (error) {
-        throw new Error(
-          `no stand-in for ${surface.module}: ${error instanceof Error && !('stderr' in error) ? error.message : failure(error)}`,
-        )
-      }
-    })
+    result =
+      process.platform === 'darwin' &&
+      process.env.TM_SESSION &&
+      process.env.CI !== 'true' &&
+      toolchain.moduleRoot === path.resolve(import.meta.dirname, '../../sootsim-swift') &&
+      !swiftDistributionAt(toolchain.moduleRoot)
+        ? sourceBinaryStandins(binary, toolchain, provided)
+        : found.map((surface) => {
+            const dir = path.join(work, surface.module)
+            try {
+              return surface.kind === 'swift'
+                ? swiftStandin(surface, binary, toolchain, dir)
+                : cStandin(surface, binary, toolchain, dir)
+            } catch (error) {
+              throw new Error(
+                `no stand-in for ${surface.module}: ${error instanceof Error && !('stderr' in error) ? error.message : failure(error)}`,
+              )
+            }
+          })
+    if (typeof result === 'string') return result
     fs.mkdirSync(path.dirname(cached), { recursive: true })
     fs.writeFileSync(cached, JSON.stringify(result))
     built.set(id, result)

package/src/swift-submit.ts

@@ -20,6 +20,12 @@
  * Browser-safe: node-only submitters live beside their call sites.
  */
 
+import {
+  isSwiftMetalLibrarySources,
+  type SwiftMetalLibrarySource,
+  type SwiftResourceBundle,
+} from './swiftContract'
+
 export const SWIFT_COMPILE_PATH = '/api/swift-compile'
 export const SWIFT_PACKAGE_PATH = '/__peach/swift-package/'
 export const SWIFT_HMR_PATH = '/__peach/swift-hmr'
@@ -30,6 +36,9 @@ export const MAX_SWIFT_COMPILE_SOURCE_BYTES = 2 * 1024 * 1024
 export const MAX_SWIFT_COMPILE_RESOURCES = 128
 export const MAX_SWIFT_COMPILE_RESOURCE_BYTES = 2 * 1024 * 1024
 export const MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES = 8 * 1024 * 1024
+export const MAX_SWIFT_COMPILE_METAL_FILES = 128
+export const MAX_SWIFT_COMPILE_METAL_BYTES = 2 * 1024 * 1024
+export const MAX_SWIFT_COMPILE_METAL_TOTAL_BYTES = 8 * 1024 * 1024
 export const MAX_SWIFT_COMPILE_IMAGES = 128
 export const MAX_SWIFT_COMPILE_IMAGE_BYTES = 4 * 1024 * 1024
 export const MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES = 16 * 1024 * 1024
@@ -71,8 +80,25 @@ export const MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES = 16 * 1024 * 1024
  * 22: WebKit script messages carry request ids and receive Promise replies.
  * 23: URLSessionWebSocketTask uses the networking host for real WebSocket transport.
  * 24: WebKit cookie stores share native jars with isolated store lifetimes.
+ * 25: CoreMotion authorization reads motion (4) from the shared permission owner.
  */
-export const SWIFT_HOST_ABI = 24
+// 26: target resource bundles and shader library source assignments.
+// 27: direct Metal requests, asynchronous GPU completion and shared readback.
+// 28: direct render operations and texture readback before completion.
+// 29: original metallib input, native AIR inspection and compute execution.
+// 30: compute texture bytes and immutable sampler bindings at submission.
+// 31: independent vertex/fragment resource snapshots for every render draw.
+// 32: target-owned named images and per-bundle image resource tables.
+// 33: active iOS device identity before Swift native module calls.
+// 34: asynchronous SwiftUI shader prewarm through the compositor device.
+// 35: SwiftUI shader shape fills retain the original shader wire.
+// 36: shader strokes carry width, inset and output-origin geometry.
+// 37: shader foreground and background styles retain their library arguments.
+// 38: typed Swift view exports and package-scoped native descriptors.
+// 39: canvas image draw operations retain their target bundle.
+// 40: implicit animations retain typed value changes through a generation marker.
+// 41: original compiled SwiftUI libraries retain data and deferred URL inputs.
+export const SWIFT_HOST_ABI = 41
 
 export interface SwiftImageUpload {
   /** the raster file picked for the asset (has the extension). */
@@ -108,6 +134,7 @@ export type SwiftCompileOutcome =
        * when the request packs no images.
        */
       imageUrls?: Record<string, string>
+      metalSources?: Record<string, SwiftMetalLibrarySource>
       /** the callable swift modules the sources export; absent when none. */
       native?: SwiftNativeModules
     }
@@ -125,7 +152,7 @@ export type SwiftCompileOutcome =
 const POLL_INTERVAL_MS = 1500
 
 /**
- * the callable surface of a swift package whose sources declare `RNXModule`
+ * the callable surface of a swift package whose sources declare `PeachModule`
  * classes, as vxrn's native-source contract describes it: `one typegen`
  * writes it beside a One package, and the compile host derives it for a
  * project. the dispatch glue compiled into the artifact checks `hash` on every
@@ -138,6 +165,8 @@ export interface SwiftNativeModules {
   files: Record<string, string[]>
   /** module name to its method names. */
   modules: Record<string, string[]>
+  /** typed view name to its prop names. */
+  views: Record<string, string[]>
   /** the files that also declare the package's `@main` view. */
   defaultViewFiles: string[]
 }
@@ -150,14 +179,18 @@ export function swiftNativeEntry(
   packageId: string
   contractHash: string
   modules: Record<string, string[]>
+  views: string[]
   defaultView: boolean
 } {
   return {
     packageId: native.packageId,
     contractHash: native.hash,
     modules: Object.fromEntries(
-      (native.files[file] ?? []).map((name) => [name, native.modules[name] ?? []]),
+      (native.files[file] ?? [])
+        .filter((name) => Object.hasOwn(native.modules, name))
+        .map((name) => [name, native.modules[name]]),
     ),
+    views: (native.files[file] ?? []).filter((name) => Object.hasOwn(native.views, name)),
     defaultView: native.defaultViewFiles.includes(file),
   }
 }
@@ -187,15 +220,17 @@ export interface SwiftCompileContext {
 
 export type SwiftCompileSubmit = (work: {
   files: Record<string, string>
+  metalSources?: Record<string, string>
   /** the bundle pack; absent means the project packs none. */
   resources?: Record<string, string>
   /** project-relative resource paths used to associate implicit resources with targets. */
   resourcePaths?: string[]
+  resourceBundles?: SwiftResourceBundle[]
   /** the photo rasters to publish; absent means the project packs none. */
   images?: Record<string, SwiftImageUpload>
   entry: string
-  /** the id a One package's native modules register under; absent means `App`. */
-  packageId?: string
+  /** the directory-derived id of the One package. */
+  packageId: string
 }) => Promise<SwiftCompileOutcome>
 
 /** the HTTP submitter, shared by the browser worker and the node build. */
@@ -255,7 +290,12 @@ export function isSwiftNativeModules(value: unknown): value is SwiftNativeModule
     typeof value.hash === 'string' &&
     isRecord(value.files) &&
     isRecord(value.modules) &&
-    [...Object.values(value.files), ...Object.values(value.modules)].every(
+    isRecord(value.views) &&
+    [
+      ...Object.values(value.files),
+      ...Object.values(value.modules),
+      ...Object.values(value.views),
+    ].every(
       (names) => Array.isArray(names) && names.every((name) => typeof name === 'string'),
     ) &&
     Array.isArray(value.defaultViewFiles) &&
@@ -275,6 +315,8 @@ function isSwiftCompileOutcome(value: unknown): value is SwiftCompileOutcome {
         (value.imageUrls === undefined ||
           (isRecord(value.imageUrls) &&
             Object.values(value.imageUrls).every((url) => typeof url === 'string'))) &&
+        (value.metalSources === undefined ||
+          isSwiftMetalLibrarySources(value.metalSources)) &&
         (value.native === undefined || isSwiftNativeModules(value.native))
       )
     case 'compiling':
@@ -308,6 +350,7 @@ export interface SwiftModuleAddress {
   icuUrl: string
   /** bundle asset name to absolute photo url, when the pack publishes any. */
   imageUrls?: Record<string, string>
+  metalSources?: Record<string, SwiftMetalLibrarySource>
   /** the callable swift modules the artifact links, when the sources declare any. */
   native?: SwiftNativeModules
 }
@@ -337,12 +380,14 @@ export async function compileSwiftProject(
   submit: SwiftCompileSubmit,
   work: {
     files: Record<string, string>
+    metalSources?: Record<string, string>
     resources?: Record<string, string>
     /** project-relative resource paths used to associate implicit resources with targets. */
     resourcePaths?: string[]
+    resourceBundles?: SwiftResourceBundle[]
     images?: Record<string, SwiftImageUpload>
     entry: string
-    packageId?: string
+    packageId: string
   },
   origin: string,
   signal?: AbortSignal,
@@ -359,6 +404,16 @@ export async function compileSwiftProject(
           ...(outcome.imageUrls === undefined
             ? {}
             : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }),
+          ...(outcome.metalSources === undefined
+            ? {}
+            : {
+                metalSources: Object.fromEntries(
+                  Object.entries(outcome.metalSources).map(([file, source]) => [
+                    file,
+                    { ...source, url: compileAssetUrl(source.url, origin) },
+                  ]),
+                ),
+              }),
           ...(outcome.native === undefined ? {} : { native: outcome.native }),
         }
       case 'compiling':

package/src/swift-toolchain.ts

@@ -10,6 +10,11 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 
+// swift.org's x.y.0 archives report the compiler identity as x.y.
+export function swiftCompilerRelease(release: string): string {
+  return release.replace(/^swift-(\d+\.\d+)\.0-RELEASE$/, 'swift-$1-RELEASE')
+}
+
 /**
  * the bin directory of the toolchain for `release`, unverified. macOS: the
  * Xcode Toolchains directory, the user's before the system's. Linux: a
@@ -62,7 +67,7 @@ export function swiftToolchain(release: string, sdk: SwiftWasmSdk): string {
         stdio: ['ignore', 'pipe', 'pipe'],
       })
     : ''
-  if (!version.includes(`(${release})`)) {
+  if (!version.includes(`(${swiftCompilerRelease(release)})`)) {
     const found = version
       ? `found ${version.split('\n')[0]?.trim()} at ${swift}`
       : process.platform === 'darwin'