peachsim 0.1.1620 → 0.1.1635

package/src/vite-plugin.ts

@@ -17,6 +17,7 @@ import { fileURLToPath, pathToFileURL } from 'url'
 import { parseSync } from 'oxc-parser'
 import { minifySync, transformSync } from 'rolldown/utils'
 import { type Plugin, transformWithOxc } from 'vite'
+import { resolveOneNativeBackend } from '../../contrast-bundler/src/oneFramework.ts'
 import { transformFlowSource } from '../../peach-compat/src/flow-strip.ts'
 import { renderWorkerSystemChunk } from './worker-system-chunks.ts'
 
@@ -34,7 +35,7 @@ import {
 import { resolveExportsHiddenSubpath } from '../../peach-compat/src/resolve-hidden-subpath.ts'
 import {
   SOOTSIM_COMPAT_PUBLISHED_BROWSER_ENTRIES,
-  SOOTSIM_COMPAT_WRAPPER_REAL_PACKAGES,
+  PEACH_UPSTREAM_MODULES,
   SOOTSIM_HAPTIC_FEEDBACK_TOUCHABLE_SOURCE,
   SOOTSIM_HAPTIC_FEEDBACK_TOUCHABLE_SPECIFIER,
   compatStubsForBuildResolver,
@@ -46,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,
@@ -291,9 +295,7 @@ const compatWrapperRealPackageAliases: Array<{
   find: string
   replacement: string
 }> = []
-for (const { specifier, packageName } of Object.values(
-  SOOTSIM_COMPAT_WRAPPER_REAL_PACKAGES,
-)) {
+for (const { specifier, packageName } of Object.values(PEACH_UPSTREAM_MODULES)) {
   let replacement = resolveExportsHiddenSubpath(packageName, (specifier) =>
     sootsimPluginRequire.resolve(specifier),
   )
@@ -366,7 +368,6 @@ export function sootsim(options: SootSimOptions = {}): Plugin[] {
   }
 
   return [
-    wsBridgePlugin(),
     reactBridgePlugin(),
     {
       name: 'sootsim-published-browser-internals',
@@ -1319,10 +1320,11 @@ declare global {
 // across the overlap so every connected sim stays on the same websocket.
 const viteBridgeProcesses = (globalThis.__sootsimViteBridgeProcesses ??= new Map())
 
-// start WS bridge server for debug CLI connectivity. exported so shell
-// vite can install it standalone (engine builds via `vite build --watch`,
-// which doesn't fire configureServer — the bridge has to run on shell).
+// start WS bridge server for debug CLI connectivity. the shell vite server
+// 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) ||
@@ -1654,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) {
@@ -1726,17 +1735,6 @@ function sootsimConfigPlugin(
                 'react-native/src/private/featureflags/ReactNativeFeatureFlags.js',
               ),
             },
-            ...[
-              'BatchedBridge/BatchedBridge',
-              'Components/View/ReactNativeStyleAttributes',
-              'StyleSheet/processColor',
-            ].map((module) => ({
-              find: `@peach-internal/react-native/${module}`,
-              replacement: path.resolve(
-                workspaceNodeModules,
-                `react-native/Libraries/${module}.js`,
-              ),
-            })),
             ...Object.entries(rnLibraryStubs).map(([find, replacement]) => ({
               find: new RegExp(
                 `^${find.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\.[cm]?[jt]sx?)?$`,
@@ -2227,6 +2225,8 @@ function metroNativeResolve(isAppSource: (p: string) => boolean): Plugin {
       filter: { id: /^\./ },
       handler(source, importer) {
         if (!importer) return null
+        const oneBackend = resolveOneNativeBackend(source, importer)
+        if (oneBackend) return oneBackend
         if (!importer.includes('node_modules') && !isAppSource(importer)) return null
         if (platformExts.some((ext) => source.endsWith(ext))) return null
 

package/src/worklet-executable.ts

@@ -92,7 +92,7 @@ interface Scope {
 
 type Binding =
   | { kind: 'value'; init: SyntaxNode; scope: Scope }
-  // `key` is set when the parameter is a destructured property of that argument.
+  // `key` is set when the parameter is a destructured member of that argument.
   | { kind: 'param'; fn: SyntaxNode; index: number; key?: string }
   | { kind: 'opaque' }
 
@@ -147,7 +147,7 @@ function lookup(scope: Scope, name: string): Binding | undefined {
   return undefined
 }
 
-// a destructured parameter binds each plain property to that key of its argument.
+// a destructured parameter binds each plain member to that key of its argument.
 // rest elements, defaults and nested patterns stay opaque.
 function declareParam(inner: Scope, fn: SyntaxNode, index: number, param: unknown): void {
   const name = identifierName(param)
@@ -155,6 +155,17 @@ function declareParam(inner: Scope, fn: SyntaxNode, index: number, param: unknow
     declare(inner, name, { kind: 'param', fn, index })
     return
   }
+  if (isNode(param) && param.type === 'ArrayPattern') {
+    const elements: unknown = Reflect.get(param, 'elements')
+    if (!Array.isArray(elements)) return
+    elements.forEach((element: unknown, position) => {
+      const name = identifierName(element)
+      if (name !== undefined)
+        declare(inner, name, { kind: 'param', fn, index, key: String(position) })
+      else declareOpaque(inner, patternNames(element))
+    })
+    return
+  }
   if (!isNode(param) || param.type !== 'ObjectPattern') {
     declareOpaque(inner, patternNames(param))
     return
@@ -334,6 +345,21 @@ function immediateArgument(
 // the value a literal holds under a static name. the last duplicate wins, as it
 // does at run time. a spread makes the literal's keys unknown.
 function propertyValue(object: SyntaxNode, name: string): SyntaxNode | undefined {
+  if (object.type === 'ArrayExpression') {
+    const index = Number(name)
+    const elements: unknown = Reflect.get(object, 'elements')
+    if (!Number.isSafeInteger(index) || index < 0 || String(index) !== name)
+      return undefined
+    if (!Array.isArray(elements)) return undefined
+    if (
+      elements
+        .slice(0, index + 1)
+        .some((element: unknown) => isNode(element) && element.type === 'SpreadElement')
+    )
+      return undefined
+    const value: unknown = elements[index]
+    return isNode(value) ? value : undefined
+  }
   let value: SyntaxNode | undefined
   for (const property of childNodes(Reflect.get(object, 'properties'))) {
     if (property.type === 'SpreadElement') return undefined
@@ -373,7 +399,8 @@ function resolveObject(
   depth: number,
 ): ResolvedObject | undefined {
   if (depth > MAX_RESOLUTION_DEPTH) return undefined
-  if (expression.type === 'ObjectExpression') return { object: expression, scope }
+  if (expression.type === 'ObjectExpression' || expression.type === 'ArrayExpression')
+    return { object: expression, scope }
   if (expression.type === 'SequenceExpression') {
     const last = childNodes(Reflect.get(expression, 'expressions')).at(-1)
     return last && resolveObject(last, scope, collection, depth + 1)

package/src/worklets-babel.ts

@@ -54,10 +54,17 @@ const REANIMATED_IMPORT_REGEX =
 // app installed, so they compile with the engine's own plugin and carry no
 // version stamp. every other file is app code and compiles like it does on
 // device: with the plugin the app installed, stamped for the app's runtime.
-const ENGINE_STAND_IN_PATHS = ['/packages/peach-engine/src/', '/packages/peach-compat/src/']
+const ENGINE_STAND_IN_PATHS = [
+  '/packages/peach-engine/src/',
+  '/packages/peach-compat/src/',
+]
 
 const workletsPlugins = new Map<string, { path: string; identity: string }>()
 let babelCorePromise: Promise<typeof import('@babel/core')> | null = null
+const pendingWorkletTransforms = new Map<
+  string,
+  Promise<Pick<TransformResult, 'code' | 'map'> | null>
+>()
 
 export function shouldApplyWorkletsPlugin(id: string, code: string): boolean {
   if (!/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/.test(id)) return false
@@ -93,7 +100,10 @@ function getWorkletsPlugin(id: string): { path: string; identity: string } {
   const manifest = JSON.parse(
     fs.readFileSync(path.resolve(path.dirname(pluginPath), '..', 'package.json'), 'utf8'),
   ) as { version?: string }
-  const plugin = { path: pluginPath, identity: `${pluginPath}@${manifest.version ?? '0'}` }
+  const plugin = {
+    path: pluginPath,
+    identity: `${pluginPath}@${manifest.version ?? '0'}`,
+  }
   workletsPlugins.set(fromDir, plugin)
   return plugin
 }
@@ -109,7 +119,7 @@ function isTypescriptFile(id: string): boolean {
 // normal dev rebuild changes a handful of files and replays the rest.
 export type WorkletBodyMode = 'executable' | 'transport'
 
-const CACHE_SCHEMA = 'v7'
+const CACHE_SCHEMA = 'v8'
 const CACHE_ROOT = path.resolve(
   workspaceRoot,
   'node_modules',
@@ -321,23 +331,34 @@ export async function transformWorkletsCode(
   bodyMode: WorkletBodyMode = 'executable',
 ): Promise<Pick<TransformResult, 'code' | 'map'> | null> {
   const entryPath = getCacheEntryPath(code, id, sourceMaps, bodyMode)
+  const pending = entryPath && pendingWorkletTransforms.get(entryPath)
+  if (pending) return pending
   const cached = readCachedTransform(entryPath)
   if (cached) return cached
   if (!babelCorePromise) {
     babelCorePromise = import('@babel/core') as Promise<typeof import('@babel/core')>
   }
-  const { transformAsync } = await babelCorePromise
-  const result = await transformAsync(
-    code,
-    createWorkletsBabelOptions(id, sourceMaps, bodyMode),
-  )
-  if (!result?.code) return null
-  const transformed = {
-    code: result.code,
-    map: (result.map ?? null) as TransformResult['map'],
+  // nested worker graphs can request the same cold transform before babel
+  // finishes. share only active work; watch edits must not retain old results.
+  const transform = babelCorePromise.then(async ({ transformAsync }) => {
+    const result = await transformAsync(
+      code,
+      createWorkletsBabelOptions(id, sourceMaps, bodyMode),
+    )
+    if (!result?.code) return null
+    const transformed = {
+      code: result.code,
+      map: (result.map ?? null) as TransformResult['map'],
+    }
+    writeCachedTransform(entryPath, transformed)
+    return transformed
+  })
+  if (entryPath) pendingWorkletTransforms.set(entryPath, transform)
+  try {
+    return await transform
+  } finally {
+    if (entryPath) pendingWorkletTransforms.delete(entryPath)
   }
-  writeCachedTransform(entryPath, transformed)
-  return transformed
 }
 
 export function transformWorkletsCodeSync(

package/src/xcode-project.ts

@@ -940,6 +940,16 @@ export function readXcodeAppTarget(
     info[key.slice('INFOPLIST_KEY_'.length)] =
       value === 'YES' ? true : value === 'NO' ? false : value
   }
+  if (settings('GENERATE_INFOPLIST_FILE') === 'YES') {
+    const versions = {
+      CFBundleShortVersionString: 'MARKETING_VERSION',
+      CFBundleVersion: 'CURRENT_PROJECT_VERSION',
+    }
+    for (const [key, setting] of Object.entries(versions)) {
+      const value = settings(setting)
+      if (info[key] === undefined && value) info[key] = value
+    }
+  }
   if (
     settings('INFOPLIST_KEY_UIApplicationSceneManifest_Generation') === 'YES' &&
     info.UIApplicationSceneManifest === undefined