vxrn 1.26.0 → 1.26.1

package/src/utils/createNativeDevEngine.test.ts

@@ -1,10 +1,12 @@
-import { existsSync } from 'node:fs'
+import { existsSync, realpathSync } from 'node:fs'
 import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { createContext, runInContext, runInNewContext } from 'node:vm'
-import { rolldown, type RolldownOutput } from 'rolldown'
+import { originalPositionFor, TraceMap } from '@jridgewell/trace-mapping'
+import { rolldown, type Plugin, type RolldownOutput } from 'rolldown'
 import { dev } from 'rolldown/experimental'
+import { normalizePath } from 'vite'
 import { describe, expect, it, vi } from 'vitest'
 import { getNativePrelude } from '../runtime/native-prelude'
 import { workletImportsPlugin } from '../plugins/workletImportsPlugin'
@@ -20,10 +22,104 @@ import {
   hmrClientNoopPlugin,
   nativeAnimatedGuardPlugin,
   normalizeNativeCommonJSInterop,
+  postProcessNativeBundle,
   vxrnCompilerPlugin,
   wrapNativeBundleModuleScope,
+  type NativePluginContext,
 } from './createNativeDevEngine'
 
+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',
+    async (mode) => {
+      const root = await mkdtemp(join(tmpdir(), 'vxrn-native-plugin-adapter-'))
+      await writeFile(
+        join(root, 'entry.js'),
+        `globalThis.nativePluginResult = [__GLOBAL_PLUGIN__, __DIRECT_PLUGIN__, 'plain-plugin']`
+      )
+      const factories = ['global', 'direct'].map((name) =>
+        vi.fn(
+          (context: NativePluginContext): Plugin => ({
+            name: `${name}-native`,
+            transform(code, id) {
+              if (id.endsWith('/entry.js')) {
+                return code.replace(
+                  `__${name.toUpperCase()}_PLUGIN__`,
+                  JSON.stringify({ name, ...context })
+                )
+              }
+            },
+          })
+        )
+      )
+      const plugins = factories.map(
+        (vxrnNative, index): Plugin => ({
+          name: `adapter-${index}`,
+          api: { vxrnNative },
+        })
+      )
+      const previousPlugins = globalThis.__vxrnAddNativePlugins
+      globalThis.__vxrnAddNativePlugins = [plugins[0]]
+      const configuredPlugins: Plugin[] = [
+        plugins[1],
+        {
+          name: 'plain-native-plugin',
+          transform(code, id) {
+            if (id.endsWith('/__virtual-native-entry.tsx')) return `import './entry.js'`
+            if (id.endsWith('/entry.js')) return code.replace('plain-plugin', 'plain')
+          },
+        },
+      ]
+      let native: Awaited<ReturnType<typeof createNativeDevEngine>> | undefined
+      try {
+        let code: string
+        if (mode === 'dev') {
+          native = await createNativeDevEngine({
+            root,
+            platform,
+            port: 0,
+            plugins: configuredPlugins,
+          })
+          code = (await native.getBundle()).code
+        } else {
+          code = (
+            await buildNativeBundle({
+              root,
+              platform,
+              entryFile: 'entry.js',
+              plugins: configuredPlugins,
+            })
+          ).code
+        }
+        const context = {
+          console,
+          setTimeout,
+          clearTimeout,
+          __GLOBAL_PLUGIN__: 'unadapted',
+          __DIRECT_PLUGIN__: 'unadapted',
+        }
+        runInNewContext(code, context)
+        expect(Reflect.get(context, 'nativePluginResult')).toEqual([
+          { name: 'global', root, platform, dev: mode === 'dev' },
+          { name: 'direct', root, platform, dev: mode === 'dev' },
+          'plain',
+        ])
+        for (const factory of factories) {
+          expect(factory).toHaveBeenCalledExactlyOnceWith({
+            root,
+            platform,
+            dev: mode === 'dev',
+          })
+        }
+      } finally {
+        await native?.close()
+        globalThis.__vxrnAddNativePlugins = previousPlugins
+        await rm(root, { recursive: true, force: true })
+      }
+    }
+  )
+})
+
 const nativeTransformProbe = `
 export const transformProbe = () => {
   'worklet'
@@ -128,120 +224,155 @@ globalThis.result = (function(parentArgument) {
   }
 )
 
-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 },
+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,
         })
-        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
+        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 })
         }
-        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-'))
@@ -396,12 +527,17 @@ if (import.meta.hot) import.meta.hot.accept(() => {})
         join(root, 'production.mjs'),
         `import calculate, { reads } from 'pure-math'; globalThis.calculate = calculate; globalThis.reads = reads`
       )
+      // a production bundle is minified by default, so this also covers worklet
+      // closure serialization under mangling: the worklet body is a string
+      // literal the minifier leaves alone, and __closure carries its captures
+      // by property name, which mangling does not rewrite.
       const production = await buildNativeBundle({
         root,
         platform: 'android',
         entryFile: 'production.mjs',
         plugins: [workletImportsPlugin({ 'pure-math': ['default', 'reads'] })],
       })
+      expect(production.code).not.toContain('__esmMin')
       const productionRN: any = { console }
       runInNewContext(production.code, productionRN)
       expect(productionRN.calculate(10)).toBe(109)
@@ -409,6 +545,20 @@ if (import.meta.hot) import.meta.hot.accept(() => {})
       expect(reconstruct(productionRN.reads)()).toBe(3)
       expect(productionRN.reads()).toBe(1)
 
+      const unminifiedProduction = await buildNativeBundle({
+        root,
+        platform: 'android',
+        entryFile: 'production.mjs',
+        minify: false,
+        plugins: [workletImportsPlugin({ 'pure-math': ['default', 'reads'] })],
+      })
+      expect(unminifiedProduction.code).toContain('__esmMin')
+      const unminifiedRN: any = { console }
+      runInNewContext(unminifiedProduction.code, unminifiedRN)
+      expect(unminifiedRN.calculate(10)).toBe(109)
+      expect(reconstruct(unminifiedRN.calculate)(10)).toBe(109)
+      expect(reconstruct(unminifiedRN.reads)()).toBe(3)
+
       const sharedPlugin = workletImportsPlugin({ 'pure-math': ['default', 'reads'] })
       const parallel = await Promise.all(
         (['ios', 'android'] as const).map(async (platform) => {
@@ -512,60 +662,70 @@ if (import.meta.hot) import.meta.hot.accept(() => {})
 })
 
 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) => `
