peachsim 0.1.1641 → 0.1.1644

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1641 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1644 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __create = Object.create;

package/dist-lib/worklet-executable.cjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1641 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1644 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 let __sootsim_import_meta_url = '', __sootsim_import_meta_dirname = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; __sootsim_import_meta_dirname = __dirname; } catch {}
 "use strict";
 var __defProp = Object.defineProperty;

package/dist-lib/worklet-executable.mjs

@@ -1,4 +1,4 @@
-/*! peach v0.1.1641 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
+/*! peach v0.1.1644 | (c) 2026 Tamagui LLC | Proprietary; see LICENSE */
 
 // src/worklet-executable.ts
 import { parse } from "acorn";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.1641",
+  "version": "0.1.1644",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/src/appBundleResourcesContract.ts

@@ -0,0 +1,51 @@
+import type { PeachBundleAssetReference } from './bundle-asset-resource'
+
+// copied native resources keep their bundle-relative namespace, independently
+// of the host URLs used to deliver their immutable bytes.
+export type AppBundleResources = Record<string, PeachBundleAssetReference>
+
+export function isAppBundleResourcePath(path: string): boolean {
+  return (
+    path.length > 0 &&
+    !path.includes('\0') &&
+    !/[\\?#]/.test(path) &&
+    path.split('/').every((part) => part !== '' && part !== '.' && part !== '..')
+  )
+}
+
+export function readAppBundleResources(wire: string | null): AppBundleResources {
+  if (wire === null) return {}
+  const value: unknown = JSON.parse(wire)
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error('invalid native app bundle resources')
+  const resources: AppBundleResources = Object.create(null)
+  for (const [path, resource] of Object.entries(value)) {
+    if (
+      !isAppBundleResourcePath(path) ||
+      !resource ||
+      typeof resource !== 'object' ||
+      !('uri' in resource) ||
+      typeof resource.uri !== 'string' ||
+      !('sha256' in resource) ||
+      typeof resource.sha256 !== 'string' ||
+      !/^[a-f0-9]{64}$/.test(resource.sha256) ||
+      !('contentType' in resource) ||
+      typeof resource.contentType !== 'string' ||
+      !('byteLength' in resource) ||
+      typeof resource.byteLength !== 'number' ||
+      !Number.isSafeInteger(resource.byteLength) ||
+      resource.byteLength < 0
+    )
+      throw new Error('invalid native app bundle resource')
+    const url = new URL(resource.uri)
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+      throw new Error('invalid native app bundle resource URL')
+    resources[path] = {
+      uri: url.href,
+      sha256: resource.sha256,
+      contentType: resource.contentType,
+      byteLength: resource.byteLength,
+    }
+  }
+  return resources
+}

package/src/backend-origin.ts

@@ -1,4 +1,4 @@
-const DEFAULT_CONTRAST_BACKEND_ORIGIN = 'https://contrast.dev'
+const DEFAULT_CONTRAST_BACKEND_ORIGIN = 'https://peachsim.com'
 
 export const LOOPBACK_PROBE_HOSTNAMES = ['127.0.0.1', '::1'] as const
 
@@ -115,6 +115,8 @@ export function isContrastBackendHost(hostname: string): boolean {
     isLoopbackHost(normalized) ||
     normalized === 'contrast.dev' ||
     normalized.endsWith('.contrast.dev') ||
+    normalized === 'peachsim.com' ||
+    normalized === 'www.peachsim.com' ||
     normalized === PEACHSIM_NATIVE_HOST
   )
 }

package/src/host/bridge-host.ts

