vxrn 2.0.0-beta.99.1 → 2.6.0

package/src/plugins/workletImportsPlugin.ts

@@ -4,7 +4,8 @@ import { dirname, isAbsolute, join } from 'node:path'
 import { statSync } from 'node:fs'
 import { rolldown, type Plugin } from 'rolldown'
 import { parseSync } from 'oxc-parser'
-import { getClosureVariables, JS_GLOBALS, transformHermesLoops } from '@vxrn/compiler'
+import { createBackgroundWorkletModule } from '../backgroundComputation'
+import { prepareBackgroundWorkletModule } from '../backgroundComputationNative'
 import { hermesCompatSWCPlugin, hermesLoopsPlugin } from '../utils/createNativeDevEngine'
 
 /**
@@ -40,7 +41,12 @@ export function workletImportsPlugin(imports: Record<string, readonly string[]>)
       const instance: Plugin = {
         name: 'vxrn:worklet-imports:bundle',
         async resolveId(source, importer, options) {
-          const names = selections.get(source)
+          const marker = '?one-background='
+          const selected = source.indexOf(marker)
+          const names =
+            selected < 0
+              ? selections.get(source)
+              : [decodeURIComponent(source.slice(selected + marker.length))]
           if (!names) return
           if (!names.length)
             throw new Error(`[worklet imports] no exports selected for ${source}`)
@@ -48,7 +54,11 @@ export function workletImportsPlugin(imports: Record<string, readonly string[]>)
             throw new Error(`[worklet imports] ${source} requires a static ESM import`)
           }
           rejectRuntimeDependency(source)
-          const resolved = await this.resolve(source, importer, { skipSelf: true })
+          const resolved = await this.resolve(
+            selected < 0 ? source : source.slice(0, selected),
+            importer,
+            { skipSelf: true }
+          )
           if (
             !resolved ||
             resolved.external ||
@@ -173,7 +183,7 @@ export function workletImportsPlugin(imports: Record<string, readonly string[]>)
               )
             }
             // also cover closure-bearing loops in helpers emitted by the bundler.
-            code = transformHermesLoops(chunk.code, id)?.code ?? chunk.code
+            code = chunk.code
             for (const file of await bundle.watchFiles) {
               if (isAbsolute(file)) outerContext.addWatchFile(file)
             }
@@ -181,40 +191,12 @@ export function workletImportsPlugin(imports: Record<string, readonly string[]>)
             await bundle.close()
           }
 
-          const loader = `__oneLoadWorkletModule_${selected.key}`
-          const loaderCode = `function ${loader}() {
-  'worklet';
-  const cache = globalThis.__oneWorkletImportCache || (globalThis.__oneWorkletImportCache = new WeakMap());
-  let namespace = cache.get(${loader});
-  if (namespace === undefined) {
-    ${code}
-    namespace = __oneWorkletBundle;
-    cache.set(${loader}, namespace);
-  }
-  return namespace;
-}`
-          const parsed = parseSync(id, loaderCode, { lang: 'js' })
-          if (parsed.errors.length) throw new Error(parsed.errors[0].message)
-          const captures = getClosureVariables(
-            parsed.program.body[0],
-            new Set([...JS_GLOBALS, 'arguments'])
+          const moduleSource = createBackgroundWorkletModule(
+            code,
+            selected.names,
+            selected.key
           )
-          if (captures.length) {
-            throw new Error(
-              `[worklet imports] ${selected.entry} requires unsupported runtime globals: ${captures.join(', ')}`
-            )
-          }
-          return `${loaderCode}\n${selected.names
-            .map(
-              (name, index) => `
-function __oneExport${index}(...args) {
-  'worklet';
-  return (0, ${loader}().__export${index})(...args);
-}
-export { __oneExport${index} as ${JSON.stringify(name)} };
-`
-            )
-            .join('\n')}`
+          return prepareBackgroundWorkletModule(moduleSource, selected.entry)
         },
       }
       return {

package/src/rn-commands/bundle/buildBundle.ts

@@ -93,17 +93,19 @@ export async function buildBundle(
 
   // write sourcemap if available and requested
   if (result.map && args.sourcemapOutput) {
-    FSExtra.writeFileSync(args.sourcemapOutput, result.map, { encoding: 'utf8' })
+    FSExtra.outputFileSync(args.sourcemapOutput, result.map, { encoding: 'utf8' })
   }
 
   console.info(`Writing bundle to ${bundleOutput}...`)
-  FSExtra.writeFileSync(bundleOutput, builtBundle, { encoding: bundleEncoding })
+  FSExtra.outputFileSync(bundleOutput, builtBundle, { encoding: bundleEncoding })
   console.info('Done.')
 
   // Prevent the process not getting exited for some unknown reason.
   // If the process is not exited, it might hang the native build process.
+  // unref so a clean build exits as soon as its work is done; the timer only
+  // fires when something else still holds the event loop.
   setTimeout(() => {
     console.info('Exiting process to prevent hanging.')
     process.exit()
-  }, 30000)
+  }, 30000).unref()
 }

package/src/swift-package-id.ts

@@ -0,0 +1 @@
+export { swiftPackageDirOf, swiftPackageDirectories, swiftPackageId } from './utils/swiftPackageId'

package/src/utils/compileNativeDevBytecode.test.ts

@@ -0,0 +1,168 @@
+import { chmod, mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { afterEach, beforeEach, expect, it } from 'vitest'
+import { nativeDevBytecodeCompiler } from './compileNativeDevBytecode'
+
+const savedHermescPath = process.env.HERMESC_PATH
+beforeEach(() => {
+  delete process.env.HERMESC_PATH
+})
+afterEach(() => {
+  if (savedHermescPath === undefined) delete process.env.HERMESC_PATH
+  else process.env.HERMESC_PATH = savedHermescPath
+})
+
+it.each(['prebuilt', 'source'])(
+  'shares compiled bytes and retries failures with %s hermes',
+  async (mode) => {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-dev-bytecode-test-'))
+    const require = createRequire(import.meta.url)
+    const compilerRoot = dirname(require.resolve('hermes-compiler/package.json'))
+    const host = { darwin: 'osx-bin', linux: 'linux64-bin', win32: 'win64-bin' }[
+      process.platform
+    ]!
+    const pod = join(root, 'ios/Pods/hermes-engine/destroot/bin')
+    try {
+      await mkdir(pod, { recursive: true })
+      await symlink(
+        join(
+          compilerRoot,
+          'hermesc',
+          host,
+          process.platform === 'win32' ? 'hermesc.exe' : 'hermesc'
+        ),
+        join(pod, 'hermesc')
+      )
+      const specs = join(root, 'ios/Pods/Local Podspecs')
+      await mkdir(specs, { recursive: true })
+      await writeFile(
+        join(specs, 'hermes-engine.podspec.json'),
+        JSON.stringify({
+          subspecs: [{ name: mode === 'prebuilt' ? 'Pre-built' : 'Hermes' }],
+          user_target_xcconfig: {
+            HERMES_CLI_PATH: '${PODS_ROOT}/hermes-engine/destroot/bin/hermesc',
+          },
+        })
+      )
+      const compiler = nativeDevBytecodeCompiler(root)
+      const compile = (bundle: { code: string; map: string }) =>
+        compiler(bundle, 'http://localhost:8081/index.bundle?platform=ios')
+      const first = { code: 'globalThis.answer = 42;', map: '' }
+      const pending = compile(first)
+      expect(compile(first)).toBe(pending)
+      const bytes = await pending
+      expect(bytes.subarray(0, 8).toString('hex')).toBe('c61fbc03c103191f')
+      expect(await compile(first)).toBe(bytes)
+      const changed = await compile({ code: 'globalThis.answer = 43;', map: '' })
+      expect(changed.equals(bytes)).toBe(false)
+      const invalid = { code: 'function {', map: '' }
+      const failed = compile(invalid)
+      await expect(failed).rejects.toThrow()
+      const retried = compile(invalid)
+      expect(retried).not.toBe(failed)
+      await expect(retried).rejects.toThrow()
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  }
+)
+
+function hostHermesc(): string {
+  const require = createRequire(import.meta.url)
+  const compilerRoot = dirname(require.resolve('hermes-compiler/package.json'))
+  const host = { darwin: 'osx-bin', linux: 'linux64-bin', win32: 'win64-bin' }[
+    process.platform
+  ]!
+  return join(
+    compilerRoot,
+    'hermesc',
+    host,
+    process.platform === 'win32' ? 'hermesc.exe' : 'hermesc'
+  )
+}
+
+it('uses HERMESC_PATH without any ios/Pods', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'vxrn-dev-bytecode-override-'))
+  process.env.HERMESC_PATH = hostHermesc()
+  try {
+    const compiler = nativeDevBytecodeCompiler(root)
+    const bytes = await compiler(
+      { code: 'globalThis.answer = 42;', map: '' },
+      'http://localhost:8081/index.bundle?platform=ios'
+    )
+    expect(bytes.subarray(0, 8).toString('hex')).toBe('c61fbc03c103191f')
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+it('treats empty HERMESC_PATH as unset', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'vxrn-dev-bytecode-empty-'))
+  process.env.HERMESC_PATH = '   '
+  try {
+    expect(() => nativeDevBytecodeCompiler(root)).toThrow(
+      /hermes-engine\.podspec\.json/
+    )
+    expect(() => nativeDevBytecodeCompiler(root)).not.toThrow(/HERMESC_PATH is set/)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+it('loudly rejects a HERMESC_PATH that points nowhere', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'vxrn-dev-bytecode-invalid-'))
+  process.env.HERMESC_PATH = join(root, 'no-such-hermesc')
+  try {
+    expect(() => nativeDevBytecodeCompiler(root)).toThrow(
+      /HERMESC_PATH is set but points nowhere/
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+// windows has no executable bit, so this case is posix-only.
+it.runIf(process.platform !== 'win32')(
+  'loudly rejects a non-executable HERMESC_PATH',
+  async () => {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-dev-bytecode-noexec-'))
+    const plain = join(root, 'not-executable')
+    await writeFile(plain, 'x')
+    await chmod(plain, 0o644)
+    process.env.HERMESC_PATH = plain
+    try {
+      expect(() => nativeDevBytecodeCompiler(root)).toThrow(
+        /HERMESC_PATH is not executable/
+      )
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  }
+)
+
+it('loudly rejects a root without ios/Pods when the override is unset', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'vxrn-dev-bytecode-nopods-'))
+  try {
+    expect(() => nativeDevBytecodeCompiler(root)).toThrow(
+      /hermes-engine\.podspec\.json.*HERMESC_PATH/s
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+it('loudly rejects a malformed podspec when the override is unset', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'vxrn-dev-bytecode-malformed-'))
+  try {
+    const specs = join(root, 'ios/Pods/Local Podspecs')
+    await mkdir(specs, { recursive: true })
+    await writeFile(join(specs, 'hermes-engine.podspec.json'), '{oops')
+    expect(() => nativeDevBytecodeCompiler(root)).toThrow(
+      /hermes-engine\.podspec\.json/
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})

package/src/utils/compileNativeDevBytecode.ts

@@ -0,0 +1,117 @@
+import { accessSync, constants, readFileSync, statSync } from 'node:fs'
+import { execFile } from 'node:child_process'
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { promisify } from 'node:util'
+import type { NativeDevBundle } from './createNativeDevEngine'
+
+const execute = promisify(execFile)
+
+// explicit compiler ownership for split layouts, where the dev server root
+// is not the native project (the iOS test job serves tests/test while the
+// container is built from tests/rn-test-container). empty means unset.
+function useHermescOverride(): string | undefined {
+  const override = process.env.HERMESC_PATH?.trim()
+  if (!override) return undefined
+  let stat: ReturnType<typeof statSync> | undefined
+  try {
+    stat = statSync(override)
+  } catch {
+    stat = undefined
+  }
+  if (!stat?.isFile()) {
+    throw new Error(
+      `[vxrn] HERMESC_PATH is set but points nowhere: ${override}. ` +
+        `Point it at the hermesc binary the native build used, or unset it to resolve the pod compiler.`
+    )
+  }
+  try {
+    accessSync(override, constants.X_OK)
+  } catch {
+    throw new Error(
+      `[vxrn] HERMESC_PATH is not executable: ${override}. ` +
+        `Point it at the hermesc binary the native build used, or unset it to resolve the pod compiler.`
+    )
+  }
+  return override
+}
+
+// the pod compiler matches the actual native vm, including rn's prebuilt
+// hermes replacement. the npm compiler can target a different bytecode version.
+function resolvePodHermesc(root: string): string {
+  const pods = join(root, 'ios/Pods')
+  const podspecPath = join(pods, 'Local Podspecs/hermes-engine.podspec.json')
+  let podspec: {
+    subspecs: { name: string }[]
+    user_target_xcconfig?: { HERMES_CLI_PATH?: string }
+  }
+  try {
+    podspec = JSON.parse(readFileSync(podspecPath, 'utf8'))
+  } catch (error) {
+    throw new Error(
+      `[vxrn] native iOS dev bytecode needs the pod hermesc but ${root} has no usable native project: ` +
+        `cannot read ${podspecPath} (${error instanceof Error ? error.message : String(error)}). ` +
+        `Run prebuild and pod install for this app, or set HERMESC_PATH to the hermesc the native build used.`
+    )
+  }
+  if (!Array.isArray(podspec.subspecs)) {
+    throw new Error(
+      `[vxrn] native iOS dev bytecode needs the pod hermesc but ${podspecPath} declares no subspecs. ` +
+        `Reinstall pods for this app, or set HERMESC_PATH to the hermesc the native build used.`
+    )
+  }
+  const prebuilt = podspec.subspecs.some(
+    (spec: { name: string }) => spec.name === 'Pre-built'
+  )
+  if (prebuilt) {
+    return join(pods, 'hermes-engine/destroot/bin/hermesc')
+  }
+  const cliPath = podspec.user_target_xcconfig?.HERMES_CLI_PATH
+  if (!cliPath) {
+    throw new Error(
+      `[vxrn] native iOS dev bytecode needs the pod hermesc but ${podspecPath} declares no HERMES_CLI_PATH. ` +
+        `Reinstall pods for this app, or set HERMESC_PATH to the hermesc the native build used.`
+    )
+  }
+  return cliPath.replace(/\$\(PODS_ROOT\)|\$\{PODS_ROOT\}/g, pods)
+}
+
+// compile once per emitted bundle. the device can start a fresh hermes context
+// without compiling every cold route's module closures on its js thread.
+export function nativeDevBytecodeCompiler(root: string) {
+  const compiler = useHermescOverride() ?? resolvePodHermesc(root)
+  const compiled = new WeakMap<NativeDevBundle, Map<string, Promise<Buffer>>>()
+
+  return (bundle: NativeDevBundle, sourceURL: string): Promise<Buffer> => {
+    let urls = compiled.get(bundle)
+    if (!urls) compiled.set(bundle, (urls = new Map()))
+    const existing = urls.get(sourceURL)
+    if (existing) return existing
+    const result = (async () => {
+      const directory = await mkdtemp(join(tmpdir(), 'vxrn-dev-hermes-'))
+      try {
+        // hermesc records its input argument as the debug filename. use the
+        // served js url as a relative filename so stacks and devtools retain
+        // the original bundle coordinates without a second source map.
+        const source = join(directory, sourceURL)
+        await mkdir(dirname(source), { recursive: true })
+        const output = join(directory, 'index.hbc')
+        await writeFile(source, bundle.code)
+        await execute(
+          compiler,
+          ['-Og', '-g', '-emit-binary', '-out', output, sourceURL],
+          { cwd: directory, maxBuffer: 16 * 1024 * 1024 }
+        )
+        return await readFile(output)
+      } finally {
+        await rm(directory, { recursive: true, force: true })
+      }
+    })().catch((error) => {
+      urls.delete(sourceURL)
+      throw error
+    })
+    urls.set(sourceURL, result)
+    return result
+  }
+}