vxrn 1.25.16 → 1.26.0

package/dist/utils/createNativeDevEngine.test.mjs

@@ -2,18 +2,234 @@ 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 } 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.mjs";
-import { buildNativeBundle, createNativeDevAssetRegistry, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.mjs";
+import { workletImportsPlugin } from "../plugins/workletImportsPlugin.mjs";
+import { buildNativeBundle, createNativeDevAssetRegistry, createNativeDevEngine, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.mjs";
 const nativeTransformProbe = `
 export const transformProbe = () => {
   'worklet'
   return 'transformed'
 }
 `;
+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;
+    if (pipeline.startsWith("metro")) {
+      const {
+        transform
+      } = await import("@vxrn/vite-plugin-metro/metroNativeWorker");
+      const data = (await transform({}, "/project", id, Buffer.from(source), {
+        dev: false,
+        platform: "ios",
+        type: pipeline === "metro-script" ? "script" : "module"
+      })).output[0].data;
+      const {
+        fromRawMappings
+      } = await import("metro-source-map");
+      output = {
+        code: data.code,
+        map: fromRawMappings([{
+          code: data.code,
+          path: id,
+          source,
+          map: data.map
+        }]).toMap()
+      };
+    } else {
+      const plugin = hermesCompatSWCPlugin(pipeline === "rolldown-dev", true);
+      output = await Reflect.apply(plugin.transform, void 0, [source, id]);
+    }
+    const context = {};
+    context.__d = factory => {
+      const module = {
+        exports: {}
+      };
+      factory(context, name => {
+        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 => value === "finally")).toHaveLength(3);
+    expect(result.events.filter(value => value === "closed")).toHaveLength(1);
+    const {
+      originalPositionFor,
+      TraceMap
+    } = await import("@jridgewell/trace-mapping");
+    const lines = output.code.split("\n");
+    const line = lines.findIndex(value => 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) {
+ return ${callback};
+}
+`;
+      await writeFile(id, source);
+      let result;
+      if (pipeline === "shared") {
+        const plugin = (await compiler.createVXRNCompilerPlugin()).find(p => p.name === "one:compiler");
+        await plugin.configResolved({
+          root: projectRoot,
+          build: {}
+        });
+        result = await (plugin.transform.handler || plugin.transform).call({
+          environment: {
+            name: "ios"
+          }
+        }, source, id);
+      } else if (pipeline === "metro") {
+        const {
+          transform
+        } = await import("@vxrn/vite-plugin-metro/metroNativeWorker");
+        const data = (await transform({}, projectRoot, id, Buffer.from(source), {
+          dev: false,
+          platform: "ios",
+          type: "module",
+          customTransformOptions: {
+            reactCompiler: true,
+            worklets: true
+          }
+        })).output[0].data;
+        const msm = await import("metro-source-map");
+        result = {
+          code: data.code,
+          map: msm.fromRawMappings([{
+            code: data.code,
+            path: id,
+            source,
+            map: data.map
+          }]).toMap()
+        };
+      } else {
+        const plugin = vxrnCompilerPlugin("ios", false, projectRoot, true);
+        result = await Reflect.apply(plugin.transform, void 0, [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;
+      let cacheCalls = 0;
+      const memo = size => {
+        cacheCalls++;
+        return cache ??= Array(size).fill(/* @__PURE__ */Symbol.for("react.memo_cache_sentinel"));
+      };
+      const module = {
+        exports: {}
+      };
+      const probe = new Function("_c", "useDerivedValue", "runOnUI", "Gesture", "__d", "module", `${runnable}
+return ${pipeline === "metro" ? "module.exports.useProbe" : "useProbe"}`)(memo, fn => fn, fn => fn, {
+        Pan: () => ({
+          onUpdate: fn => fn
+        })
+      }, factory => 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;
+        for (let depth = 0; depth < 2; depth++) {
+          expect(fn.__initData?.code).toBeTypeOf("string");
+          value = onUI ? new Function("runOnUI", `return (${fn.__initData.code})`)(fn2 => fn2).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 => 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 === void 0) 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");
@@ -21,7 +237,8 @@ async function createWorkletsProject(throwOnTransform = true) {
     recursive: true
   });
   await writeFile(join(packageRoot, "package.json"), JSON.stringify({
-    name: "react-native-worklets"
+    name: "react-native-worklets",
+    version: "0.10.1"
   }));
   await writeFile(join(packageRoot, "plugin.js"), throwOnTransform ? `module.exports = () => ({
       visitor: {
@@ -59,7 +276,249 @@ describe("native prelude", () => {
     expect(context.removeEventListener).toBe(removeEventListener);
   });
 });
+describe("native pure-function worklet imports", () => {
+  it("keeps live module versions isolated across a transitive HMR update", async () => {
+    const root2 = await createWorkletsProject(false);
+    const packageRoot = join(root2, "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(root2, "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;
+    const updated = new Promise(resolve => {
+      resolveUpdate = resolve;
+    });
+    const native = await createNativeDevEngine({
+      root: root2,
+      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 = {
+        console,
+        setTimeout,
+        clearTimeout
+      };
+      runInNewContext(initial.code, rn);
+      expect(rn.calculate(10)).toBe(12);
+      expect(rn.reads()).toBe(1);
+      const ui = createContext({});
+      const compiled = /* @__PURE__ */new Map();
+      const reconstruct = worklet => {
+        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 => 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(root2, "production.mjs"), `import calculate, { reads } from 'pure-math'; globalThis.calculate = calculate; globalThis.reads = reads`);
+      const production = await buildNativeBundle({
+        root: root2,
+        platform: "android",
+        entryFile: "production.mjs",
+        plugins: [workletImportsPlugin({
+          "pure-math": ["default", "reads"]
+        })]
+      });
+      const productionRN = {
+        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"]
+      });
+      expect(await Promise.all(["ios", "android"].map(async platform => {
+        const output = await buildNativeBundle({
+          root: root2,
+          platform,
+          entryFile: "production.mjs",
+          plugins: [sharedPlugin]
+        });
+        const context = {
+          console
+        };
+        runInNewContext(output.code, context);
+        return context.calculate(10);
+      }))).toEqual([13, 109]);
+    } finally {
+      await native.close();
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false
+      });
+      await rm(root2, {
+        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/]])("rejects %s through the native engine", async (_name, source, entry, expected) => {
+    const root2 = await createWorkletsProject(false);
+    const packageRoot = join(root2, "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(root2, "entry.mjs"), entry);
+    const compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true
+    });
+    const native = await createNativeDevEngine({
+      root: root2,
+      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(root2, {
+        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 root2 = await mkdtemp(join(tmpdir(), "vxrn-native-hmr-interop-"));
+    const entry = join(root2, "entry.mjs");
+    const packageRoot = join(root2, "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 => `
+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;
+    const updateReceived = new Promise(resolve => {
+      resolveUpdate = resolve;
+    });
+    const native = await createNativeDevEngine({
+      root: root2,
+      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 = {
+        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(root2, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
   it("registers a Rolldown 1.2 client and applies a self-accepted patch", {
     timeout: 3e4
   }, async () => {
@@ -347,6 +806,27 @@ describe("getHermesSWCIncludes", () => {
     expect(result.code).not.toContain("async function*");
     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, void 0, [`
+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") throw new Error("Hermes compatibility transform hook is not callable");
@@ -457,6 +937,7 @@ describe("native required transform failures", () => {
   it.each([true, false])("rejects valid worklet source when its required compiler transform fails (dev=%s)", async dev2 => {
     const testRoot = await createWorkletsProject();
     const compiler = await import("@vxrn/compiler");
+    const spy = vi.spyOn(compiler, "transformWorklets").mockRejectedValue(/* @__PURE__ */new Error("NATIVE_TRANSFORM_NEGATIVE_CONTROL"));
     compiler.configureVXRNCompilerPlugin({
       enableReanimated: true
     });
@@ -465,6 +946,7 @@ describe("native required transform failures", () => {
       if (typeof plugin.transform !== "function") throw new Error("vxrn compiler transform hook is not callable");
       await expect(Reflect.apply(plugin.transform, void 0, [nativeTransformProbe, join(testRoot, "entry.ts")])).rejects.toThrow("NATIVE_TRANSFORM_NEGATIVE_CONTROL");
     } finally {
+      spy.mockRestore();
       compiler.configureVXRNCompilerPlugin({
         enableReanimated: false
       });
@@ -477,6 +959,7 @@ 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(/* @__PURE__ */new Error("NATIVE_TRANSFORM_NEGATIVE_CONTROL"));
     compiler.configureVXRNCompilerPlugin({
       enableReanimated: true
     });
@@ -499,6 +982,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
@@ -512,6 +996,7 @@ 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(/* @__PURE__ */new Error("NATIVE_TRANSFORM_NEGATIVE_CONTROL"));
     compiler.configureVXRNCompilerPlugin({
       enableReanimated: true
     });
@@ -522,6 +1007,7 @@ describe("native required transform failures", () => {
         entryFile: "entry.ts"
       })).rejects.toThrow("NATIVE_TRANSFORM_NEGATIVE_CONTROL");
     } finally {
+      spy.mockRestore();
       compiler.configureVXRNCompilerPlugin({
         enableReanimated: false
       });
@@ -559,6 +1045,230 @@ describe("native required transform failures", () => {
       });
     }
   });
+  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, void 0, [inputCode, id]);
+      expect(result).toBeDefined();
+      expect(result.map).toBeDefined();
+      const tracer = new TraceMap(result.map);
+      const counterLineIndex = result.code.split("\n").findIndex(l => 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, void 0, [inputCode, id]);
+      expect(result).toBeDefined();
+      expect(result.map).toBeDefined();
+      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 => 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);
+      const compilerOut = await compiler.transformOxcReactCompiler(id, inputCode, "19", true);
+      const remapping = (await import("@jridgewell/remapping")).default;
+      const badPos = originalPositionFor(new TraceMap(remapping([result.map, compilerOut.map], () => null)), {
+        line: markerLineIndex + 1,
+        column: markerCol
+      });
+      expect(badPos.source).toBeNull();
+      expect(badPos.line).toBeNull();
+    } finally {
+      compiler.configureVXRNCompilerPlugin({
+        enableCompiler: false
+      });
+      if (origEnv !== void 0) 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: vi2
+    } = await import("vitest");
+    const babelSpy = vi2.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, void 0, [inputCode, id]);
+      expect(result).toBeDefined();
+      expect(result.code).toContain("__workletHash");
+      expect(result.code).toContain("__closure");
+      expect(babelSpy).not.toHaveBeenCalled();
+      expect(result.map).toBeDefined();
+      const tracer = new TraceMap(result.map);
+      const boxLineIndex = result.code.split("\n").findIndex(l => 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: vi2
+    } = await import("vitest");
+    const babelSpy = vi2.spyOn(compiler, "transformBabel").mockResolvedValue({
+      code: "/* babel transformed */"
+    });
+    const workletSpy = vi2.spyOn(compiler, "transformWorklets");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: false
+    });
+    const getBabelOptionsSpy = vi2.spyOn(compiler, "getBabelOptions").mockReturnValue({
+      plugins: ["react-native-reanimated/plugin"]
+    });
+    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");
+      expect(await Reflect.apply(plugin.transform, void 0, [inputCode, id])).toBeDefined();
+      expect(babelSpy).toHaveBeenCalledWith(id, inputCode, expect.objectContaining({
+        plugins: expect.arrayContaining(["react-native-reanimated/plugin"])
+      }));
+      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: vi2
+    } = await import("vitest");
+    const babelSpy = vi2.spyOn(compiler, "transformBabel");
+    const workletSpy = vi2.spyOn(compiler, "transformWorklets");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true
+    });
+    const getBabelOptionsSpy = vi2.spyOn(compiler, "getBabelOptions").mockReturnValue({
+      plugins: [["react-native-reanimated/plugin", {
+        globals: ["customGlobal"]
+      }]]
+    });
+    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, void 0, [inputCode, id]);
+      expect(result).toBeDefined();
+      expect(result.code).toContain("__workletHash");
+      expect(workletSpy).toHaveBeenCalledWith(id, expect.any(String), false, expect.objectContaining({
+        globals: ["customGlobal"],
+        projectRoot
+      }));
+      expect(babelSpy).not.toHaveBeenCalled();
+    } finally {
+      babelSpy.mockRestore();
+      workletSpy.mockRestore();
+      getBabelOptionsSpy.mockRestore();
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false,
+        enableNativeWorklets: false
+      });
+    }
+  });
 });
 describe("native production assets", () => {
   it("registers scale siblings and keeps monorepo assets inside assetsDest", async () => {
@@ -752,4 +1462,65 @@ globalThis.__vxrnConditionalExportProbe = helper()
     }
   });
 });
+describe("native Flow sources", () => {
+  it.each(["", `/* ${"license text ".repeat(150)} */
+`])("strips third-party Flow following a license header (%#)", async license => {
+    const testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-flow-"));
+    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
+      });
+    }
+  });
+});
 //# sourceMappingURL=createNativeDevEngine.test.mjs.map