vxrn 2.0.0-beta.99.1 → 2.6.0

package/src/utils/createNativeDevEngine.test.ts

@@ -1,5 +1,5 @@
 import { existsSync, realpathSync } from 'node:fs'
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { createContext, runInContext, runInNewContext } from 'node:vm'
@@ -28,6 +28,108 @@ import {
   type NativePluginContext,
 } from './createNativeDevEngine'
 
+it.each(['edit', 'create', 'delete'] as const)(
+  'loads routes and applies %s HMR through symlinked node_modules',
+  async (change) => {
+    const workspace = await mkdtemp(join(tmpdir(), 'vxrn-native-route-symlink-'))
+    const root = join(workspace, 'packages/shell')
+    await mkdir(join(workspace, 'node_modules'), { recursive: true })
+    await mkdir(join(root, 'app'), { recursive: true })
+    await symlink('../../node_modules', join(root, 'node_modules'))
+    await writeFile(join(root, 'app/_layout.tsx'), "export default 'layout'")
+    await writeFile(
+      join(root, 'app/index.tsx'),
+      "export default 'index'; globalThis.routeEdit = 'index'; if (import.meta.hot) import.meta.hot.accept()"
+    )
+    if (change === 'delete') {
+      await writeFile(join(root, 'app/[id].tsx'), "export default 'dynamic'")
+    }
+    let resolveUpdate!: (update: any) => void
+    const nextUpdate = () =>
+      new Promise<any>((resolve) => {
+        resolveUpdate = resolve
+      })
+    let native: Awaited<ReturnType<typeof createNativeDevEngine>> | undefined
+    try {
+      native = await createNativeDevEngine({
+        root,
+        platform: 'ios',
+        port: 0,
+        plugins: [
+          {
+            name: 'route-registry-fixture',
+            transform(code, id) {
+              if (id.endsWith('/__virtual-native-entry.tsx')) {
+                // retain the generated registry import and its actual HMR acceptance.
+                const registryImport = code.match(/import \{ routes \} from [^;]+;/)![0]
+                const accept = code.slice(code.lastIndexOf('if (import.meta.hot)'))
+                return `${registryImport}
+globalThis.routeMap = routes
+${accept}`
+              }
+            },
+          },
+        ],
+        onHmrUpdate(update) {
+          resolveUpdate(update)
+        },
+      })
+      const context: any = {
+        console: { ...console, error() {} },
+        setTimeout,
+        clearTimeout,
+        __VXRN_UPDATE_NATIVE_ROUTES__(routes: any) {
+          context.routeMap = routes
+        },
+      }
+      runInNewContext((await native.getBundle()).code, context)
+      expect(Object.keys(context.routeMap).sort()).toEqual(
+        (change === 'delete'
+          ? ['/app/_layout.tsx', '/app/index.tsx', '/app/[id].tsx']
+          : ['/app/_layout.tsx', '/app/index.tsx']
+        ).sort()
+      )
+      expect((await context.routeMap['/app/index.tsx']()).default).toBe('index')
+      const runtime = context.__rolldown_runtime__
+      await native.engine.registerClient(runtime.clientId)
+      const apply = async (pending: Promise<any>) => {
+        const update = await pending
+        expect(update.type).toBe('hmr:update')
+        expect(runtime.applyHmrUpdate(update.code, update.changedIds, update.seq)).toBe(
+          true
+        )
+        await native!.engine.ensureCurrentBuildFinish()
+      }
+      const pending = nextUpdate()
+      if (change === 'edit') {
+        expect(context.routeEdit).toBe('index')
+        await writeFile(
+          join(root, 'app/index.tsx'),
+          "export default 'edited'; globalThis.routeEdit = 'edited'; if (import.meta.hot) import.meta.hot.accept()"
+        )
+        await apply(pending)
+        expect(context.routeEdit).toBe('edited')
+      } else if (change === 'create') {
+        expect(context.routeMap['/app/[id].tsx']).toBeUndefined()
+        await writeFile(join(root, 'app/[id].tsx'), "export default 'dynamic'")
+        await apply(pending)
+        expect((await context.routeMap['/app/[id].tsx']()).default).toBe('dynamic')
+      } else {
+        expect((await context.routeMap['/app/[id].tsx']()).default).toBe('dynamic')
+        await rm(join(root, 'app/[id].tsx'))
+        await apply(pending)
+        expect(Object.keys(context.routeMap).sort()).toEqual([
+          '/app/_layout.tsx',
+          '/app/index.tsx',
+        ])
+      }
+    } finally {
+      await native?.close()
+      await rm(workspace, { recursive: true, force: true })
+    }
+  }
+)
+
 describe.each(['ios', 'android'] as const)('native plugin adapters on %s', (platform) => {
   it.each(['dev', 'build'] as const)(
     'binds configured plugins to the %s bundle',
@@ -120,6 +222,79 @@ describe.each(['ios', 'android'] as const)('native plugin adapters on %s', (plat
   )
 })
 
+it.each(['react-native-nitro-modules', 'react-native-worklets'])(
+  'shares the app native singleton for %s across nested installs',
+  async (packageName) => {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-native-singleton-'))
+    const nested = join(root, 'node_modules/transitive')
+    for (const [parent, label] of [
+      [root, 'app'],
+      [nested, 'nested'],
+    ]) {
+      const directory = join(parent, 'node_modules', packageName)
+      await mkdir(directory, { recursive: true })
+      await writeFile(
+        join(directory, 'package.json'),
+        JSON.stringify({
+          name: packageName,
+          type: 'module',
+          exports: {
+            '.': { 'react-native': './native.js', default: './web.js' },
+            './shared': './native.js',
+          },
+        })
+      )
+      await writeFile(
+        join(directory, 'native.js'),
+        `export const singleton = { owner: '${label}' }`
+      )
+      await writeFile(
+        join(directory, 'web.js'),
+        `throw new Error('web export reached native')`
+      )
+    }
+    await writeFile(join(root, 'package.json'), '{}')
+    await writeFile(
+      join(nested, 'package.json'),
+      JSON.stringify({ name: 'transitive', type: 'module', main: 'index.js' })
+    )
+    await writeFile(
+      join(nested, 'index.js'),
+      `export { singleton } from '${packageName}/shared'`
+    )
+    await writeFile(
+      join(root, 'entry.js'),
+      `
+      import { singleton } from '${packageName}'
+      import { singleton as nested } from 'transitive'
+      globalThis.singletonResult = [singleton.owner, singleton === nested]
+    `
+    )
+    let native: Awaited<ReturnType<typeof createNativeDevEngine>> | undefined
+    try {
+      native = await createNativeDevEngine({
+        root,
+        platform: 'ios',
+        port: 0,
+        plugins: [
+          {
+            name: 'singleton-entry',
+            transform(_code, id) {
+              if (id.endsWith('/__virtual-native-entry.tsx')) return "import './entry.js'"
+            },
+          },
+        ],
+      })
+      const context = { console, setTimeout, clearTimeout }
+      runInNewContext((await native.getBundle()).code, context)
+      expect(Reflect.get(context, 'singletonResult')).toEqual(['app', true])
+    } finally {
+      await native?.close()
+      await rm(root, { recursive: true, force: true })
+    }
+  }
+)
+
 const nativeTransformProbe = `
 export const transformProbe = () => {
   'worklet'
@@ -672,6 +847,56 @@ if (import.meta.hot) import.meta.hot.accept(() => {})
 })
 
 describe('native Rolldown HMR runtime', () => {
+  it('opens the HMR socket on the origin the device loaded the bundle from', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-native-hmr-origin-'))
+    // an emulator behind `adb reverse tcp:8081 tcp:<port>` loads the bundle from
+    // localhost:8081, where the server's own port is unreachable
+    await writeFile(
+      join(root, 'WebSocket.js'),
+      `export default class WebSocket {
+  constructor(url) { globalThis.hmrSocketUrl = url }
+  addEventListener() {}
+}`
+    )
+    await writeFile(
+      join(root, 'getDevServer.js'),
+      `export default function getDevServer() {
+  return { url: 'http://localhost:8081/', bundleLoadedFromServer: true }
+}`
+    )
+    await writeFile(
+      join(root, 'entry.mjs'),
+      `import WebSocket from './WebSocket.js'
+import getDevServer from './getDevServer.js'
+globalThis.hostModules = [WebSocket, getDevServer]`
+    )
+    const native = await createNativeDevEngine({
+      root,
+      port: 52278,
+      platform: 'android',
+      plugins: [
+        {
+          name: 'native-hmr-origin-entry',
+          transform(_code, id) {
+            if (id.endsWith('/__virtual-native-entry.tsx')) return `import './entry.mjs'`
+          },
+        },
+      ],
+    })
+    try {
+      const context: any = { console, setTimeout, clearTimeout }
+      runInNewContext((await native.getBundle()).code, context)
+      expect(context.hmrSocketUrl).toBe(
+        `ws://localhost:8081/hot?platform=android&clientId=${encodeURIComponent(
+          context.__rolldown_runtime__.clientId
+        )}`
+      )
+    } finally {
+      await native.close()
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
   it.each([true, false])(
     'keeps CommonJS default components callable through the native HMR wire path (Babel=%s)',
     async (babel) => {
@@ -1223,6 +1448,82 @@ describe('getHermesSWCIncludes', () => {
     expect(result.code).not.toContain('async function *')
   })
 
+  it.each([true, false])(
+    'lowers complete class hierarchies for Hermes (dev=%s)',
+    async (dev) => {
+      const plugin = hermesCompatSWCPlugin(dev)
+      const result = await Reflect.apply(plugin.transform as Function, undefined, [
+        `class Base { value = 2; getValue() { return this.value } }
+       class Derived extends Base { extra = 3; getValue() { return super.getValue() + this.extra } }
+       globalThis.__classProbe = new Derived().getValue()`,
+        '/project/classes.ts',
+      ])
+      expect(result.code).not.toMatch(/\bclass\s+(?:Base|Derived|extends)/)
+      const context: any = {}
+      runInNewContext(result.code, context)
+      expect(context.__classProbe).toBe(5)
+    }
+  )
+
+  it('lowers constructor block bindings before production name mangling', async () => {
+    const plugin = hermesCompatSWCPlugin(false)
+    const result = await Reflect.apply(plugin.transform as Function, undefined, [
+      `class Client {
+         constructor(options) {
+           if (options.dsn) { let url = options.url; this.url = url }
+           this.callbacks = []
+           for (let index = 0; index < 2; index++) this.callbacks.push(() => index)
+         }
+       }
+       globalThis.__constructorScope = new Client({dsn: true, url: 3})`,
+      '/project/constructor-scope.js',
+    ])
+    expect(result.code).not.toMatch(/\b(?:let|const)\s/)
+    const context: any = {}
+    runInNewContext(result.code, context)
+    expect(context.__constructorScope.url).toBe(3)
+    const values = Array.from(context.__constructorScope.callbacks, (callback: any) =>
+      callback()
+    )
+    expect(values).toEqual([0, 1])
+  })
+
+  it.each([true, false])(
+    'preserves class-free parameter shadowing for Hermes (dev=%s)',
+    async (dev) => {
+      const plugin = hermesCompatSWCPlugin(dev)
+      const result = await Reflect.apply(plugin.transform as Function, undefined, [
+        `function createStore(config) {
+         if (!globalThis.factory) {
+           const config = { install() { globalThis.factory = value => value.id } }
+           config.install()
+         }
+         return globalThis.factory(config)
+       }
+       globalThis.__storeId = createStore({id: 'device'})`,
+        '/project/class-free-storage.js',
+      ])
+      expect(result.code).not.toMatch(/\b(?:let|const)\s/)
+      const context: any = {}
+      runInNewContext(result.code, context)
+      expect(context.__storeId).toBe('device')
+    }
+  )
+
+  it('lowers classes in large prebuilt modules', async () => {
+    const plugin = hermesCompatSWCPlugin(false)
+    const result = await Reflect.apply(plugin.transform as Function, undefined, [
+      '/*' +
+        ' '.repeat(500_000) +
+        '*/ class Large { value = 7 } globalThis.__largeClass = new Large().value',
+      '/project/prebuilt.js',
+    ])
+    expect(result.code).not.toMatch(/\bclass\s+Large/)
+    const context: any = {}
+    runInNewContext(result.code, context)
+    expect(context.__largeClass).toBe(7)
+  })
+
   it('downlevels private fields, public class fields, and static blocks for Hermes', async () => {
     const plugin = hermesCompatSWCPlugin(true)
     if (typeof plugin.transform !== 'function') {
@@ -1423,7 +1724,11 @@ describe('native required transform failures', () => {
       const spy = vi
         .spyOn(compiler, 'transformWorklets')
         .mockRejectedValue(new Error('NATIVE_TRANSFORM_NEGATIVE_CONTROL'))
-      compiler.configureVXRNCompilerPlugin({ enableReanimated: true })
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: true,
+        enableNativeWorklets: true,
+      })
+      expect(compiler.isNativeWorkletsEnabled()).toBe(true)
 
       try {
         const plugin = vxrnCompilerPlugin('ios', dev, testRoot)
@@ -1439,7 +1744,10 @@ describe('native required transform failures', () => {
         ).rejects.toThrow('NATIVE_TRANSFORM_NEGATIVE_CONTROL')
       } finally {
         spy.mockRestore()
-        compiler.configureVXRNCompilerPlugin({ enableReanimated: false })
+        compiler.configureVXRNCompilerPlugin({
+          enableReanimated: false,
+          enableNativeWorklets: false,
+        })
         await rm(testRoot, { recursive: true, force: true })
       }
     }
@@ -1451,7 +1759,11 @@ describe('native required transform failures', () => {
     const spy = vi
       .spyOn(compiler, 'transformWorklets')
       .mockRejectedValue(new Error('NATIVE_TRANSFORM_NEGATIVE_CONTROL'))
-    compiler.configureVXRNCompilerPlugin({ enableReanimated: true })
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true,
+    })
+    expect(compiler.isNativeWorkletsEnabled()).toBe(true)
     let resolveOutput!: (output: unknown) => void
     const output = new Promise<unknown>((resolve) => {
       resolveOutput = resolve
@@ -1474,7 +1786,10 @@ describe('native required transform failures', () => {
     } finally {
       spy.mockRestore()
       await engine.close()
-      compiler.configureVXRNCompilerPlugin({ enableReanimated: false })
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false,
+      })
       await rm(testRoot, { recursive: true, force: true })
     }
   })
@@ -1485,7 +1800,11 @@ describe('native required transform failures', () => {
     const spy = vi
       .spyOn(compiler, 'transformWorklets')
       .mockRejectedValue(new Error('NATIVE_TRANSFORM_NEGATIVE_CONTROL'))
-    compiler.configureVXRNCompilerPlugin({ enableReanimated: true })
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true,
+    })
+    expect(compiler.isNativeWorkletsEnabled()).toBe(true)
 
     try {
       await expect(
@@ -1497,7 +1816,10 @@ describe('native required transform failures', () => {
       ).rejects.toThrow('NATIVE_TRANSFORM_NEGATIVE_CONTROL')
     } finally {
       spy.mockRestore()
-      compiler.configureVXRNCompilerPlugin({ enableReanimated: false })
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false,
+      })
       await rm(testRoot, { recursive: true, force: true })
     }
   })
@@ -1519,7 +1841,11 @@ describe('native required transform failures', () => {
   it('returns maps for every required production transform', async () => {
     const testRoot = await createWorkletsProject(false)
     const compiler = await import('@vxrn/compiler')
-    compiler.configureVXRNCompilerPlugin({ enableReanimated: true })
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true,
+    })
+    expect(compiler.isNativeWorkletsEnabled()).toBe(true)
 
     try {
       const compilerPlugin = vxrnCompilerPlugin('ios', false, testRoot, true)
@@ -1542,7 +1868,10 @@ describe('native required transform failures', () => {
       ])
       expect(hermesResult.map).toBeTruthy()
     } finally {
-      compiler.configureVXRNCompilerPlugin({ enableReanimated: false })
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false,
+      })
       await rm(testRoot, { recursive: true, force: true })
     }
   })
@@ -1672,7 +2001,7 @@ export async function* probe() { throw new Error("MARKER"); }
     }
   })
 
-  it('transforms worklets via native Rust/Wasm SWC with zero Babel execution and accurate sourcemaps', async () => {
+  it('transforms worklets via One OXC 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')
@@ -1734,7 +2063,7 @@ export function Box() {
     }
   })
 
-  it('retains the existing Babel backend by default when enableNativeWorklets is false for auto-detected Reanimated and ordinary configured worklets plugin', async () => {
+  it('respects an explicitly configured Babel plugin when One worklet compilation is disabled', async () => {
     const compiler = await import('@vxrn/compiler')
     const { vi } = await import('vitest')
     const babelSpy = vi.spyOn(compiler, 'transformBabel').mockResolvedValue({
@@ -1742,7 +2071,7 @@ export function Box() {
     } as any)
     const workletSpy = vi.spyOn(compiler, 'transformWorklets')
 
-    // enableReanimated is auto-detected, but enableNativeWorklets is NOT explicitly enabled
+    // this tests explicit Babel configuration, not automatic backend selection.
     compiler.configureVXRNCompilerPlugin({
       enableReanimated: true,
       enableNativeWorklets: false,
@@ -1764,7 +2093,7 @@ export function Box() {
       const result = await Reflect.apply(plugin.transform, undefined, [inputCode, id])
 
       expect(result).toBeDefined()
-      // Retained existing Babel backend: Babel was called with the plugin
+      // the caller explicitly supplied this Babel plugin.
       expect(babelSpy).toHaveBeenCalledWith(
         id,
         inputCode,
@@ -1772,7 +2101,7 @@ export function Box() {
           plugins: expect.arrayContaining(['react-native-reanimated/plugin']),
         })
       )
-      // Native SWC was NOT called
+      // One compilation was disabled by the caller.
       expect(workletSpy).not.toHaveBeenCalled()
     } finally {
       babelSpy.mockRestore()
@@ -1785,7 +2114,7 @@ export function Box() {
     }
   })
 
-  it('intercepts tuple worklet plugins with options, executes native SWC with options, and skips Babel when enableNativeWorklets is true', async () => {
+  it('intercepts tuple worklet plugins with options, executes One OXC 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')
@@ -1872,8 +2201,14 @@ globalThis.minifyProbe = describeHeader()`
   }
 
   function runFixture(code: string) {
-    const context: Record<string, unknown> = { console }
-    runInNewContext(code, context)
+    const context = createContext({ console })
+    runInContext(code, context)
+    expect(
+      runInContext(
+        'Object.getOwnPropertyDescriptor(globalThis, "describeHeader")',
+        context
+      )
+    ).toBeUndefined()
     return Reflect.get(context, 'minifyProbe')
   }
 
