peachsim 0.1.939 → 0.1.1399

package/src/vite.d.ts

@@ -7,4 +7,4 @@ export interface PeachPluginOptions {
   open?: boolean | { appName: string }
 }
 
-export declare function rnxPlugin(options?: PeachPluginOptions): Plugin
+export declare function peachPlugin(options?: PeachPluginOptions): Plugin

package/src/worker-system-chunks.ts

@@ -0,0 +1,221 @@
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import { Worker } from 'node:worker_threads'
+import { rollup } from 'rollup'
+import { isRecord } from './is-record'
+
+const require = createRequire(import.meta.url)
+const systemRuntime = fs.readFileSync(require.resolve('systemjs/dist/s.min.js'), 'utf8')
+const minifierModule = require.resolve('terser')
+type MinifiedWorkerChunk = { code: string; map: string }
+const minifierWorker = `
+const { parentPort, workerData } = require('node:worker_threads');
+const { minify } = require(workerData.module);
+parentPort.on('message', async ({ code, map, keepNames }) => {
+  try {
+    const result = await minify(code, {
+      module: true,
+      compress: { passes: 2 },
+      mangle: true,
+      keep_fnames: keepNames,
+      keep_classnames: keepNames,
+      sourceMap: { content: map },
+    });
+    parentPort.postMessage({ code: result.code, map: result.map });
+  } catch (error) {
+    parentPort.postMessage({ error: error instanceof Error ? error.message : String(error) });
+  }
+});
+`
+type MinifierJob = {
+  code: string
+  map: string
+  keepNames: boolean
+  resolve: (result: MinifiedWorkerChunk) => void
+  reject: (error: Error) => void
+}
+type MinifierSlot = {
+  worker: Worker
+  job: MinifierJob | undefined
+  failure: Error | undefined
+}
+// share two reusable isolates across every worker build in this vite process.
+const minifiers = new Set<MinifierSlot>()
+const pendingMinifiers: MinifierJob[] = []
+
+function runMinifiers() {
+  while (pendingMinifiers.length) {
+    let slot = [...minifiers].find((candidate) => !candidate.job && !candidate.failure)
+    if (!slot) {
+      if (minifiers.size === 2) return
+      let worker: Worker
+      try {
+        worker = new Worker(minifierWorker, {
+          eval: true,
+          execArgv: [],
+          workerData: { module: minifierModule },
+        })
+      } catch (error) {
+        pendingMinifiers
+          .shift()
+          ?.reject(error instanceof Error ? error : new Error(String(error)))
+        continue
+      }
+      const created: MinifierSlot = { worker, job: undefined, failure: undefined }
+      minifiers.add(created)
+      worker.on('message', (message: unknown) => {
+        if (created.failure) return
+        const job = created.job
+        let result: MinifiedWorkerChunk | Error
+        if (isRecord(message) && typeof message.error === 'string') {
+          result = new Error(message.error)
+        } else if (
+          isRecord(message) &&
+          typeof message.code === 'string' &&
+          message.code &&
+          typeof message.map === 'string'
+        ) {
+          result = { code: message.code, map: message.map }
+        } else {
+          created.failure = new Error(
+            'worker minification produced no code or source map',
+          )
+          void worker.terminate()
+          return
+        }
+        if (!job) {
+          created.failure = new Error('worker minifier returned an unexpected result')
+          void worker.terminate()
+          return
+        }
+        created.job = undefined
+        // idle isolates must not keep a completed build process alive.
+        worker.unref()
+        if (result instanceof Error) job.reject(result)
+        else job.resolve(result)
+        runMinifiers()
+      })
+      worker.on('error', (error) => {
+        created.failure = error instanceof Error ? error : new Error(String(error))
+      })
+      // a failed isolate owns its slot until its thread has actually exited.
+      worker.once('exit', (status) => {
+        minifiers.delete(created)
+        created.job?.reject(
+          created.failure ??
+            new Error(`worker minifier exited ${status} without a result`),
+        )
+        runMinifiers()
+      })
+      slot = created
+    }
+    const job = pendingMinifiers.shift()
+    if (!job) return
+    slot.job = job
+    slot.worker.ref()
+    try {
+      slot.worker.postMessage({ code: job.code, map: job.map, keepNames: job.keepNames })
+    } catch (error) {
+      slot.failure = error instanceof Error ? error : new Error(String(error))
+      void slot.worker.terminate()
+    }
+  }
+}
+
+// systemjs owns linking, live exports, cycles and evaluation identity. its
+// instantiate hook uses the same fetch and script evaluation in every worker
+// host, including public JavaScriptCore. each fetch captures its own anonymous
+// registration so concurrent chunks cannot consume one another's declarations.
+const workerLoader = `
+// chunk fetching yields before the worker's message listener is installed.
+// retain the payloads and transferred ports until linking ends. intercepted
+// events keep their immediate-propagation flag, so replay fresh native events.
+const pendingWorkerMessages = [];
+const WorkerMessageEvent = globalThis.MessageEvent;
+const dispatchWorkerMessage = globalThis.dispatchEvent.bind(globalThis);
+const removeWorkerMessageListener = globalThis.removeEventListener.bind(globalThis);
+function bufferWorkerMessage(event) {
+  pendingWorkerMessages.push(new WorkerMessageEvent('message', {
+    data: event.data,
+    origin: event.origin,
+    lastEventId: event.lastEventId,
+    source: event.source,
+    ports: event.ports,
+  }));
+  event.stopImmediatePropagation();
+}
+globalThis.addEventListener('message', bufferWorkerMessage, true);
+const workerEntryUrl = globalThis.location.href;
+const workerEntryRegistration = System.getRegister();
+System.instantiate = async function(url) {
+  if (url === workerEntryUrl) return workerEntryRegistration;
+  const response = await fetch(url, { credentials: 'same-origin' });
+  if (!response.ok) throw new Error(url + ': HTTP ' + response.status);
+  let registration;
+  new Function('System', await response.text())({
+    register(dependencies, declare) { registration = [dependencies, declare]; }
+  });
+  if (!registration) throw new Error(url + ': missing worker registration');
+  return registration;
+};
+await System.import(workerEntryUrl);
+removeWorkerMessageListener('message', bufferWorkerMessage, true);
+for (const event of pendingWorkerMessages) dispatchWorkerMessage(event);
+pendingWorkerMessages.length = 0;
+`
+
+export async function renderWorkerSystemChunk(
+  code: string,
+  isEntry: boolean,
+  keepNames = false,
+) {
+  const entry = '\0peach-worker-chunk'
+  const bundle = await rollup({
+    input: entry,
+    treeshake: false,
+    plugins: [
+      {
+        name: 'peach-worker-system-chunk',
+        resolveId(id) {
+          return id === entry ? id : { id, external: true }
+        },
+        load(id) {
+          return id === entry ? code : null
+        },
+        renderDynamicImport({ targetModuleId }) {
+          // runtime-supplied URLs name ES modules outside the generated graph.
+          // generated chunk imports retain their SystemJS registration loader.
+          if (targetModuleId === null) return { left: 'import(', right: ')' }
+        },
+      },
+    ],
+  })
+  let loweredCode: string
+  let loweredMap: string
+  try {
+    const { output } = await bundle.generate({
+      format: 'system',
+      sourcemap: true,
+      banner: isEntry ? systemRuntime : undefined,
+      footer: isEntry ? workerLoader : undefined,
+    })
+    const chunk = output[0]
+    if (!chunk || chunk.type !== 'chunk' || !chunk.map)
+      throw new Error('worker module lowering produced no chunk or source map')
+    loweredCode = chunk.code
+    loweredMap = chunk.map.toString()
+  } finally {
+    await bundle.close()
+  }
+
+  return new Promise<MinifiedWorkerChunk>((resolve, reject) => {
+    pendingMinifiers.push({
+      code: loweredCode,
+      map: loweredMap,
+      keepNames,
+      resolve,
+      reject,
+    })
+    runMinifiers()
+  })
+}