@@ -1530,7 +1530,21 @@ export class SootSimBridgeHost {
    *  non-upgrade routes that don't match serve index.html (SPA behavior) so
    *  electron's webContents can navigate freely inside the runtime. */
   private handleHttpRequest(req: IncomingMessage, res: ServerResponse) {
-    if (rejectUntrustedBridgeOrigin(req, res)) return
+    const method = (req.method || 'GET').toUpperCase()
+    let url: URL
+    try {
+      url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`)
+    } catch {
+      res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' })
+      res.end('invalid request URL or host')
+      return
+    }
+    const publicEngineFont =
+      (method === 'GET' || method === 'HEAD') &&
+      /^\/(?:runtime\/|sootsim\/)?engine\/fonts\/[^\\]*\.(ttf|otf|woff2?)$/.test(
+        url.pathname,
+      )
+    if (!publicEngineFont && rejectUntrustedBridgeOrigin(req, res)) return
     if (req.url === '/__peach/fetch-transport') {
       res.writeHead(200, {
         'Content-Type': 'application/json',
@@ -1619,16 +1633,6 @@ export class SootSimBridgeHost {
       return
     }
 
-    const method = (req.method || 'GET').toUpperCase()
-    let url: URL
-    try {
-      url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`)
-    } catch {
-      res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' })
-      res.end('invalid request URL or host')
-      return
-    }
-
     // /__sootsim/shared-config is the one awaited HTTP write. ordinary
     // settings fan out over WS, but destructive reloads need confirmation
     // that the disk source of truth accepted their final reset first.
@@ -1972,6 +1976,8 @@ export class SootSimBridgeHost {
         res.writeHead(200, {
           'Content-Type': contentType,
           'Cache-Control': 'no-store',
+          // native file documents have an opaque origin when reading public fonts.
+          ...(publicEngineFont ? { 'Access-Control-Allow-Origin': '*' } : {}),
         })
         if (method === 'HEAD') {
           res.end()

package/src/host/staged-host-files.ts

@@ -51,11 +51,21 @@ export function stageHostBytes(
   origin: string,
   extension = '',
 ): string {
-  const digest = createHash('sha256').update(bytes).digest('hex')
-  extension = extension.toLowerCase()
-  const name = STAGED_NAME.test(digest + extension) ? digest + extension : digest
+  const directory = prepareStagedDirectory()
+  return writeStagedBytes(bytes, origin, extension, directory)
+}
+
+// a resource pack prunes once, rather than scanning the cache for every file.
+export function stageHostByteFiles(
+  files: readonly Uint8Array[],
+  origin: string,
+): string[] {
+  const directory = prepareStagedDirectory()
+  return files.map((bytes) => writeStagedBytes(bytes, origin, '', directory))
+}
+
+function prepareStagedDirectory(): string {
   const directory = stagedDir()
-  const destination = path.join(directory, name)
   fs.mkdirSync(directory, { recursive: true })
   const now = Date.now()
   for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
@@ -63,6 +73,20 @@ export function stageHostBytes(
     if (entry.isFile() && now - fs.statSync(stale).mtimeMs > STAGED_RETENTION_MS)
       fs.rmSync(stale, { force: true })
   }
+  return directory
+}
+
+function writeStagedBytes(
+  bytes: Uint8Array,
+  origin: string,
+  extension: string,
+  directory: string,
+): string {
+  const digest = createHash('sha256').update(bytes).digest('hex')
+  extension = extension.toLowerCase()
+  const name = STAGED_NAME.test(digest + extension) ? digest + extension : digest
+  const destination = path.join(directory, name)
+  const now = Date.now()
   if (fs.existsSync(destination)) {
     fs.utimesSync(destination, new Date(now), new Date(now))
   } else {

package/src/launchMetadataContract.ts

@@ -6,6 +6,7 @@ export const LAUNCH_METADATA_KEYS: readonly string[] = [
   'appFonts',
   'appSplash',
   'appCatalog',
+  'appBundleResources',
   'nativeAppIdentity',
   'nativeFirebase',
   'appManifest',

package/src/menu.ts

@@ -71,7 +71,13 @@ export const SOOTSIM_RENDER_RESOLUTION_LABELS: Record<SootSimRenderResolution, s
 // engine's wireframe store draws. 'wireframe' is the clean structural sketch;
 // the others are its screen-space styles that ship as named effects.
 export type SootSimScreenEffect = 'none' | 'wireframe' | 'blueprint' | 'panel' | 'green'
-export const SOOTSIM_SCREEN_EFFECTS = ['none', 'wireframe', 'blueprint', 'panel', 'green'] as const
+export const SOOTSIM_SCREEN_EFFECTS = [
+  'none',
+  'wireframe',
+  'blueprint',
+  'panel',
+  'green',
+] as const
 
 export function isSootSimScreenEffect(value: unknown): value is SootSimScreenEffect {
   return (
@@ -373,9 +379,9 @@ function deviceMenu(
       },
       { type: 'separator' },
       { label: 'Trigger Screenshot', action: 'screenshot' },
-      // pose controls for the current device: open/close on foldables,
-      // rotate left/right wherever a turn changes geometry, the way ios
-      // simulator holds them (rotate left is cmd+left, rotate right
+      // pose controls for the current device: open/close, book and laptop on
+      // foldables, rotate left/right wherever a turn changes geometry, the way
+      // ios simulator holds them (rotate left is cmd+left, rotate right
       // cmd+right). truthiness, not !== null: a partial state must hide
       // these, never show duo items for the wrong device.
       ...(state.devicePosture || state.canRotate
@@ -390,6 +396,8 @@ function deviceMenu(
                         : 'Open iPhone Duo',
                     action: 'toggle-duo-posture',
                   },
+                  { label: 'Book Pose', action: 'fold-duo-book' },
+                  { label: 'Laptop Pose', action: 'fold-duo-laptop' },
                 ]
               : []),
             ...(state.canRotate

package/src/native-app-identity-project.ts

@@ -326,44 +326,8 @@ function readIosNativeAppIdentity(
   parseInfoPlist: (source: string) => unknown,
   iosTarget: string | undefined,
 ): NativeAppIdentity | null {
-  const iosRoot = path.join(projectRoot, 'ios')
-  if (!fs.existsSync(iosRoot)) return null
-  const projects = fs
-    .readdirSync(iosRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && entry.name.endsWith('.xcodeproj'))
-  if (projects.length === 0) return null
-  if (projects.length > 1 && !iosTarget) {
-    throw new NativeAppTargetSelectionError(
-      `native app identity requires a selected Xcode project; set withPeach's iosTarget to an app target in one of: ${projects.map((entry) => entry.name).join(', ')}`,
-    )
-  }
-  let project = projects[0]!
-  if (iosTarget && projects.length > 1) {
-    const matches = projects.filter((entry) =>
-      listXcodeAppTargets(path.join(iosRoot, entry.name), {
-        requireSources: false,
-      }).includes(iosTarget),
-    )
-    if (matches.length === 0) {
-      throw new Error(`native app identity has no application target ${iosTarget}`)
-    }
-    if (matches.length > 1) {
-      throw new Error(
-        `native app identity target ${iosTarget} is ambiguous across ${matches.map((entry) => entry.name).join(', ')}`,
-      )
-    }
-    project = matches[0]!
-  }
-  const xcodeproj = path.join(iosRoot, project.name)
-  const appTargets = listXcodeAppTargets(xcodeproj, { requireSources: false })
-  if (!iosTarget && appTargets.length > 1) {
-    throw new NativeAppTargetSelectionError(
-      `native app identity requires a selected app target; set withPeach's iosTarget to one of: ${appTargets.join(', ')}`,
-    )
-  }
-  const app = readXcodeAppTarget(xcodeproj, iosTarget ?? appTargets[0], 'Release', {
-    requireSources: false,
-  })
+  const app = readIosAppTarget(projectRoot, iosTarget)
+  if (!app) return null
   const identity = readNativeAppIdentityFromXcodeTarget(app, parseInfoPlist)
   const projectManifestPath = path.join(projectRoot, 'package.json')
   const projectRequire = createRequire(projectManifestPath)
@@ -422,3 +386,48 @@ function readIosNativeAppIdentity(
   }
   return { ...identity, reanimatedStaticFeatureFlags: flags }
 }
+
+// native identity and copied resources must select the same application target.
+export function readIosAppTarget(
+  projectRoot: string,
+  iosTarget?: string,
+): XcodeAppTarget | null {
+  const iosRoot = path.join(projectRoot, 'ios')
+  if (!fs.existsSync(iosRoot)) return null
+  const projects = fs
+    .readdirSync(iosRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && entry.name.endsWith('.xcodeproj'))
+  if (projects.length === 0) return null
+  if (projects.length > 1 && !iosTarget) {
+    throw new NativeAppTargetSelectionError(
+      `native app identity requires a selected Xcode project; set withPeach's iosTarget to an app target in one of: ${projects.map((entry) => entry.name).join(', ')}`,
+    )
+  }
+  let project = projects[0]!
+  if (iosTarget && projects.length > 1) {
+    const matches = projects.filter((entry) =>
+      listXcodeAppTargets(path.join(iosRoot, entry.name), {
+        requireSources: false,
+      }).includes(iosTarget),
+    )
+    if (matches.length === 0) {
+      throw new Error(`native app identity has no application target ${iosTarget}`)
+    }
+    if (matches.length > 1) {
+      throw new Error(
+        `native app identity target ${iosTarget} is ambiguous across ${matches.map((entry) => entry.name).join(', ')}`,
+      )
+    }
+    project = matches[0]!
+  }
+  const xcodeproj = path.join(iosRoot, project.name)
+  const appTargets = listXcodeAppTargets(xcodeproj, { requireSources: false })
+  if (!iosTarget && appTargets.length > 1) {
+    throw new NativeAppTargetSelectionError(
+      `native app identity requires a selected app target; set withPeach's iosTarget to one of: ${appTargets.join(', ')}`,
+    )
+  }
+  return readXcodeAppTarget(xcodeproj, iosTarget ?? appTargets[0], 'Release', {
+    requireSources: false,
+  })
+}

package/src/runtime-delivery.ts

@@ -3,7 +3,7 @@
 // the machinery itself (hosted manifest, sha256-verified tarballs, channels,
 // channel resolution, and auto-update) lives in @contrast/runtime-delivery and
 // knows nothing about peach. this file supplies peach's identity, public env
-// overrides, and the contrast.dev/runtimes hosting layout.
+// overrides, and the peachsim.com/runtimes hosting layout.
 //
 // @contrast/runtime-delivery is an internal workspace package that is never
 // published, so both the CLI bundle and dist-lib inline it (see the `alias`
@@ -20,14 +20,13 @@ import {
   runtimesDir,
   writeActiveRuntime,
 } from './home-paths.ts'
-import { rnxPublicBrand } from './public-brand.ts'
+import { peachPublicBrand } from './public-brand.ts'
 
-export const DEFAULT_RUNTIME_CDN_ORIGIN = 'https://contrast.dev'
+export const DEFAULT_RUNTIME_CDN_ORIGIN = peachPublicBrand.origin
 
-/** the official curated changelog and the machine-readable release feed. the
- *  peach site is static, so its /api traffic is owned by contrast.dev. */
-export const RNX_CHANGELOG_URL = `${rnxPublicBrand.origin}/changelog`
-export const RNX_CHANGELOG_API_URL = 'https://contrast.dev/api/changelog/sootsim'
+/** the official curated changelog and the machine-readable release feed. */
+export const RNX_CHANGELOG_URL = `${peachPublicBrand.origin}/changelog`
+export const RNX_CHANGELOG_API_URL = `${peachPublicBrand.origin}/api/changelog/sootsim`
 
 export const RNX_RUNTIME_PRODUCT: RuntimeProduct = {
   id: 'peach',

package/src/swift-compile.ts

@@ -1,4 +1,9 @@
-import { spawn, execFileSync, type ExecFileOptions } from 'node:child_process'
+import {
+  spawn,
+  execFileSync,
+  type ExecFileOptions,
+  type SpawnOptions,
+} from 'node:child_process'
 import { createHash } from 'node:crypto'
 import {
   cpSync,
@@ -33,7 +38,7 @@ import {
   swiftTargetModuleName,
   type SwiftPackageTarget,
 } from './swift-package'
-import { withSwiftRootLock } from './swift-root-lock'
+import { withSwiftRootLock, type SwiftRootLease } from './swift-root-lock'
 import { swiftEnvironment, swiftSdkOptions, type SwiftWasmSdk } from './swift-toolchain'
 import { isSwiftResourceBundles } from './swiftContract'
 import type { SwiftImageUpload } from './swift-submit'
@@ -43,24 +48,29 @@ export { swiftIcuAsset, type SwiftIcuAsset }
 
 // compiler drivers own descendants such as admission and swiftpm workers.
 // cancellation waits for their pipes to close before releasing the build root.
+// a `lease` records the group under the root's lock, so the root stays held
+// while the compiler lives even if this process does not.
 // `stream` echoes the output as it arrives: all of it, or only matching lines.
 // a successful run then echoes the rest minus lines matching `quiet`, its
 // warnings; a failed run's output goes to the caller's one diagnostic.
 async function runCompiler(
   command: string,
   args: string[],
-  options: ExecFileOptions & { signal?: AbortSignal },
+  options: ExecFileOptions & { signal?: AbortSignal; lease?: SwiftRootLease },
   stream: boolean | RegExp = false,
   quiet?: RegExp,
 ): Promise<void> {
   const { signal } = options
   signal?.throwIfAborted()
-  const child = spawn(command, args, {
+  const launch = {
     cwd: options.cwd,
     env: swiftEnvironment(options.env),
     detached: true,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
+    stdio: ['ignore', 'pipe', 'pipe'] as ['ignore', 'pipe', 'pipe'],
+  } satisfies SpawnOptions
+  const child = options.lease
+    ? options.lease.spawn(command, args, launch)
+    : spawn(command, args, launch)
   let stopping: Promise<void> | undefined
   try {
     await new Promise<void>((resolve, reject) => {
@@ -6242,7 +6252,7 @@ export function compileSwiftProjectUnit(
       // using it, so one process writes, builds and reads them at a time.
       return withSwiftRootLock(
         root,
-        async () => {
+        async (lease) => {
           // a process that held the root while this one waited may have built
           // this exact address.
           const built = readCompiledArtifact(path.join(sharedRoot, 'artifact'), hash)
@@ -6314,6 +6324,7 @@ export function compileSwiftProjectUnit(
             maxBuffer: 64 * 1024 * 1024,
             timeout: options.timeoutMs,
             signal: options.signal,
+            lease,
           }
           report('compiling and linking Swift modules')
           try {

package/src/swift-compiler-digest.ts

@@ -3,11 +3,13 @@ import { readFileSync } from 'node:fs'
 import path from 'node:path'
 
 // the lowering and manifest code in swift-compile.ts and its design-time lowering
-// decide the emitted output, so their text addresses every swift artifact. bundled
-// builds cannot read these files at runtime, so build-cli injects this digest.
+// decide the emitted output, and the root lock decides whose sources and
+// executable an address names, so their text addresses every swift artifact.
+// bundled builds cannot read these files at runtime, so build-cli injects this
+// digest.
 export function swiftCompilerSourceDigest(srcDir: string): string {
   const hash = createHash('sha256')
-  for (const file of ['swift-compile.ts', 'swift-design-time.ts']) {
+  for (const file of ['swift-compile.ts', 'swift-design-time.ts', 'swift-root-lock.ts']) {
     hash.update(readFileSync(path.join(srcDir, file)))
   }
   return hash.digest('hex')

package/src/swift-objc-compile.ts

@@ -37,6 +37,19 @@ export function compileXcodeObjCImplementations(
   )
 }
 
+// a link's target, or null when the target is proven absent; other failures surface.
+function linkedStat(file: string): fs.Stats | null {
+  try {
+    return fs.statSync(file)
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+const isSdkInclude = (file: string): boolean =>
+  file === '/usr/include' || file.startsWith('/usr/include/')
+
 /** prepares genuine objects without authorizing unsupported framework linkage. */
 export function prepareXcodeObjCImplementations(
   app: XcodeAppTarget,
@@ -63,13 +76,24 @@ export function prepareXcodeObjCImplementations(
         ),
       )
   }
+  const walked = new Set<string>()
+  const ancestors = new Set<string>()
   const addHeaders = (directory: string): void => {
+    // a versioned framework links Headers to a real directory: stage each path it is reached by, once, never around a link cycle.
+    const real = fs.realpathSync(directory)
+    if (walked.has(directory) || ancestors.has(real)) return
+    walked.add(directory)
+    ancestors.add(real)
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
-      if (entry.isDirectory() && entry.name.startsWith('.')) continue
+      if (entry.name.startsWith('.') && !entry.isFile()) continue
       const file = path.join(directory, entry.name)
-      if (entry.isDirectory()) addHeaders(file)
+      // a link to nothing is never opened by the compiler: a header that is needed fails there as not found.
+      const linked = entry.isSymbolicLink() ? linkedStat(file) : null
+      if (entry.isSymbolicLink() && !linked) continue
+      if (entry.isDirectory() || linked?.isDirectory()) addHeaders(file)
       else if (/\.(h|hh|hpp|hxx|inc|inl|modulemap)$/.test(entry.name)) add(file, true)
     }
+    ancestors.delete(real)
   }
   const targets: {
     name: string
@@ -152,6 +176,12 @@ export function prepareXcodeObjCImplementations(
       ),
     ])
       add(file, true)
+    // search paths name directories of headers the target includes; /usr/include maps to the wasm sysroot.
+    for (const directory of [
+      ...target.objc.headerSearchPaths,
+      ...target.objc.frameworkSearchPaths,
+    ])
+      if (!isSdkInclude(directory) && fs.existsSync(directory)) addHeaders(directory)
     targets.push({
       name: target.moduleName,
       deploymentTarget: target.iosDeploymentTarget,
@@ -290,8 +320,8 @@ export function prepareXcodeObjCImplementations(
           return path.join(work, name, relative)
       }
       // native SDK include paths select the wasm SDK, never host system headers.
-      if (file.startsWith('/usr/include/'))
-        return path.join(sdk.sysroot, 'include', file.slice('/usr/include/'.length))
+      if (isSdkInclude(file))
+        return path.join(sdk.sysroot, 'include', file.slice('/usr/include'.length))
       throw new Error(
         `Objective-C compiler input is outside the project and its pinned packages: ${file}`,
       )