@@ -1931,6 +2266,198 @@ globalThis.minifyProbe = describeHeader()`
 })
 
 describe('native production assets', () => {
+  it.each(['ios', 'android'] as const)(
+    'preserves CommonJS package main exports on %s',
+    async (platform) => {
+      const root = await mkdtemp(join(tmpdir(), 'vxrn-native-cjs-main-'))
+      try {
+        const directory = join(root, 'node_modules', 'native-punycode')
+        await mkdir(directory, { recursive: true })
+        await writeFile(
+          join(directory, 'package.json'),
+          JSON.stringify({
+            name: 'native-punycode',
+            main: './cjs.js',
+            module: './esm.mjs',
+          })
+        )
+        await writeFile(
+          join(directory, 'cjs.js'),
+          `module.exports = { ucs2: { decode: value => Array.from(value) } }`
+        )
+        await writeFile(
+          join(directory, 'esm.mjs'),
+          `export default { ucs2: { decode: value => Array.from(value) } }`
+        )
+        await writeFile(
+          join(root, 'entry.js'),
+          `import imported from 'native-punycode'
+         const required = require('native-punycode')
+         globalThis.decoded = [required.ucs2.decode('ab').join(','), imported.ucs2.decode('cd').join(',')]`
+        )
+        const result = await buildNativeBundle({ root, platform, entryFile: 'entry.js' })
+        const context = { console }
+        runInNewContext(result.code, context)
+        expect(Reflect.get(context, 'decoded')).toEqual(['a,b', 'c,d'])
+      } finally {
+        await rm(root, { recursive: true, force: true })
+      }
+    }
+  )
+
+  it('uses browser fallbacks and mappings after React Native overrides', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-native-browser-'))
+    try {
+      for (const [name, manifest] of Object.entries({
+        mapped: { main: './node.js', browser: { './node.js': './browser.js' } },
+        identity: {
+          main: './index.js',
+          browser: { './node': './browser' },
+          'react-native': { './node': './node' },
+        },
+        fallback: { main: './node.js', browser: './browser.js' },
+        conditional: { exports: { browser: './browser.js', default: './node.js' } },
+        both: {
+          exports: {
+            browser: './browser.js',
+            'react-native': './native.js',
+            default: './node.js',
+          },
+        },
+        native: {
+          main: './node.js',
+          browser: './browser.js',
+          'react-native': './native.js',
+        },
+      })) {
+        const directory = join(root, 'node_modules', name)
+        await mkdir(directory, { recursive: true })
+        await writeFile(
+          join(directory, 'package.json'),
+          JSON.stringify({ name, ...manifest })
+        )
+        await writeFile(join(directory, 'index.js'), `module.exports = require('./node')`)
+        for (const target of ['node', 'browser', 'native']) {
+          await writeFile(join(directory, `${target}.js`), `module.exports = '${target}'`)
+        }
+      }
+      await writeFile(
+        join(root, 'entry.js'),
+        `globalThis.targets = [require('mapped'), require('fallback'), require('conditional'), require('both'), require('native'), require('identity')]`
+      )
+      const result = await buildNativeBundle({
+        root,
+        platform: 'ios',
+        entryFile: 'entry.js',
+      })
+      const context = { console }
+      runInNewContext(result.code, context)
+      expect(Reflect.get(context, 'targets')).toEqual([
+        'browser',
+        'browser',
+        'browser',
+        'native',
+        'native',
+        'node',
+      ])
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it('uses runtime exports for declaration aliases while preserving source aliases', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-native-declaration-alias-'))
+    const packageRoot = join(root, 'node_modules/example')
+    await mkdir(packageRoot, { recursive: true })
+    await writeFile(
+      join(packageRoot, 'package.json'),
+      JSON.stringify({
+        name: 'example',
+        type: 'module',
+        exports: { './value': { import: './esm.js', require: './cjs.cjs' } },
+      })
+    )
+    await writeFile(join(packageRoot, 'esm.js'), 'export const value = 42')
+    await writeFile(join(packageRoot, 'cjs.cjs'), 'exports.value = 43')
+    await writeFile(join(root, 'runtime.js'), 'export const value = 44')
+    await writeFile(
+      join(root, 'declaration.d.ts'),
+      'export class Value { constructor(); }'
+    )
+    await writeFile(
+      join(root, 'tsconfig.json'),
+      JSON.stringify({
+        compilerOptions: {
+          paths: {
+            'example/value': ['./declaration.d.ts'],
+            '@runtime': ['./runtime.js'],
+          },
+        },
+      })
+    )
+    await writeFile(
+      join(root, 'entry.ts'),
+      `import { value } from 'example/value'; import { value as local } from '@runtime'; globalThis.aliasValues = [value, require('example/value').value, local]`
+    )
+    try {
+      const result = await buildNativeBundle({
+        root,
+        platform: 'ios',
+        entryFile: 'entry.ts',
+      })
+      const context = { console }
+      runInNewContext(result.code, context)
+      expect(Reflect.get(context, 'aliasValues')).toEqual([42, 43, 44])
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it.each(['legacy', 'exported'])(
+    'shares the %s React Native asset registry with library imports',
+    async (registryKind) => {
+      const root = await mkdtemp(join(tmpdir(), 'vxrn-native-registry-'))
+      const rnRoot = join(root, 'node_modules/react-native')
+      const registryRoot = join(root, 'node_modules/@react-native/assets-registry')
+      await mkdir(join(rnRoot, 'src'), { recursive: true })
+      await mkdir(registryRoot, { recursive: true })
+      await writeFile(
+        join(rnRoot, 'package.json'),
+        JSON.stringify({ name: 'react-native', main: 'index.js' })
+      )
+      await writeFile(join(rnRoot, 'index.js'), 'export {}')
+      await writeFile(
+        join(registryRoot, 'package.json'),
+        JSON.stringify({ name: '@react-native/assets-registry' })
+      )
+      const registryFile =
+        registryKind === 'exported'
+          ? join(rnRoot, 'src/asset-registry.js')
+          : join(registryRoot, 'registry.js')
+      await writeFile(
+        registryFile,
+        'const assets = []; export function registerAsset(asset) { return assets.push(asset) }; export function getAssetByID(id) { return assets[id - 1] }'
+      )
+      await writeFile(join(root, 'icon.png'), 'icon')
+      await writeFile(
+        join(root, 'entry.js'),
+        `import icon from './icon.png'; import { getAssetByID } from '@react-native/assets-registry/registry'; globalThis.registryAsset = getAssetByID(icon)`
+      )
+      try {
+        const result = await buildNativeBundle({
+          root,
+          entryFile: 'entry.js',
+          platform: 'ios',
+        })
+        const context = createContext({ console })
+        runInContext(result.code, context)
+        expect(context.registryAsset.name).toBe('icon')
+      } finally {
+        await rm(root, { recursive: true, force: true })
+      }
+    }
+  )
+
   it('registers scale siblings and keeps monorepo assets inside assetsDest', async () => {
     const testRoot = await mkdtemp(join(tmpdir(), 'vxrn-native-assets-'))
     const appRoot = join(testRoot, 'workspace/apps/native-app')
@@ -1942,6 +2469,8 @@ describe('native production assets', () => {
     await writeFile(join(appAssets, 'icon.png'), 'icon-1x')
     await writeFile(join(appAssets, 'icon@2x.png'), 'icon-2x')
     await writeFile(join(appAssets, 'icon@3x.png'), 'icon-3x')
+    const animationBytes = Buffer.from([0x50, 0x4b, 0xff, 0x00])
+    await writeFile(join(appAssets, 'animation.lottie'), animationBytes)
     await writeFile(join(packageAssets, 'back.png'), 'back-1x')
     await writeFile(join(packageAssets, 'back@2x.png'), 'back-2x')
     await writeFile(
@@ -1949,7 +2478,8 @@ describe('native production assets', () => {
       `
 import icon from './assets/icon.png'
 import back from '../../node_modules/example/assets/back.png'