+  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 })
+      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',
@@ -1594,6 +1754,102 @@ export function Box() {
   })
 })
 
+describe('native production minification', () => {
+  // a cjs dependency reached through an esm module, a top-level export, and a
+  // runtime result that depends on both. minification mangles every top-level
+  // name here and drops every comment, which is what the bundle's
+  // post-processing reads, so a pass that runs on minified output stops
+  // applying — silently for the commonjs interop, and fatally for the `export`
+  // statement, which hermes cannot parse.
+  async function writeMinifyFixture() {
+    const root = await mkdtemp(join(tmpdir(), 'vxrn-native-minify-'))
+    const dep = join(root, 'node_modules', 'legacy-color')
+    await mkdir(dep, { recursive: true })
+    await writeFile(
+      join(dep, 'package.json'),
+      JSON.stringify({ name: 'legacy-color', main: 'index.js' })
+    )
+    await writeFile(
+      join(dep, 'index.js'),
+      `function LegacyColor(value) { this.value = value }
+LegacyColor.prototype.describe = function () { return 'legacy:' + this.value }
+module.exports = LegacyColor`
+    )
+    await writeFile(
+      join(root, 'views.js'),
+      `'use strict';
+import LegacyColor from 'legacy-color'
+import { level } from './entry.js'
+export const describeHeader = () => new LegacyColor(level()).describe()`
+    )
+    await writeFile(
+      join(root, 'entry.js'),
+      `import { describeHeader } from './views.js'
+export const level = () => 'header'
+globalThis.minifyProbe = describeHeader()`
+    )
+    return root
+  }
+
+  function runFixture(code: string) {
+    const context: Record<string, unknown> = { console }
+    runInNewContext(code, context)
+    return Reflect.get(context, 'minifyProbe')
+  }
+
+  it('minifies when asked, leaves the bundle alone when not, and both behave the same', async () => {
+    const root = await writeMinifyFixture()
+    try {
+      const [plain, minified] = await Promise.all(
+        [false, true].map((minify) =>
+          buildNativeBundle({ root, platform: 'ios', entryFile: 'entry.js', minify })
+        )
+      )
+
+      // the unminified bundle keeps rolldown's generated names and layout
+      expect(plain.code).toContain('__toESM')
+      expect(plain.code).toContain('describeHeader')
+      expect(plain.code.split('\n').length).toBeGreaterThan(40)
+
+      // the minified one keeps neither
+      expect(minified.code).not.toContain('describeHeader')
+      expect(minified.code).not.toContain('//#region')
+      expect(minified.code.length).toBeLessThan(plain.code.length * 0.7)
+
+      // and both still run, with the same result. before the post-processing
+      // moved inside the bundle, the minified one threw on its surviving
+      // `export {}` statement.
+      expect(runFixture(minified.code)).toBe('legacy:header')
+      expect(runFixture(plain.code)).toBe('legacy:header')
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+
+  it("defaults to react native's rule: minify a production bundle, never a dev one", async () => {
+    const root = await writeMinifyFixture()
+    try {
+      const [prod, devBundle, explicitOff] = await Promise.all([
+        buildNativeBundle({ root, platform: 'ios', entryFile: 'entry.js' }),
+        buildNativeBundle({ root, platform: 'ios', entryFile: 'entry.js', dev: true }),
+        buildNativeBundle({
+          root,
+          platform: 'ios',
+          entryFile: 'entry.js',
+          minify: false,
+        }),
+      ])
+
+      expect(prod.code).not.toContain('describeHeader')
+      expect(devBundle.code).toContain('describeHeader')
+      expect(explicitOff.code).toContain('describeHeader')
+      expect(prod.code.length).toBeLessThan(explicitOff.code.length)
+    } finally {
+      await rm(root, { recursive: true, force: true })
+    }
+  })
+})
+
 describe('native production assets', () => {
   it('registers scale siblings and keeps monorepo assets inside assetsDest', async () => {
     const testRoot = await mkdtemp(join(tmpdir(), 'vxrn-native-assets-'))
@@ -1650,7 +1906,23 @@ globalThis.__nativeAssetProbe = [icon, back]
         assetsDest,
       })
 
-      expect(result.code).toMatch(/"scales":\s*\[\s*1,\s*2,\s*3\s*\]/)
+      const registered: Array<{ name: string; scales: number[] }> = []
+      runInNewContext(result.code, {
+        console,
+        require: (id: string) =>
+          id === 'react-native/Libraries/Image/AssetRegistry'
+            ? {
+                registerAsset: (asset: { name: string; scales: number[] }) => {
+                  registered.push(asset)
+                  return asset
+                },
+              }
+            : {},
+      })
+      expect(registered.map((asset) => [asset.name, asset.scales])).toEqual([
+        ['icon', [1, 2, 3]],
+        ['back', [1, 2]],
+      ])
       for (const file of ['icon.png', 'icon@2x.png', 'icon@3x.png']) {
         expect(existsSync(join(assetsDest, 'assets/assets', file))).toBe(true)
       }
@@ -1835,21 +2107,23 @@ 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}/**
+  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
  */
@@ -1868,25 +2142,139 @@ export default class Flowy {
   }
 }
 `
-    )
-    await writeFile(
-      join(testRoot, 'entry.js'),
-      `import Flowy from '@flowy-scope/flowy-lib'
+      )
+      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 })
+      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 })
+      }
     }