package/src/worklet-executable.ts

@@ -12,14 +12,14 @@ function isNode(value: unknown): value is SyntaxNode {
   )
 }
 
-function walk(node: SyntaxNode, visit: (node: SyntaxNode) => void): void {
-  visit(node)
-  for (const value of Object.values(node)) {
-    if (isNode(value)) walk(value, visit)
-    else if (Array.isArray(value)) {
-      for (const child of value) if (isNode(child)) walk(child, visit)
-    }
-  }
+function childNodes(value: unknown): SyntaxNode[] {
+  return Array.isArray(value) ? value.filter(isNode) : []
+}
+
+function identifierName(node: unknown): string | undefined {
+  if (!isNode(node) || node.type !== 'Identifier') return undefined
+  const name = Reflect.get(node, 'name')
+  return typeof name === 'string' ? name : undefined
 }
 
 function propertyName(node: unknown): string | undefined {
@@ -28,48 +28,358 @@ function propertyName(node: unknown): string | undefined {
   return typeof name === 'string' ? name : undefined
 }
 
-// collect upstream init records by their actual __initData assignments, including
-// minified identifiers and inline records. babel and acorn share these node shapes.
-export function workletExecutableBodies(syntax: unknown): Array<{
+// the static name a member or property key selects. a computed identifier names a
+// variable, not a key, so it has none.
+function keyName(owner: SyntaxNode, key: unknown): string | undefined {
+  if (Reflect.get(owner, 'computed') === true && isNode(key) && key.type === 'Identifier')
+    return undefined
+  return propertyName(key)
+}
+
+// the names a binding pattern declares or an assignment target writes.
+function patternNames(node: unknown): string[] {
+  if (!isNode(node)) return []
+  switch (node.type) {
+    case 'Identifier': {
+      const name = identifierName(node)
+      return name === undefined ? [] : [name]
+    }
+    case 'AssignmentPattern':
+      return patternNames(Reflect.get(node, 'left'))
+    case 'RestElement':
+      return patternNames(Reflect.get(node, 'argument'))
+    case 'ArrayPattern':
+      return childNodes(Reflect.get(node, 'elements')).flatMap(patternNames)
+    case 'ObjectPattern':
+      return childNodes(Reflect.get(node, 'properties')).flatMap((property) =>
+        patternNames(
+          property.type === 'Property' || property.type === 'ObjectProperty'
+            ? Reflect.get(property, 'value')
+            : property,
+        ),
+      )
+    default:
+      return []
+  }
+}
+
+// a scope holds the names declared directly in one scope-owning node. `hoist`
+// marks where `var` lands: a function body or the program.
+interface Scope {
+  parent: Scope | undefined
+  hoist: boolean
+  names: Map<string, Binding>
+}
+
+type Binding =
+  | { kind: 'value'; init: SyntaxNode; scope: Scope }
+  // `key` is set when the parameter is a destructured property of that argument.
+  | { kind: 'param'; fn: SyntaxNode; index: number; key?: string }
+  | { kind: 'opaque' }
+
+interface InitCollection {
+  // the right side of each `x.__initData = ...`, with the scope it evaluates in.
+  inits: Array<{ value: SyntaxNode; scope: Scope }>
+  // each immediately invoked function, keyed by its callee, with the call and its scope.
+  immediate: Map<SyntaxNode, { call: SyntaxNode; scope: Scope }>
+  // names written by assignment, resolved after the walk.
+  writes: Array<{ name: string; scope: Scope }>
+  // bindings written after their declaration; their value is not static.
+  reassigned: Set<Binding>
+}
+
+const FUNCTION_TYPES = new Set([
+  'FunctionDeclaration',
+  'FunctionExpression',
+  'ArrowFunctionExpression',
+])
+const MAX_RESOLUTION_DEPTH = 32
+
+function newScope(parent: Scope | undefined, hoist: boolean): Scope {
+  return { parent, hoist, names: new Map() }
+}
+
+function hoistScope(scope: Scope): Scope {
+  let current = scope
+  while (!current.hoist && current.parent) current = current.parent
+  return current
+}
+
+// a second declaration of one name in one scope leaves its value order-dependent,
+// so the name stays opaque rather than picking either declaration.
+function declare(scope: Scope, name: string, binding: Binding): void {
+  scope.names.set(name, scope.names.has(name) ? { kind: 'opaque' } : binding)
+}
+
+function declareOpaque(scope: Scope, names: string[]): void {
+  for (const name of names) declare(scope, name, { kind: 'opaque' })
+}
+
+function lookup(scope: Scope, name: string): Binding | undefined {
+  for (let current: Scope | undefined = scope; current; current = current.parent) {
+    const binding = current.names.get(name)
+    if (binding) return binding
+  }
+  return undefined
+}
+
+// a destructured parameter binds each plain property 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)
+  if (name !== undefined) {
+    declare(inner, name, { kind: 'param', fn, index })
+    return
+  }
+  if (!isNode(param) || param.type !== 'ObjectPattern') {
+    declareOpaque(inner, patternNames(param))
+    return
+  }
+  for (const property of childNodes(Reflect.get(param, 'properties'))) {
+    const key = keyName(property, Reflect.get(property, 'key'))
+    const value: unknown = Reflect.get(property, 'value')
+    const valueName = identifierName(value)
+    if (
+      key !== undefined &&
+      valueName !== undefined &&
+      ['Property', 'ObjectProperty'].includes(property.type)
+    )
+      declare(inner, valueName, { kind: 'param', fn, index, key })
+    else
+      declareOpaque(
+        inner,
+        patternNames(property.type === 'RestElement' ? property : value),
+      )
+  }
+}
+
+// the scope a node's children are visited in, after declaring the names it binds.
+function enter(node: SyntaxNode, scope: Scope): Scope {
+  switch (node.type) {
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'ArrowFunctionExpression': {
+      const inner = newScope(scope, true)
+      const params = Reflect.get(node, 'params')
+      if (Array.isArray(params)) {
+        params.forEach((param: unknown, index) => declareParam(inner, node, index, param))
+      }
+      const id = Reflect.get(node, 'id')
+      if (node.type === 'FunctionExpression') declareOpaque(inner, patternNames(id))
+      if (node.type === 'FunctionDeclaration') {
+        declareOpaque(scope, patternNames(id))
+        declareOpaque(hoistScope(scope), patternNames(id))
+      }
+      return inner
+    }
+    case 'BlockStatement':
+    case 'ForStatement':
+    case 'ForInStatement':
+    case 'ForOfStatement':
+    case 'SwitchStatement':
+    case 'StaticBlock':
+      return newScope(scope, false)
+    case 'CatchClause': {
+      const inner = newScope(scope, false)
+      declareOpaque(inner, patternNames(Reflect.get(node, 'param')))
+      return inner
+    }
+    case 'VariableDeclaration': {
+      const target = Reflect.get(node, 'kind') === 'var' ? hoistScope(scope) : scope
+      for (const declarator of childNodes(Reflect.get(node, 'declarations'))) {
+        const id = Reflect.get(declarator, 'id')
+        const init = Reflect.get(declarator, 'init')
+        const name = identifierName(id)
+        if (name !== undefined && isNode(init))
+          declare(target, name, { kind: 'value', init, scope })
+        else declareOpaque(target, patternNames(id))
+      }
+      return scope
+    }
+    case 'ImportDeclaration':
+      for (const specifier of childNodes(Reflect.get(node, 'specifiers')))
+        declareOpaque(scope, patternNames(Reflect.get(specifier, 'local')))
+      return scope
+    case 'ClassDeclaration':
+      declareOpaque(scope, patternNames(Reflect.get(node, 'id')))
+      return scope
+    default:
+      return scope
+  }
+}
+
+function recordWrites(target: unknown, scope: Scope, collection: InitCollection): void {
+  for (const name of patternNames(target)) collection.writes.push({ name, scope })
+}
+
+// facts read where they occur: init assignments, immediate calls and writes.
+function record(node: SyntaxNode, scope: Scope, collection: InitCollection): void {
+  switch (node.type) {
+    case 'AssignmentExpression': {
+      const left = Reflect.get(node, 'left')
+      const right = Reflect.get(node, 'right')
+      if (
+        isNode(left) &&
+        left.type === 'MemberExpression' &&
+        keyName(left, Reflect.get(left, 'property')) === '__initData' &&
+        isNode(right)
+      )
+        collection.inits.push({ value: right, scope })
+      recordWrites(left, scope, collection)
+      return
+    }
+    case 'UpdateExpression':
+      recordWrites(Reflect.get(node, 'argument'), scope, collection)
+      return
+    case 'ForInStatement':
+    case 'ForOfStatement':
+      recordWrites(Reflect.get(node, 'left'), scope, collection)
+      return
+    case 'CallExpression': {
+      const callee = Reflect.get(node, 'callee')
+      if (isNode(callee) && FUNCTION_TYPES.has(callee.type))
+        collection.immediate.set(callee, { call: node, scope })
+      return
+    }
+    default:
+      return
+  }
+}
+
+function visit(node: SyntaxNode, scope: Scope, collection: InitCollection): void {
+  record(node, scope, collection)
+  const inner = enter(node, scope)
+  for (const value of Object.values(node)) {
+    if (isNode(value)) visit(value, inner, collection)
+    else for (const child of childNodes(value)) visit(child, inner, collection)
+  }
+}
+
+function collectInitData(root: SyntaxNode): InitCollection {
+  const collection: InitCollection = {
+    inits: [],
+    immediate: new Map(),
+    writes: [],
+    reassigned: new Set(),
+  }
+  visit(root, newScope(undefined, true), collection)
+  for (const { name, scope } of collection.writes) {
+    const binding = lookup(scope, name)
+    if (binding) collection.reassigned.add(binding)
+  }
+  return collection
+}
+
+// the argument an immediately invoked function passes to one parameter.
+function immediateArgument(
+  fn: SyntaxNode,
+  index: number,
+  collection: InitCollection,
+): { argument: unknown; scope: Scope } | undefined {
+  const immediate = collection.immediate.get(fn)
+  const args: unknown = immediate && Reflect.get(immediate.call, 'arguments')
+  if (!immediate || !Array.isArray(args)) return undefined
+  // a spread before the parameter shifts every later argument position.
+  const preceding: unknown[] = args.slice(0, index + 1)
+  if (preceding.some((arg) => isNode(arg) && arg.type === 'SpreadElement'))
+    return undefined
+  return { argument: args[index], scope: immediate.scope }
+}
+
+// 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 {
+  let value: SyntaxNode | undefined
+  for (const property of childNodes(Reflect.get(object, 'properties'))) {
+    if (property.type === 'SpreadElement') return undefined
+    if (!['Property', 'ObjectProperty'].includes(property.type)) continue
+    if (keyName(property, Reflect.get(property, 'key')) !== name) continue
+    const next: unknown = Reflect.get(property, 'value')
+    value = isNode(next) ? next : undefined
+  }
+  return value
+}
+
+interface ResolvedObject {
+  object: SyntaxNode
+  scope: Scope
+}
+
+// the object literal under one static key of a resolved owner.
+function resolveProperty(
+  owner: ResolvedObject | undefined,
+  name: string,
+  collection: InitCollection,
+  depth: number,
+): ResolvedObject | undefined {
+  if (!owner) return undefined
+  const value = propertyValue(owner.object, name)
+  return value && resolveObject(value, owner.scope, collection, depth + 1)
+}
+
+// the object literal an expression yields, when it is statically known: a literal,
+// a binding whose value is one, a parameter of an immediately invoked function
+// bound to its argument (or to a key of it), or a static member of one of those.
+function resolveObject(
+  expression: SyntaxNode,
+  scope: Scope,
+  collection: InitCollection,
+  depth: number,
+): ResolvedObject | undefined {
+  if (depth > MAX_RESOLUTION_DEPTH) return undefined
+  if (expression.type === 'ObjectExpression') return { object: expression, scope }
+  if (expression.type === 'Identifier') {
+    const name = identifierName(expression)
+    const binding = name === undefined ? undefined : lookup(scope, name)
+    if (!binding || collection.reassigned.has(binding)) return undefined
+    if (binding.kind === 'value')
+      return resolveObject(binding.init, binding.scope, collection, depth + 1)
+    if (binding.kind === 'param') {
+      const passed = immediateArgument(binding.fn, binding.index, collection)
+      if (!passed || !isNode(passed.argument)) return undefined
+      const argument = resolveObject(passed.argument, passed.scope, collection, depth + 1)
+      return binding.key === undefined
+        ? argument
+        : resolveProperty(argument, binding.key, collection, depth)
+    }
+    return undefined
+  }
+  if (expression.type === 'MemberExpression') {
+    const name = keyName(expression, Reflect.get(expression, 'property'))
+    const object: unknown = Reflect.get(expression, 'object')
+    if (name === undefined || !isNode(object)) return undefined
+    const owner = resolveObject(object, scope, collection, depth + 1)
+    return resolveProperty(owner, name, collection, depth)
+  }
+  return undefined
+}
+
+// collect upstream init records by their actual __initData assignments. each
+// assigned expression resolves lexically to an inline literal, a variable or
+// parameter, or a member of an immediately invoked function's argument, which is
+// how minified bundles pass their init records. babel and acorn share these shapes.
+export function workletExecutableBodies(
+  syntax: unknown,
+  includeCompiled = false,
+): Array<{
   initData: SyntaxNode
   codeProperty: SyntaxNode
   code: string
 }> {
   if (!isNode(syntax)) throw new Error('peach: expected worklet syntax')
-  const tree = syntax
-  const initNames = new Set<string>()
+  const collection = collectInitData(syntax)
   const objects = new Set<SyntaxNode>()
-  walk(tree, (node) => {
-    if (node.type !== 'AssignmentExpression') return
-    const left = Reflect.get(node, 'left')
-    if (
-      !isNode(left) ||
-      left.type !== 'MemberExpression' ||
-      propertyName(Reflect.get(left, 'property')) !== '__initData'
-    )
-      return
-    const right = Reflect.get(node, 'right')
-    if (!isNode(right)) return
-    if (right.type === 'ObjectExpression') objects.add(right)
-    else if (right.type === 'Identifier') {
-      const name = propertyName(right)
-      if (name) initNames.add(name)
-    }
-  })
-  walk(tree, (node) => {
-    if (node.type !== 'VariableDeclarator') return
-    const name = propertyName(Reflect.get(node, 'id'))
-    const init = Reflect.get(node, 'init')
-    if (name && initNames.has(name) && isNode(init) && init.type === 'ObjectExpression') {
-      objects.add(init)
-    }
-  })
+  for (const { value, scope } of collection.inits) {
+    const resolved = resolveObject(value, scope, collection, 0)
+    if (resolved) objects.add(resolved.object)
+  }
   const bodies: Array<{ initData: SyntaxNode; codeProperty: SyntaxNode; code: string }> =
     []
   for (const object of objects) {
     const properties = Reflect.get(object, 'properties')
     if (!Array.isArray(properties)) continue
     if (
+      !includeCompiled &&
       properties.some(
         (property) =>
           isNode(property) &&

package/src/worklets-babel.ts

@@ -93,7 +93,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 = 'v4'
+const CACHE_SCHEMA = 'v5'
 const CACHE_ROOT = path.resolve(
   workspaceRoot,
   'node_modules',