vxrn 1.25.16 → 1.26.0

package/src/utils/createNativeDevEngine.test.ts

@@ -2,14 +2,16 @@ import { existsSync } from 'node:fs'
 import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { runInNewContext } from 'node:vm'
+import { createContext, runInContext, runInNewContext } from 'node:vm'
 import { rolldown, type RolldownOutput } from 'rolldown'
 import { dev } from 'rolldown/experimental'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import { getNativePrelude } from '../runtime/native-prelude'
+import { workletImportsPlugin } from '../plugins/workletImportsPlugin'
 import {
   buildNativeBundle,
   createNativeDevAssetRegistry,
+  createNativeDevEngine,
   getNativeAssetData,
   getHermesSWCIncludes,
   getHmrRuntimeSource,
@@ -29,13 +31,225 @@ export const transformProbe = () => {
 }
 `
 
+// node guards lowering semantics; the async-default regression itself needs
+// hermes, where the original arrow resolves its await to undefined.
+describe.each(['rolldown-dev', 'rolldown-build', 'metro-module', 'metro-script'])(
+  'native async through %s',
+  (pipeline) => {
+    it('preserves defaults, lexical bindings, bigint, rejection, and iterator cleanup', async () => {
+      const id = '/project/native-async.js'
+      const source = `
+globalThis.result = (function(parentArgument) {
+  const events = [];
+  const run = async(value = 2n, fail = false) => {
+    try {
+      const awaited = await (fail ? Promise.reject(new Error('rejected')) : Promise.resolve(3n));
+      events.push('after-await');
+      return [String(value + awaited), this.base, arguments[0]];
+    } catch (error) { return error.message; }
+    finally { events.push('finally'); }
+  };
+  const badDefault = async(value = (() => { throw new Error('default'); })()) => value;
+  let synchronousThrow = false;
+  let rejectedDefault;
+  try { rejectedDefault = badDefault().catch(error => error.message); }
+  catch { synchronousThrow = true; }
+  async function* values() {
+    try { yield 1n; yield 2n; }
+    finally { events.push('closed'); }
+  }
+  const first = async() => { for await (const value of values()) return String(value); };
+  return Promise.all([run(), run(4n), run(undefined, true), rejectedDefault, first()])
+    .then(values => ({ values, events, synchronousThrow }));
+}).call({ base: 7 }, 'lexical');
+`
+      let output: any
+      if (pipeline.startsWith('metro')) {
+        const { transform } = await import('@vxrn/vite-plugin-metro/metroNativeWorker')
+        const result = await transform({}, '/project', id, Buffer.from(source), {
+          dev: false,
+          platform: 'ios',
+          type: pipeline === 'metro-script' ? 'script' : 'module',
+        })
+        const data = result.output[0].data
+        const { fromRawMappings } = await import('metro-source-map')
+        output = {
+          code: data.code,
+          map: (fromRawMappings as any)([
+            { code: data.code, path: id, source, map: data.map },
+          ]).toMap(),
+        }
+      } else {
+        const plugin = hermesCompatSWCPlugin(pipeline === 'rolldown-dev', true)
+        output = await Reflect.apply(plugin.transform as Function, undefined, [
+          source,
+          id,
+        ])
+      }
+      const context: any = {}
+      context.__d = (factory: any) => {
+        const module = { exports: {} }
+        factory(
+          context,
+          (name: string) => {
+            throw new Error(`unexpected dependency ${name}`)
+          },
+          () => {},
+          () => {},
+          module,
+          module.exports,
+          []
+        )
+      }
+      runInNewContext(output.code, context)
+      const result = await context.result
+      expect(result.values).toEqual([
+        ['5', 7, 'lexical'],
+        ['7', 7, 'lexical'],
+        'rejected',
+        'default',
+        '1',
+      ])
+      expect(result.synchronousThrow).toBe(false)
+      expect(result.events.filter((value: string) => value === 'finally')).toHaveLength(3)
+      expect(result.events.filter((value: string) => value === 'closed')).toHaveLength(1)
+      const { originalPositionFor, TraceMap } = await import('@jridgewell/trace-mapping')
+      const lines = output.code.split('\n')
+      const line = lines.findIndex((value: string) => value.includes('after-await'))
+      const position = originalPositionFor(new TraceMap(output.map), {
+        line: line + 1,
+        column: lines[line].indexOf('events.push'),
+      })
+      expect(position.source).toBe(id)
+      expect(position.line).toBe(
+        source.split('\n').findIndex((value) => value.includes('after-await')) + 1
+      )
+    })
+  }
+)
+
+describe.each(['shared', 'rolldown', 'metro'])('React Compiler worklets through %s', (pipeline) => {
+  it.each([
+    ['block', 'useDerivedValue(() => { return value + 8 }, [value])', 18],
+    ['expression', 'useDerivedValue(() => value + 8, [value])', 18],
+    ['object', 'useDerivedValue(() => ({ lift: value + 8 }), [value])', { lift: 18 }],
+    ['nested', 'useDerivedValue(() => runOnUI(() => value + 8), [value])', 18],
+    ['gesture', 'useDerivedValue(() => Gesture.Pan().onUpdate(() => value + 8), [value])', 18],
+  ])('preserves %s callbacks on the UI runtime and memoizes stable inputs', async (_name, callback, expected) => {
+    const compiler = await import('@vxrn/compiler')
+    const { parseSync } = await import('oxc-parser')
+    const { default: MagicString } = await import('magic-string')
+    const { TraceMap, originalPositionFor } = await import('@jridgewell/trace-mapping')
+    const projectRoot = await createWorkletsProject(false)
+    const sourceMaps = process.env.VXRN_ENABLE_SOURCE_MAP
+    process.env.VXRN_ENABLE_SOURCE_MAP = '1'
+    compiler.configureVXRNCompilerPlugin({
+      enableCompiler: true,
+      enableReanimated: true,
+      enableNativeWorklets: true,
+    })
+    try {
+      const id = join(projectRoot, 'useProbe.ts')
+      const source = `export function useProbe(value) {\n return ${callback};\n}\n`
+      await writeFile(id, source)
+      let result: any
+      if (pipeline === 'shared') {
+        const plugins = await compiler.createVXRNCompilerPlugin()
+        const plugin = plugins.find((p: any) => p.name === 'one:compiler') as any
+        await plugin.configResolved({ root: projectRoot, build: {} })
+        const hook = plugin.transform.handler || plugin.transform
+        result = await hook.call({ environment: { name: 'ios' } }, source, id)
+      } else if (pipeline === 'metro') {
+        const { transform } = await import('@vxrn/vite-plugin-metro/metroNativeWorker')
+        const output = await transform({}, projectRoot, id, Buffer.from(source), {
+          dev: false,
+          platform: 'ios',
+          type: 'module',
+          customTransformOptions: { reactCompiler: true, worklets: true },
+        })
+        const data = output.output[0].data
+        const msm = await import('metro-source-map')
+        result = {
+          code: data.code,
+          map: (msm.fromRawMappings as any)([{ code: data.code, path: id, source, map: data.map }]).toMap(),
+        }
+      } else {
+        const plugin = vxrnCompilerPlugin('ios', false, projectRoot, true)
+        result = await Reflect.apply(plugin.transform as Function, undefined, [source, id])
+      }
+      const runnable = new MagicString(result.code)
+      for (const node of parseSync('probe.js', result.code).program.body) {
+        if (node.type === 'ImportDeclaration') runnable.remove(node.start, node.end)
+        if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+          runnable.remove(node.start, node.declaration.start)
+        }
+      }
+      let cache: any[] | undefined
+      let cacheCalls = 0
+      const memo = (size: number) => {
+        cacheCalls++
+        return cache ??= Array(size).fill(Symbol.for('react.memo_cache_sentinel'))
+      }
+      const module = { exports: {} as any }
+      const probe = new Function('_c', 'useDerivedValue', 'runOnUI', 'Gesture', '__d', 'module',
+        `${runnable}\nreturn ${pipeline === 'metro' ? 'module.exports.useProbe' : 'useProbe'}`
+      )(
+        memo,
+        (fn: any) => fn,
+        (fn: any) => fn,
+        { Pan: () => ({ onUpdate: (fn: any) => fn }) },
+        (factory: any) => factory(globalThis, () => ({ c: memo }), () => {}, () => {}, module, module.exports, []),
+        module
+      )
+      const first = probe(10)
+      expect(first.__initData?.code).toBeTypeOf('string')
+      for (const onUI of [false, true]) {
+        let fn = first
+        let value: any
+        for (let depth = 0; depth < 2; depth++) {
+          expect(fn.__initData?.code).toBeTypeOf('string')
+          value = onUI
+            ? new Function('runOnUI', `return (${fn.__initData.code})`)((fn: any) => fn)
+                .call({ __closure: fn.__closure })
+            : fn()
+          if (typeof value !== 'function') break
+          fn = value
+        }
+        expect(value).toEqual(expected)
+      }
+      expect(probe(10)).toBe(first)
+      expect(cacheCalls).toBe(2)
+      expect(probe(20)).not.toBe(first)
+
+      const lines = result.code.split('\n')
+      const line = lines.findIndex((text: string) => text.includes('function useProbe('))
+      expect(line).toBeGreaterThanOrEqual(0)
+      const position = originalPositionFor(new TraceMap(result.map), {
+        line: line + 1,
+        column: lines[line].indexOf('function'),
+      })
+      expect(position.source).toBe(id)
+      expect(position.line).toBe(1)
+    } finally {
+      if (sourceMaps === undefined) delete process.env.VXRN_ENABLE_SOURCE_MAP
+      else process.env.VXRN_ENABLE_SOURCE_MAP = sourceMaps
+      compiler.configureVXRNCompilerPlugin({
+        enableCompiler: false,
+        enableReanimated: false,
+        enableNativeWorklets: false,
+      })
+      await rm(projectRoot, { recursive: true, force: true })
+    }
+  })
+})
+
 async function createWorkletsProject(throwOnTransform = true) {
   const testRoot = await mkdtemp(join(tmpdir(), 'vxrn-native-transform-failure-'))
   const packageRoot = join(testRoot, 'node_modules/react-native-worklets')
   await mkdir(packageRoot, { recursive: true })
   await writeFile(
     join(packageRoot, 'package.json'),
-    JSON.stringify({ name: 'react-native-worklets' })
+    JSON.stringify({ name: 'react-native-worklets', version: '0.10.1' })
   )
   await writeFile(
     join(packageRoot, 'plugin.js'),
@@ -76,7 +290,283 @@ describe('native prelude', () => {
   })
 })
 
+describe('native pure-function worklet imports', () => {
+  it('keeps live module versions isolated across a transitive HMR update', async () => {
+    const root = await createWorkletsProject(false)
+    const packageRoot = join(root, 'node_modules/pure-math')
+    await mkdir(packageRoot, { recursive: true })
+    await writeFile(
+      join(packageRoot, 'package.json'),
+      JSON.stringify({ type: 'module', exports: './index.js' })
+    )
+    const dependency = join(packageRoot, 'amount.ios.js')
+    await writeFile(dependency, 'export const amount = 2')
+    await writeFile(join(packageRoot, 'amount.android.js'), 'export const amount = 99')
+    await writeFile(
+      join(packageRoot, 'index.js'),
+      `
+import { amount } from './amount'
+const instance = globalThis.moduleInitializations = (globalThis.moduleInitializations || 0) + 1
+export default function calculate(value) { return value + amount }
+export function reads() { return instance }
+`
+    )
+    await writeFile(
+      join(root, 'entry.mjs'),
+      `
+import calculate, { reads } from 'pure-math'
+globalThis.calculate = calculate
+globalThis.reads = reads
+if (import.meta.hot) import.meta.hot.accept(() => {})
+`
+    )
+    const compiler = await import('@vxrn/compiler')
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true,
+    })
+    let resolveUpdate!: (value: any) => void
+    const updated = new Promise<any>((resolve) => {
+      resolveUpdate = resolve
+    })
+    const native = await createNativeDevEngine({
+      root,
+      port: 0,
+      platform: 'ios',
+      plugins: [
+        workletImportsPlugin({ 'pure-math': ['default', 'reads'] }),
+        {
+          name: 'worklet-import-fixture',
+          transform(_code, id) {
+            if (id.endsWith('/__virtual-native-entry.tsx')) return `import './entry.mjs'`
+          },
+        },
+      ],
+      onHmrUpdate: resolveUpdate,
+    })
+    try {
+      const initial = await native.getBundle()
+      const rn: any = { console, setTimeout, clearTimeout }
+      runInNewContext(initial.code, rn)
+      expect(rn.calculate(10)).toBe(12)
+      expect(rn.reads()).toBe(1)
+      const ui: any = createContext({})
+      const compiled = new Map<number, Function>()
+      const reconstruct = (worklet: any): Function => {
+        if (!worklet.__initData || !worklet.__workletHash)
+          throw new Error('remote function')
+        let fn = compiled.get(worklet.__workletHash)
+        if (!fn) {
+          fn = runInContext(`(${worklet.__initData.code})`, ui)
+          compiled.set(worklet.__workletHash, fn!)
+        }
+        const closure = Object.fromEntries(
+          Object.entries(worklet.__closure).map(([name, value]) => [
+            name,
+            typeof value === 'function' ? reconstruct(value) : value,
+          ])
+        )
+        return fn!.bind({ __closure: closure })
+      }
+      expect(() => reconstruct((value: number) => value + 2)).toThrow('remote function')
+      const old = reconstruct(rn.calculate)
+      const oldReads = reconstruct(rn.reads)
+      expect(old(10)).toBe(12)
+      expect(reconstruct(rn.calculate)(11)).toBe(13)
+      expect(oldReads()).toBe(1)
+      expect(rn.reads()).toBe(1)
+
+      const runtime = rn.__rolldown_runtime__
+      await native.engine.registerClient(runtime.clientId)
+      await writeFile(dependency, 'export const amount = 3')
+      const update = await updated
+      expect(update.type).toBe('hmr:update')
+      expect(runtime.applyHmrUpdate(update.code, update.changedIds, update.seq)).toBe(
+        true
+      )
+      expect(rn.calculate(10)).toBe(13)
+      const next = reconstruct(rn.calculate)
+      expect([old(10), next(10), old(10), next(10)]).toEqual([12, 13, 12, 13])
+      const nextReads = reconstruct(rn.reads)
+      expect([oldReads(), nextReads(), oldReads(), nextReads()]).toEqual([1, 2, 1, 2])
+      expect(ui.moduleInitializations).toBe(2)
+      expect(rn.reads()).toBe(2)
+
+      await writeFile(
+        join(root, 'production.mjs'),
+        `import calculate, { reads } from 'pure-math'; globalThis.calculate = calculate; globalThis.reads = reads`
+      )
+      const production = await buildNativeBundle({
+        root,
+        platform: 'android',
+        entryFile: 'production.mjs',
+        plugins: [workletImportsPlugin({ 'pure-math': ['default', 'reads'] })],
+      })
+      const productionRN: any = { console }
+      runInNewContext(production.code, productionRN)
+      expect(productionRN.calculate(10)).toBe(109)
+      expect(reconstruct(productionRN.calculate)(10)).toBe(109)
+      expect(reconstruct(productionRN.reads)()).toBe(3)
+      expect(productionRN.reads()).toBe(1)
+
+      const sharedPlugin = workletImportsPlugin({ 'pure-math': ['default', 'reads'] })
+      const parallel = await Promise.all(
+        (['ios', 'android'] as const).map(async (platform) => {
+          const output = await buildNativeBundle({
+            root,
+            platform,
+            entryFile: 'production.mjs',
+            plugins: [sharedPlugin],
+          })
+          const context: any = { console }
+          runInNewContext(output.code, context)
+          return context.calculate(10)
+        })
+      )
+      expect(parallel).toEqual([13, 109])
+    } finally {
+      await native.close()
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false,
+      })
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it.each([
+    [
+      'unselected',
+      'export default function value() { return 1 }; export const other = 2',
+      `import { other } from 'pure-math'; globalThis.value = other`,
+      /unselected export other/,
+    ],
+    [
+      'missing',
+      'export const other = 2',
+      `import value from 'pure-math'; globalThis.value = value`,
+      /default.*not exported|MISSING_EXPORT/,
+    ],
+    [
+      'builtin',
+      `import fs from 'node:fs'; export default function value() { return fs.readFileSync('x') }`,
+      `import value from 'pure-math'; globalThis.value = value`,
+      /runtime dependency node:fs/,
+    ],
+    [
+      'global',
+      'export default function value() { return process.pid }',
+      `import value from 'pure-math'; globalThis.value = value`,
+      /unsupported runtime globals: process/,
+    ],
+    [
+      'dynamic',
+      `export default function value() { return import('./other.js') }`,
+      `import value from 'pure-math'; globalThis.value = value`,
+      /dynamic imports are unsupported/,
+    ],
+  ] as const)(
+    'rejects %s through the native engine',
+    async (_name, source, entry, expected) => {
+      const root = await createWorkletsProject(false)
+      const packageRoot = join(root, 'node_modules/pure-math')
+      await mkdir(packageRoot, { recursive: true })
+      await writeFile(
+        join(packageRoot, 'package.json'),
+        JSON.stringify({ type: 'module', exports: './index.js' })
+      )
+      await writeFile(join(packageRoot, 'index.js'), source)
+      await writeFile(join(root, 'entry.mjs'), entry)
+      const compiler = await import('@vxrn/compiler')
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: true,
+        enableNativeWorklets: true,
+      })
+      const native = await createNativeDevEngine({
+        root,
+        port: 0,
+        platform: 'ios',
+        plugins: [
+          workletImportsPlugin({ 'pure-math': ['default'] }),
+          {
+            name: 'worklet-import-negative-fixture',
+            transform(_code, id) {
+              if (id.endsWith('/__virtual-native-entry.tsx'))
+                return `import './entry.mjs'`
+            },
+          },
+        ],
+      })
+      try {
+        await expect(native.getBundle()).rejects.toThrow(expected)
+      } finally {
+        await native.close()
+        compiler.configureVXRNCompilerPlugin({
+          enableReanimated: false,
+          enableNativeWorklets: false,
+        })
+        await rm(root, { recursive: true, force: true })
+      }
+    }
+  )
+})
+
 describe('native Rolldown HMR runtime', () => {
+  it.each([true, false])('keeps CommonJS default components callable through the native HMR wire path (Babel=%s)', async (babel) => {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-native-hmr-interop-'))
+    const entry = join(root, 'entry.mjs')
+    const packageRoot = join(root, 'node_modules/component')
+    await mkdir(packageRoot, { recursive: true })
+    await writeFile(
+      join(packageRoot, 'package.json'),
+      JSON.stringify({ main: './component(view).js' })
+    )
+    await writeFile(
+      join(packageRoot, 'component(view).js'),
+      babel
+        ? `Object.defineProperty(exports, '__esModule', { value: true }); exports.default = function Component() { return 42 }`
+        : `module.exports = function Component() { return 42 }`
+    )
+    const source = (version: number) => `
+import Component from 'component'
+globalThis.renderComponent = Component
+export const version = ${version}
+if (import.meta.hot) import.meta.hot.accept(() => {})
+`
+    await writeFile(entry, source(1))
+    let resolveUpdate!: (update: any) => void
+    const updateReceived = new Promise<any>((resolve) => { resolveUpdate = resolve })
+    const native = await createNativeDevEngine({
+      root,
+      port: 0,
+      platform: 'ios',
+      plugins: [{
+        name: 'native-hmr-fixture-entry',
+        transform(_code, id) {
+          if (id.endsWith('/__virtual-native-entry.tsx')) return `import './entry.mjs'`
+        },
+      }],
+      onHmrUpdate: resolveUpdate,
+    })
+    try {
+      const initial = await native.getBundle()
+      const context: any = { console, setTimeout, clearTimeout }
+      runInNewContext(initial.code, context)
+      expect(context.renderComponent()).toBe(42)
+      const runtime = context.__rolldown_runtime__
+      await native.engine.registerClient(runtime.clientId)
+      await writeFile(entry, source(2))
+      const update = await updateReceived
+      expect(update.type).toBe('hmr:update')
+      expect(update.clientId).toBe(runtime.clientId)
+      expect(runtime.applyHmrUpdate(update.code, update.changedIds, update.seq)).toBe(true)
+      expect(context.renderComponent()).toBe(42)
+    } finally {
+      await native.close()
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
   it(
     'registers a Rolldown 1.2 client and applies a self-accepted patch',
     { timeout: 30_000 },
@@ -493,6 +983,35 @@ describe('getHermesSWCIncludes', () => {
     expect(result.code).not.toContain('async function *')
   })
 
+  it('downlevels private fields, public class fields, and static blocks for Hermes', async () => {
+    const plugin = hermesCompatSWCPlugin(true)
+    if (typeof plugin.transform !== 'function') {
+      throw new Error('Hermes compatibility transform hook is not callable')
+    }
+
+    const result = await Reflect.apply(plugin.transform, undefined, [
+      `
+class TransformProbe {
+  #privateField = 1
+  publicField = 2
+  static {
+    TransformProbe.initialized = true
+  }
+
+  getSecret() {
+    return this.#privateField
+  }
+}
+`,
+      '/project/TransformProbe.ts',
+    ])
+
+    expect(result.code).not.toContain('#privateField')
+    expect(result.code).not.toMatch(/^\s*publicField\s*=/m)
+    expect(result.code).not.toContain('static {')
+    expect(result.code).toContain('this.publicField = 2')
+  })
+
   it('preserves per-iteration bindings used by lazy method getters', async () => {
     const plugin = hermesCompatSWCPlugin(true)
     if (typeof plugin.transform !== 'function') {
@@ -661,6 +1180,9 @@ describe('native required transform failures', () => {
     async (dev) => {
       const testRoot = await createWorkletsProject()
       const compiler = await import('@vxrn/compiler')
+      const spy = vi
+        .spyOn(compiler, 'transformWorklets')
+        .mockRejectedValue(new Error('NATIVE_TRANSFORM_NEGATIVE_CONTROL'))
       compiler.configureVXRNCompilerPlugin({ enableReanimated: true })
 
       try {
@@ -676,6 +1198,7 @@ describe('native required transform failures', () => {
           ])
         ).rejects.toThrow('NATIVE_TRANSFORM_NEGATIVE_CONTROL')
       } finally {
+        spy.mockRestore()
         compiler.configureVXRNCompilerPlugin({ enableReanimated: false })
         await rm(testRoot, { recursive: true, force: true })
       }
@@ -685,6 +1208,9 @@ describe('native required transform failures', () => {
   it('returns a dev build error and no output when the required compiler transform fails', async () => {
     const testRoot = await createWorkletsProject()
     const compiler = await import('@vxrn/compiler')
+    const spy = vi
+      .spyOn(compiler, 'transformWorklets')
+      .mockRejectedValue(new Error('NATIVE_TRANSFORM_NEGATIVE_CONTROL'))
     compiler.configureVXRNCompilerPlugin({ enableReanimated: true })
     let resolveOutput!: (output: unknown) => void
     const output = new Promise<unknown>((resolve) => {
@@ -706,6 +1232,7 @@ describe('native required transform failures', () => {
       expect(result).toBeInstanceOf(Error)
       expect(String(result)).toContain('NATIVE_TRANSFORM_NEGATIVE_CONTROL')
     } finally {
+      spy.mockRestore()
       await engine.close()
       compiler.configureVXRNCompilerPlugin({ enableReanimated: false })
       await rm(testRoot, { recursive: true, force: true })
@@ -715,6 +1242,9 @@ describe('native required transform failures', () => {
   it('emits no production bundle when the required compiler transform fails', async () => {
     const testRoot = await createWorkletsProject()
     const compiler = await import('@vxrn/compiler')
+    const spy = vi
+      .spyOn(compiler, 'transformWorklets')
+      .mockRejectedValue(new Error('NATIVE_TRANSFORM_NEGATIVE_CONTROL'))
     compiler.configureVXRNCompilerPlugin({ enableReanimated: true })
 
     try {
@@ -726,6 +1256,7 @@ describe('native required transform failures', () => {
         })
       ).rejects.toThrow('NATIVE_TRANSFORM_NEGATIVE_CONTROL')
     } finally {
+      spy.mockRestore()
       compiler.configureVXRNCompilerPlugin({ enableReanimated: false })
       await rm(testRoot, { recursive: true, force: true })
     }
@@ -775,6 +1306,292 @@ describe('native required transform failures', () => {
       await rm(testRoot, { recursive: true, force: true })
     }
   })
+
+  it('composes source maps across React Compiler, Fast Refresh, and module wrapper back to original source lines', async () => {
+    const { TraceMap, originalPositionFor } = await import('@jridgewell/trace-mapping')
+    const compiler = await import('@vxrn/compiler')
+    compiler.configureVXRNCompilerPlugin({ enableCompiler: true })
+
+    try {
+      const plugin = vxrnCompilerPlugin('ios', true, '/project', true)
+      if (typeof plugin.transform !== 'function') {
+        throw new Error('transform hook not callable')
+      }
+
+      const inputCode = `import { useState } from 'react'
+
+export function Counter() {
+  const [count, setCount] = useState(0)
+  return <button onClick={() => setCount(count + 1)}>{count}</button>
+}
+`
+      const id = '/project/Counter.tsx'
+      const result = await Reflect.apply(plugin.transform, undefined, [inputCode, id])
+
+      expect(result).toBeDefined()
+      expect(result.map).toBeDefined()
+
+      const tracer = new TraceMap(result.map)
+      const lines = result.code.split('\n')
+      const counterLineIndex = lines.findIndex((l: string) =>
+        l.includes('function Counter')
+      )
+      expect(counterLineIndex).toBeGreaterThan(0)
+
+      const pos = originalPositionFor(tracer, {
+        line: counterLineIndex + 1,
+        column: 16,
+      })
+
+      expect(pos.source).toBe(id)
+      expect(pos.line).toBe(3)
+    } finally {
+      compiler.configureVXRNCompilerPlugin({ enableCompiler: false })
+    }
+  })
+
+  it('composes source maps accurately across mixed path (React Compiler + Babel + Fast Refresh + module wrapper)', async () => {
+    const { TraceMap, originalPositionFor } = await import('@jridgewell/trace-mapping')
+    const compiler = await import('@vxrn/compiler')
+    const origEnv = process.env.VXRN_USE_BABEL_FOR_GENERATORS
+    process.env.VXRN_USE_BABEL_FOR_GENERATORS = '1'
+    compiler.configureVXRNCompilerPlugin({
+      enableCompiler: true,
+      enableReanimated: false,
+    })
+
+    try {
+      const plugin = vxrnCompilerPlugin('ios', true, '/project', true)
+      if (typeof plugin.transform !== 'function') {
+        throw new Error('transform hook not callable')
+      }
+
+      const inputCode = `export function Counter() { return <View />; }
+
+
+
+
+
+
+
+export async function* probe() { throw new Error("MARKER"); }
+`
+      const id = '/project/Counter.tsx'
+      const result = await Reflect.apply(plugin.transform, undefined, [inputCode, id])
+
+      expect(result).toBeDefined()
+      expect(result.map).toBeDefined()
+      // Assert that Babel's generator downleveling actually executed
+      expect(
+        result.code.includes('_wrapAsyncGenerator') ||
+          result.code.includes('regeneratorRuntime')
+      ).toBe(true)
+
+      const tracer = new TraceMap(result.map)
+      const lines = result.code.split('\n')
+      const markerLineIndex = lines.findIndex((l: string) => l.includes('MARKER'))
+      expect(markerLineIndex).toBeGreaterThan(0)
+      const markerCol = lines[markerLineIndex].indexOf('throw')
+
+      const pos = originalPositionFor(tracer, {
+        line: markerLineIndex + 1,
+        column: markerCol,
+      })
+
+      expect(pos.source).toBe(id)
+      expect(pos.line).toBe(9)
+      expect(pos.column).toBe(33)
+
+      // Negative control: verify that remapping through compilerOut.map a second time
+      // (the prior double-composition bug) breaks the trace and returns null source/line.
+      const compilerOut = await compiler.transformOxcReactCompiler(
+        id,
+        inputCode,
+        '19',
+        true
+      )
+      const remapping = (await import('@jridgewell/remapping')).default
+      const doubleComposedMap = remapping(
+        [result.map as any, compilerOut.map as any],
+        () => null
+      )
+      const badTracer = new TraceMap(doubleComposedMap as any)
+      const badPos = originalPositionFor(badTracer, {
+        line: markerLineIndex + 1,
+        column: markerCol,
+      })
+      expect(badPos.source).toBeNull()
+      expect(badPos.line).toBeNull()
+    } finally {
+      compiler.configureVXRNCompilerPlugin({ enableCompiler: false })
+      if (origEnv !== undefined) {
+        process.env.VXRN_USE_BABEL_FOR_GENERATORS = origEnv
+      } else {
+        delete process.env.VXRN_USE_BABEL_FOR_GENERATORS
+      }
+    }
+  })
+
+  it('transforms worklets via native Rust/Wasm SWC with zero Babel execution and accurate sourcemaps', async () => {
+    const { TraceMap, originalPositionFor } = await import('@jridgewell/trace-mapping')
+    const compiler = await import('@vxrn/compiler')
+    const { vi } = await import('vitest')
+    const babelSpy = vi.spyOn(compiler, 'transformBabel')
+
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true,
+      enableCompiler: false,
+    })
+
+    try {
+      const projectRoot = process.cwd()
+      const plugin = vxrnCompilerPlugin('ios', true, projectRoot, true)
+      if (typeof plugin.transform !== 'function') {
+        throw new Error('transform hook not callable')
+      }
+
+      const inputCode = `import { useAnimatedStyle } from 'react-native-reanimated'
+
+export function Box() {
+  const animatedStyle = useAnimatedStyle(() => {
+    return { opacity: 1 }
+  })
+  return <div style={animatedStyle} />
+}
+`
+      const id = join(projectRoot, 'Box.tsx')
+      const result = await Reflect.apply(plugin.transform, undefined, [inputCode, id])
+
+      expect(result).toBeDefined()
+      expect(result.code).toContain('__workletHash')
+      expect(result.code).toContain('__closure')
+      // Zero Babel calls!
+      expect(babelSpy).not.toHaveBeenCalled()
+
+      // Source map tracing
+      expect(result.map).toBeDefined()
+      const tracer = new TraceMap(result.map)
+      const lines = result.code.split('\n')
+      const boxLineIndex = lines.findIndex((l: string) =>
+        l.includes('export function Box')
+      )
+      expect(boxLineIndex).toBeGreaterThan(0)
+
+      const pos = originalPositionFor(tracer, {
+        line: boxLineIndex + 1,
+        column: 16,
+      })
+
+      expect(pos.source).toBe(id)
+      expect(pos.line).toBe(3)
+    } finally {
+      babelSpy.mockRestore()
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false,
+      })
+    }
+  })
+
+  it('retains the existing Babel backend by default when enableNativeWorklets is false for auto-detected Reanimated and ordinary configured worklets plugin', async () => {
+    const compiler = await import('@vxrn/compiler')
+    const { vi } = await import('vitest')
+    const babelSpy = vi.spyOn(compiler, 'transformBabel').mockResolvedValue({
+      code: '/* babel transformed */',
+    } as any)
+    const workletSpy = vi.spyOn(compiler, 'transformWorklets')
+
+    // enableReanimated is auto-detected, but enableNativeWorklets is NOT explicitly enabled
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: false,
+    })
+
+    const getBabelOptionsSpy = vi.spyOn(compiler, 'getBabelOptions').mockReturnValue({
+      plugins: ['react-native-reanimated/plugin'],
+    } as any)
+
+    try {
+      const projectRoot = process.cwd()
+      const plugin = vxrnCompilerPlugin('ios', true, projectRoot, false)
+      if (typeof plugin.transform !== 'function') {
+        throw new Error('transform hook not callable')
+      }
+
+      const inputCode = `export function fn() { 'worklet'; return 1 }`
+      const id = join(projectRoot, 'DefaultWorklet.tsx')
+      const result = await Reflect.apply(plugin.transform, undefined, [inputCode, id])
+
+      expect(result).toBeDefined()
+      // Retained existing Babel backend: Babel was called with the plugin
+      expect(babelSpy).toHaveBeenCalledWith(
+        id,
+        inputCode,
+        expect.objectContaining({
+          plugins: expect.arrayContaining(['react-native-reanimated/plugin']),
+        })
+      )
+      // Native SWC was NOT called
+      expect(workletSpy).not.toHaveBeenCalled()
+    } finally {
+      babelSpy.mockRestore()
+      workletSpy.mockRestore()
+      getBabelOptionsSpy.mockRestore()
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false,
+      })
+    }
+  })
+
+  it('intercepts tuple worklet plugins with options, executes native SWC with options, and skips Babel when enableNativeWorklets is true', async () => {
+    const compiler = await import('@vxrn/compiler')
+    const { vi } = await import('vitest')
+    const babelSpy = vi.spyOn(compiler, 'transformBabel')
+    const workletSpy = vi.spyOn(compiler, 'transformWorklets')
+
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true,
+    })
+
+    const getBabelOptionsSpy = vi.spyOn(compiler, 'getBabelOptions').mockReturnValue({
+      plugins: [['react-native-reanimated/plugin', { globals: ['customGlobal'] }]],
+    } as any)
+
+    try {
+      const projectRoot = process.cwd()
+      const plugin = vxrnCompilerPlugin('ios', true, projectRoot, false)
+      if (typeof plugin.transform !== 'function') {
+        throw new Error('transform hook not callable')
+      }
+
+      const inputCode = `export function fn() { 'worklet'; return customGlobal * 2 }`
+      const id = join(projectRoot, 'TupleWorklet.tsx')
+      const result = await Reflect.apply(plugin.transform, undefined, [inputCode, id])
+
+      expect(result).toBeDefined()
+      expect(result.code).toContain('__workletHash')
+      // Forwarded options
+      expect(workletSpy).toHaveBeenCalledWith(
+        id,
+        expect.any(String),
+        false,
+        expect.objectContaining({ globals: ['customGlobal'], projectRoot })
+      )
+      // Babel was completely skipped
+      expect(babelSpy).not.toHaveBeenCalled()
+    } finally {
+      babelSpy.mockRestore()
+      workletSpy.mockRestore()
+      getBabelOptionsSpy.mockRestore()
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false,
+      })
+    }
+  })
 })
 
 describe('native production assets', () => {
@@ -1016,3 +1833,60 @@ globalThis.__vxrnConditionalExportProbe = helper()
     }
   })
 })
+
+describe('native Flow sources', () => {
+  it.each(['', `/* ${'license text '.repeat(150)} */\n`])('strips third-party Flow following a license header (%#)', async (license) => {
+    const testRoot = await mkdtemp(join(tmpdir(), 'vxrn-native-flow-'))
+    // mirrors @react-native-masked-view/masked-view: a Flow `.js` component
+    // outside the react-native / @react-native scopes, which is what reached
+    // rolldown unstripped when its patch was skipped.
+    const packageRoot = join(testRoot, 'node_modules/@flowy-scope/flowy-lib')
+    await mkdir(packageRoot, { recursive: true })
+    await writeFile(
+      join(packageRoot, 'package.json'),
+      JSON.stringify({ name: '@flowy-scope/flowy-lib', main: './js/Flowy.js' })
+    )
+    await mkdir(join(packageRoot, 'js'), { recursive: true })
+    await writeFile(
+      join(packageRoot, 'js/Flowy.js'),
+      `${license}/**
+ * @flow
+ * @format
+ */
+
+type FlowyProps = {|
+  +value: number,
+|}
+
+export default class Flowy {
+  _seen: boolean = false
+
+  measure(props: FlowyProps): number {
+    const { value, ...rest }: FlowyProps = props
+    this._seen = true
+    return ((value: any): number) + Object.keys(rest).length
+  }
+}
+`
+    )
+    await writeFile(
+      join(testRoot, 'entry.js'),
+      `import Flowy from '@flowy-scope/flowy-lib'
+globalThis.__vxrnFlowProbe = new Flowy().measure({ value: 41 }) + 1
+`
+    )
+
+    try {
+      const result = await buildNativeBundle({
+        root: testRoot,
+        platform: 'ios',
+        entryFile: 'entry.js',
+      })
+      const context = { clearTimeout, console, process: { env: {} }, setTimeout }
+      runInNewContext(result.code, context)
+      expect(Reflect.get(context, '__vxrnFlowProbe')).toBe(42)
+    } finally {
+      await rm(testRoot, { recursive: true, force: true })
+    }
+  })
+})