+  )
+})
+
+describe('native bundle source maps', () => {
+  // the generated position of a marker in the emitted bundle is exactly what a
+  // device reports in a stack frame, so resolving it is the same question as
+  // symbolicating a crash.
+  const generatedPositionOf = (code: string, marker: string) => {
+    const index = code.indexOf(marker)
+    expect(index).toBeGreaterThan(-1)
+    const before = code.slice(0, index)
+    const lastNewline = before.lastIndexOf('\n')
+    return {
+      line: (before.match(/\n/g)?.length ?? 0) + 1,
+      column: index - lastNewline - 1,
+    }
+  }
+
+  it(
+    'resolves a frame to the authored file and line across an app file and a package file',
+    { timeout: 60_000 },
+    async () => {
+      // realpath: macOS hands out /var/folders temp dirs that resolve to
+      // /private/var, and the map records the resolved path.
+      const testRoot = realpathSync(
+        await mkdtemp(join(tmpdir(), 'vxrn-native-sourcemap-'))
+      )
+      const packageRoot = join(testRoot, 'node_modules/probe-package')
+      await mkdir(packageRoot, { recursive: true })
+      await writeFile(
+        join(packageRoot, 'package.json'),
+        JSON.stringify({ name: 'probe-package', main: 'index.js', type: 'module' })
+      )
+      // a blank line directly above an `export default` is the case that used to
+      // disappear during post-processing and shift every frame below it.
+      await writeFile(
+        join(packageRoot, 'index.js'),
+        [
+          `function packageThrow() {`, // 1
+          `  throw new Error('__probe_package__')`, // 2
+          `}`, // 3
+          ``, // 4
+          `export default packageThrow`, // 5
+        ].join('\n')
+      )
+      await writeFile(
+        join(testRoot, 'entry.js'),
+        [
+          `import packageThrow from 'probe-package'`, // 1
+          ``, // 2
+          `function appThrow() {`, // 3
+          `  throw new Error('__probe_app__')`, // 4
+          `}`, // 5
+          ``, // 6
+          `globalThis.__probe = [appThrow, packageThrow]`, // 7
+        ].join('\n')
+      )
+
+      try {
+        const result = await buildNativeBundle({
+          root: testRoot,
+          platform: 'ios',
+          entryFile: 'entry.js',
+          dev: true,
+          sourcemap: true,
+        })
+        expect(result.map).toBeTruthy()
+        const traced = new TraceMap(JSON.parse(result.map!))
+
+        const app = originalPositionFor(
+          traced,
+          generatedPositionOf(result.code, '__probe_app__')
+        )
+        const pkg = originalPositionFor(
+          traced,
+          generatedPositionOf(result.code, '__probe_package__')
+        )
+
+        // the authored line, which a post-processing pass that drops a line
+        // silently moves
+        expect(app.source?.endsWith('/entry.js')).toBe(true)
+        expect(app.line).toBe(4)
+        expect(pkg.source?.endsWith('/index.js')).toBe(true)
+        expect(pkg.line).toBe(2)
+
+        // and the absolute path, which is all a crash reporter has to go on
+        expect(app.source).toBe(normalizePath(join(testRoot, 'entry.js')))
+        expect(pkg.source).toBe(normalizePath(join(packageRoot, 'index.js')))
+      } finally {
+        await rm(testRoot, { recursive: true, force: true })
+      }
+    }
+  )
+})
+
+describe('postProcessNativeBundle', () => {
+  // rolldown emits the map before these passes run, so a line they remove moves
+  // every frame below it away from the source it maps to.
+  const lines = (code: string) => code.split('\n').length
+
+  it('keeps the blank line above an export default', () => {
+    const input = ['var a = 1;', '', 'export default a;', 'var b = 2;', ''].join('\n')
+    const out = postProcessNativeBundle(input)
+    expect(lines(out)).toBe(lines(input))
+    expect(out.split('\n')[2]).toBe('a;')
+  })
+
+  it('keeps the lines of a multi-line export statement', () => {
+    const input = ['var a = 1;', 'export {', '  a', '};', 'var b = 2;', ''].join('\n')
+    const out = postProcessNativeBundle(input)
+    expect(lines(out)).toBe(lines(input))
+    expect(out).not.toContain('export {')
+    expect(out.split('\n')[4]).toBe('var b = 2;')
   })
 })