-globalThis.__nativeAssetProbe = [icon, back]
+import animation from './assets/animation.lottie'
+globalThis.__nativeAssetProbe = [icon, back, animation]
 `
     )
 
@@ -2002,7 +2532,11 @@ globalThis.__nativeAssetProbe = [icon, back]
       expect(registered.map((asset) => [asset.name, asset.scales])).toEqual([
         ['icon', [1, 2, 3]],
         ['back', [1, 2]],
+        ['animation', [1]],
       ])
+      expect(await readFile(join(assetsDest, 'assets/assets/animation.lottie'))).toEqual(
+        animationBytes
+      )
       for (const file of ['icon.png', 'icon@2x.png', 'icon@3x.png']) {
         expect(existsSync(join(assetsDest, 'assets/assets', file))).toBe(true)
       }
@@ -2187,6 +2721,36 @@ globalThis.__vxrnConditionalExportProbe = helper()
 })
 
 describe('native Flow sources', () => {
+  it('strips typed arrows and class fields without a Flow pragma or type import', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-native-unmarked-flow-'))
+    await writeFile(
+      join(root, 'entry.js'),
+      `
+const URI = { isFileURI: (uri: string): boolean => uri.startsWith('file://') }
+class Response {
+  taskId: string;
+  lengthComputable: boolean = false;
+  onabort: (event: string) => void = () => {};
+  constructor(id: string) { this.taskId = id }
+}
+function filePath(path: string) { return new Response(path).taskId }
+globalThis.unmarkedFlowResult = URI.isFileURI(filePath('file://'))
+`
+    )
+    try {
+      const result = await buildNativeBundle({
+        root,
+        platform: 'ios',
+        entryFile: 'entry.js',
+      })
+      const context = { console }
+      runInNewContext(result.code, context)
+      expect(Reflect.get(context, 'unmarkedFlowResult')).toBe(true)
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
   it.each(['', `/* ${'license text '.repeat(150)} */\n`])(
     'strips third-party Flow following a license header (%#)',
     async (license) => {
@@ -2358,3 +2922,64 @@ describe('postProcessNativeBundle', () => {
     expect(out.split('\n')[4]).toBe('var b = 2;')
   })
 })
+
+describe('native package context identity', () => {
+  it.each(['@tamagui/web', '@tamagui/adapt'])(
+    'shares %s contexts with dependencies containing a second package copy',
+    async (packageName) => {
+      const root = realpathSync(await mkdtemp(join(tmpdir(), 'vxrn-native-context-')))
+      const consumer = join(root, 'node_modules/consumer')
+      const packages = [
+        join(root, `node_modules/${packageName}`),
+        join(consumer, `node_modules/${packageName}`),
+      ]
+      for (const packageRoot of packages) {
+        await mkdir(packageRoot, { recursive: true })
+        await writeFile(
+          join(packageRoot, 'package.json'),
+          JSON.stringify({
+            name: packageName,
+            type: 'module',
+            exports: {
+              '.': { 'react-native': './native.js', default: './web.js' },
+              './internal-runtime': './native.js',
+            },
+          })
+        )
+        await writeFile(
+          join(packageRoot, 'native.js'),
+          'export const context = { platform: "native" }'
+        )
+        await writeFile(
+          join(packageRoot, 'web.js'),
+          'export const context = { platform: "web" }'
+        )
+      }
+      await writeFile(
+        join(consumer, 'package.json'),
+        JSON.stringify({ name: 'consumer', main: 'index.js', type: 'module' })
+      )
+      await writeFile(
+        join(consumer, 'index.js'),
+        `export { context } from '${packageName}/internal-runtime'`
+      )
+      await writeFile(
+        join(root, 'entry.js'),
+        `import { context } from '${packageName}'; import { context as nested } from 'consumer'; globalThis.contextIdentity = [context === nested, context.platform]`
+      )
+      try {
+        const bundle = await buildNativeBundle({
+          root,
+          platform: 'ios',
+          entryFile: 'entry.js',
+          dev: false,
+        })
+        const context: any = {}
+        runInNewContext(bundle.code, context)
+        expect(context.contextIdentity).toEqual([true, 'native'])
+      } finally {
+        await rm(root, { recursive: true, force: true })
+      }
+    }
+  )
+})