vxrn 1.25.16 → 1.26.0

package/dist/utils/createNativeDevEngine.test.native.js

@@ -2,12 +2,13 @@ import { existsSync } from "fs";
 import { mkdir, mkdtemp, rm, writeFile } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
-import { runInNewContext } from "vm";
+import { createContext, runInContext, runInNewContext } from "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.native.js";
-import { buildNativeBundle, createNativeDevAssetRegistry, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.native.js";
+import { workletImportsPlugin } from "../plugins/workletImportsPlugin.native.js";
+import { buildNativeBundle, createNativeDevAssetRegistry, createNativeDevEngine, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.native.js";
 function _instanceof(left, right) {
   if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);else return left instanceof right;
 }
@@ -22,6 +23,265 @@ export const transformProbe = () => {
   return 'transformed'
 }
 `;
+describe.each(["rolldown-dev", "rolldown-build", "metro-module", "metro-script"])("native async through %s", function (pipeline) {
+  it("preserves defaults, lexical bindings, bigint, rejection, and iterator cleanup", async function () {
+    var id = "/project/native-async.js";
+    var 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');
+`;
+    var output;
+    if (pipeline.startsWith("metro")) {
+      var {
+        transform
+      } = await import("@vxrn/vite-plugin-metro/metroNativeWorker");
+      var data = (await transform({}, "/project", id, Buffer.from(source), {
+        dev: false,
+        platform: "ios",
+        type: pipeline === "metro-script" ? "script" : "module"
+      })).output[0].data;
+      var {
+        fromRawMappings
+      } = await import("metro-source-map");
+      output = {
+        code: data.code,
+        map: fromRawMappings([{
+          code: data.code,
+          path: id,
+          source,
+          map: data.map
+        }]).toMap()
+      };
+    } else {
+      var plugin = hermesCompatSWCPlugin(pipeline === "rolldown-dev", true);
+      output = await Reflect.apply(plugin.transform, void 0, [source, id]);
+    }
+    var context = {};
+    context.__d = function (factory) {
+      var module = {
+        exports: {}
+      };
+      factory(context, function (name) {
+        throw new Error(`unexpected dependency ${name}`);
+      }, function () {}, function () {}, module, module.exports, []);
+    };
+    runInNewContext(output.code, context);
+    var result1 = await context.result;
+    expect(result1.values).toEqual([["5", 7, "lexical"], ["7", 7, "lexical"], "rejected", "default", "1"]);
+    expect(result1.synchronousThrow).toBe(false);
+    expect(result1.events.filter(function (value) {
+      return value === "finally";
+    })).toHaveLength(3);
+    expect(result1.events.filter(function (value) {
+      return value === "closed";
+    })).toHaveLength(1);
+    var {
+      originalPositionFor,
+      TraceMap
+    } = await import("@jridgewell/trace-mapping");
+    var lines = output.code.split("\n");
+    var line = lines.findIndex(function (value) {
+      return value.includes("after-await");
+    });
+    var 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(function (value) {
+      return value.includes("after-await");
+    }) + 1);
+  });
+});
+describe.each(["shared", "rolldown", "metro"])("React Compiler worklets through %s", function (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 function (_name, callback, expected) {
+    var compiler = await import("@vxrn/compiler");
+    var {
+      parseSync
+    } = await import("oxc-parser");
+    var {
+      default: MagicString
+    } = await import("magic-string");
+    var {
+      TraceMap,
+      originalPositionFor
+    } = await import("@jridgewell/trace-mapping");
+    var projectRoot = await createWorkletsProject(false);
+    var sourceMaps = process.env.VXRN_ENABLE_SOURCE_MAP;
+    process.env.VXRN_ENABLE_SOURCE_MAP = "1";
+    compiler.configureVXRNCompilerPlugin({
+      enableCompiler: true,
+      enableReanimated: true,
+      enableNativeWorklets: true
+    });
+    try {
+      var _first___initData;
+      var id = join(projectRoot, "useProbe.ts");
+      var source = `export function useProbe(value) {
+ return ${callback};
+}
+`;
+      await writeFile(id, source);
+      var result;
+      if (pipeline === "shared") {
+        var plugin = (await compiler.createVXRNCompilerPlugin()).find(function (p) {
+          return 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") {
+        var {
+          transform
+        } = await import("@vxrn/vite-plugin-metro/metroNativeWorker");
+        var data = (await transform({}, projectRoot, id, Buffer.from(source), {
+          dev: false,
+          platform: "ios",
+          type: "module",
+          customTransformOptions: {
+            reactCompiler: true,
+            worklets: true
+          }
+        })).output[0].data;
+        var msm = await import("metro-source-map");
+        result = {
+          code: data.code,
+          map: msm.fromRawMappings([{
+            code: data.code,
+            path: id,
+            source,
+            map: data.map
+          }]).toMap()
+        };
+      } else {
+        var plugin1 = vxrnCompilerPlugin("ios", false, projectRoot, true);
+        result = await Reflect.apply(plugin1.transform, void 0, [source, id]);
+      }
+      var runnable = new MagicString(result.code);
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = parseSync("probe.js", result.code).program.body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var node = _step.value;
+          if (node.type === "ImportDeclaration") runnable.remove(node.start, node.end);
+          if (node.type === "ExportNamedDeclaration" && node.declaration) runnable.remove(node.start, node.declaration.start);
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion && _iterator.return != null) _iterator.return();
+        } finally {
+          if (_didIteratorError) throw _iteratorError;
+        }
+      }
+      var cache;
+      var cacheCalls = 0;
+      var memo = function (size) {
+        cacheCalls++;
+        return cache !== null && cache !== void 0 ? cache : cache = Array(size).fill(/* @__PURE__ */Symbol.for("react.memo_cache_sentinel"));
+      };
+      var module = {
+        exports: {}
+      };
+      var probe = new Function("_c", "useDerivedValue", "runOnUI", "Gesture", "__d", "module", `${runnable}
+return ${pipeline === "metro" ? "module.exports.useProbe" : "useProbe"}`)(memo, function (fn2) {
+        return fn2;
+      }, function (fn2) {
+        return fn2;
+      }, {
+        Pan: function () {
+          return {
+            onUpdate: function (fn2) {
+              return fn2;
+            }
+          };
+        }
+      }, function (factory) {
+        return factory(globalThis, function () {
+          return {
+            c: memo
+          };
+        }, function () {}, function () {}, module, module.exports, []);
+      }, module);
+      var first = probe(10);
+      expect((_first___initData = first.__initData) === null || _first___initData === void 0 ? void 0 : _first___initData.code).toBeTypeOf("string");
+      for (var _i = 0, _iter = [false, true]; _i < _iter.length; _i++) {
+        var onUI = _iter[_i];
+        var fn = first;
+        var value = void 0;
+        for (var depth = 0; depth < 2; depth++) {
+          var _fn___initData;
+          expect((_fn___initData = fn.__initData) === null || _fn___initData === void 0 ? void 0 : _fn___initData.code).toBeTypeOf("string");
+          value = onUI ? new Function("runOnUI", `return (${fn.__initData.code})`)(function (fn2) {
+            return 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);
+      var lines = result.code.split("\n");
+      var line = lines.findIndex(function (text) {
+        return text.includes("function useProbe(");
+      });
+      expect(line).toBeGreaterThanOrEqual(0);
+      var 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() {
   var throwOnTransform = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
   var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-transform-failure-"));
@@ -30,7 +290,8 @@ async function createWorkletsProject() {
     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: {
@@ -68,7 +329,258 @@ describe("native prelude", function () {
     expect(context.removeEventListener).toBe(removeEventListener);
   });
 });
+describe("native pure-function worklet imports", function () {
+  it("keeps live module versions isolated across a transitive HMR update", async function () {
+    var root2 = await createWorkletsProject(false);
+    var 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"
+    }));
+    var 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(() => {})
+`);
+    var compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true
+    });
+    var resolveUpdate;
+    var updated = new Promise(function (resolve) {
+      resolveUpdate = resolve;
+    });
+    var 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 {
+      var initial = await native.getBundle();
+      var rn = {
+        console,
+        setTimeout,
+        clearTimeout
+      };
+      runInNewContext(initial.code, rn);
+      expect(rn.calculate(10)).toBe(12);
+      expect(rn.reads()).toBe(1);
+      var ui = createContext({});
+      var compiled = /* @__PURE__ */new Map();
+      var reconstruct = function (worklet) {
+        if (!worklet.__initData || !worklet.__workletHash) throw new Error("remote function");
+        var fn = compiled.get(worklet.__workletHash);
+        if (!fn) {
+          fn = runInContext(`(${worklet.__initData.code})`, ui);
+          compiled.set(worklet.__workletHash, fn);
+        }
+        var closure = Object.fromEntries(Object.entries(worklet.__closure).map(function (param) {
+          var [name, value] = param;
+          return [name, typeof value === "function" ? reconstruct(value) : value];
+        }));
+        return fn.bind({
+          __closure: closure
+        });
+      };
+      expect(function () {
+        return reconstruct(function (value) {
+          return value + 2;
+        });
+      }).toThrow("remote function");
+      var old = reconstruct(rn.calculate);
+      var 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);
+      var runtime = rn.__rolldown_runtime__;
+      await native.engine.registerClient(runtime.clientId);
+      await writeFile(dependency, "export const amount = 3");
+      var 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);
+      var next = reconstruct(rn.calculate);
+      expect([old(10), next(10), old(10), next(10)]).toEqual([12, 13, 12, 13]);
+      var 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`);
+      var production = await buildNativeBundle({
+        root: root2,
+        platform: "android",
+        entryFile: "production.mjs",
+        plugins: [workletImportsPlugin({
+          "pure-math": ["default", "reads"]
+        })]
+      });
+      var 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);
+      var sharedPlugin = workletImportsPlugin({
+        "pure-math": ["default", "reads"]
+      });
+      expect(await Promise.all(["ios", "android"].map(async function (platform) {
+        var output = await buildNativeBundle({
+          root: root2,
+          platform,
+          entryFile: "production.mjs",
+          plugins: [sharedPlugin]
+        });
+        var 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 function (_name, source, entry, expected) {
+    var root2 = await createWorkletsProject(false);
+    var 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);
+    var compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true
+    });
+    var 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", function () {
+  it.each([true, false])("keeps CommonJS default components callable through the native HMR wire path (Babel=%s)", async function (babel) {
+    var root2 = await mkdtemp(join(tmpdir(), "vxrn-native-hmr-interop-"));
+    var entry = join(root2, "entry.mjs");
+    var 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 }`);
+    var source = function (version) {
+      return `
+import Component from 'component'
+globalThis.renderComponent = Component
+export const version = ${version}
+if (import.meta.hot) import.meta.hot.accept(() => {})
+`;
+    };
+    await writeFile(entry, source(1));
+    var resolveUpdate;
+    var updateReceived = new Promise(function (resolve) {
+      resolveUpdate = resolve;
+    });
+    var 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 {
+      var initial = await native.getBundle();
+      var context = {
+        console,
+        setTimeout,
+        clearTimeout
+      };
+      runInNewContext(initial.code, context);
+      expect(context.renderComponent()).toBe(42);
+      var runtime = context.__rolldown_runtime__;
+      await native.engine.registerClient(runtime.clientId);
+      await writeFile(entry, source(2));
+      var 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 function () {
@@ -390,6 +902,27 @@ describe("getHermesSWCIncludes", function () {
     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 function () {
+    var plugin = hermesCompatSWCPlugin(true);
+    if (typeof plugin.transform !== "function") throw new Error("Hermes compatibility transform hook is not callable");
+    var 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 function () {
     var plugin = hermesCompatSWCPlugin(true);
     if (typeof plugin.transform !== "function") throw new Error("Hermes compatibility transform hook is not callable");
@@ -505,6 +1038,7 @@ describe("native required transform failures", function () {
   it.each([true, false])("rejects valid worklet source when its required compiler transform fails (dev=%s)", async function (dev2) {
     var testRoot = await createWorkletsProject();
     var compiler = await import("@vxrn/compiler");
+    var spy = vi.spyOn(compiler, "transformWorklets").mockRejectedValue(/* @__PURE__ */new Error("NATIVE_TRANSFORM_NEGATIVE_CONTROL"));
     compiler.configureVXRNCompilerPlugin({
       enableReanimated: true
     });
@@ -513,6 +1047,7 @@ describe("native required transform failures", function () {
       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
       });
@@ -525,6 +1060,7 @@ describe("native required transform failures", function () {
   it("returns a dev build error and no output when the required compiler transform fails", async function () {
     var testRoot = await createWorkletsProject();
     var compiler = await import("@vxrn/compiler");
+    var spy = vi.spyOn(compiler, "transformWorklets").mockRejectedValue(/* @__PURE__ */new Error("NATIVE_TRANSFORM_NEGATIVE_CONTROL"));
     compiler.configureVXRNCompilerPlugin({
       enableReanimated: true
     });
@@ -547,6 +1083,7 @@ describe("native required transform failures", function () {
       expect(result).toBeInstanceOf(Error);
       expect(String(result)).toContain("NATIVE_TRANSFORM_NEGATIVE_CONTROL");
     } finally {
+      spy.mockRestore();
       await engine.close();
       compiler.configureVXRNCompilerPlugin({
         enableReanimated: false
@@ -560,6 +1097,7 @@ describe("native required transform failures", function () {
   it("emits no production bundle when the required compiler transform fails", async function () {
     var testRoot = await createWorkletsProject();
     var compiler = await import("@vxrn/compiler");
+    var spy = vi.spyOn(compiler, "transformWorklets").mockRejectedValue(/* @__PURE__ */new Error("NATIVE_TRANSFORM_NEGATIVE_CONTROL"));
     compiler.configureVXRNCompilerPlugin({
       enableReanimated: true
     });
@@ -570,6 +1108,7 @@ describe("native required transform failures", function () {
         entryFile: "entry.ts"
       })).rejects.toThrow("NATIVE_TRANSFORM_NEGATIVE_CONTROL");
     } finally {
+      spy.mockRestore();
       compiler.configureVXRNCompilerPlugin({
         enableReanimated: false
       });
@@ -607,6 +1146,238 @@ describe("native required transform failures", function () {
       });
     }
   });
+  it("composes source maps across React Compiler, Fast Refresh, and module wrapper back to original source lines", async function () {
+    var {
+      TraceMap,
+      originalPositionFor
+    } = await import("@jridgewell/trace-mapping");
+    var compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableCompiler: true
+    });
+    try {
+      var plugin = vxrnCompilerPlugin("ios", true, "/project", true);
+      if (typeof plugin.transform !== "function") throw new Error("transform hook not callable");
+      var inputCode = `import { useState } from 'react'
+
+export function Counter() {
+  const [count, setCount] = useState(0)
+  return <button onClick={() => setCount(count + 1)}>{count}</button>
+}
+`;
+      var id = "/project/Counter.tsx";
+      var result = await Reflect.apply(plugin.transform, void 0, [inputCode, id]);
+      expect(result).toBeDefined();
+      expect(result.map).toBeDefined();
+      var tracer = new TraceMap(result.map);
+      var counterLineIndex = result.code.split("\n").findIndex(function (l) {
+        return l.includes("function Counter");
+      });
+      expect(counterLineIndex).toBeGreaterThan(0);
+      var 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 function () {
+    var {
+      TraceMap,
+      originalPositionFor
+    } = await import("@jridgewell/trace-mapping");
+    var compiler = await import("@vxrn/compiler");
+    var origEnv = process.env.VXRN_USE_BABEL_FOR_GENERATORS;
+    process.env.VXRN_USE_BABEL_FOR_GENERATORS = "1";
+    compiler.configureVXRNCompilerPlugin({
+      enableCompiler: true,
+      enableReanimated: false
+    });
+    try {
+      var plugin = vxrnCompilerPlugin("ios", true, "/project", true);
+      if (typeof plugin.transform !== "function") throw new Error("transform hook not callable");
+      var inputCode = `export function Counter() { return <View />; }
+
+
+
+
+
+
+
+export async function* probe() { throw new Error("MARKER"); }
+`;
+      var id = "/project/Counter.tsx";
+      var 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);
+      var tracer = new TraceMap(result.map);
+      var lines = result.code.split("\n");
+      var markerLineIndex = lines.findIndex(function (l) {
+        return l.includes("MARKER");
+      });
+      expect(markerLineIndex).toBeGreaterThan(0);
+      var markerCol = lines[markerLineIndex].indexOf("throw");
+      var pos = originalPositionFor(tracer, {
+        line: markerLineIndex + 1,
+        column: markerCol
+      });
+      expect(pos.source).toBe(id);
+      expect(pos.line).toBe(9);
+      expect(pos.column).toBe(33);
+      var compilerOut = await compiler.transformOxcReactCompiler(id, inputCode, "19", true);
+      var remapping = (await import("@jridgewell/remapping")).default;
+      var badPos = originalPositionFor(new TraceMap(remapping([result.map, compilerOut.map], function () {
+        return 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 function () {
+    var {
+      TraceMap,
+      originalPositionFor
+    } = await import("@jridgewell/trace-mapping");
+    var compiler = await import("@vxrn/compiler");
+    var {
+      vi: vi2
+    } = await import("vitest");
+    var babelSpy = vi2.spyOn(compiler, "transformBabel");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true,
+      enableCompiler: false
+    });
+    try {
+      var projectRoot = process.cwd();
+      var plugin = vxrnCompilerPlugin("ios", true, projectRoot, true);
+      if (typeof plugin.transform !== "function") throw new Error("transform hook not callable");
+      var inputCode = `import { useAnimatedStyle } from 'react-native-reanimated'
+
+export function Box() {
+  const animatedStyle = useAnimatedStyle(() => {
+    return { opacity: 1 }
+  })
+  return <div style={animatedStyle} />
+}
+`;
+      var id = join(projectRoot, "Box.tsx");
+      var 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();
+      var tracer = new TraceMap(result.map);
+      var boxLineIndex = result.code.split("\n").findIndex(function (l) {
+        return l.includes("export function Box");
+      });
+      expect(boxLineIndex).toBeGreaterThan(0);
+      var 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 function () {
+    var compiler = await import("@vxrn/compiler");
+    var {
+      vi: vi2
+    } = await import("vitest");
+    var babelSpy = vi2.spyOn(compiler, "transformBabel").mockResolvedValue({
+      code: "/* babel transformed */"
+    });
+    var workletSpy = vi2.spyOn(compiler, "transformWorklets");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: false
+    });
+    var getBabelOptionsSpy = vi2.spyOn(compiler, "getBabelOptions").mockReturnValue({
+      plugins: ["react-native-reanimated/plugin"]
+    });
+    try {
+      var projectRoot = process.cwd();
+      var plugin = vxrnCompilerPlugin("ios", true, projectRoot, false);
+      if (typeof plugin.transform !== "function") throw new Error("transform hook not callable");
+      var inputCode = `export function fn() { 'worklet'; return 1 }`;
+      var 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 function () {
+    var compiler = await import("@vxrn/compiler");
+    var {
+      vi: vi2
+    } = await import("vitest");
+    var babelSpy = vi2.spyOn(compiler, "transformBabel");
+    var workletSpy = vi2.spyOn(compiler, "transformWorklets");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true,
+      enableNativeWorklets: true
+    });
+    var getBabelOptionsSpy = vi2.spyOn(compiler, "getBabelOptions").mockReturnValue({
+      plugins: [["react-native-reanimated/plugin", {
+        globals: ["customGlobal"]
+      }]]
+    });
+    try {
+      var projectRoot = process.cwd();
+      var plugin = vxrnCompilerPlugin("ios", true, projectRoot, false);
+      if (typeof plugin.transform !== "function") throw new Error("transform hook not callable");
+      var inputCode = `export function fn() { 'worklet'; return customGlobal * 2 }`;
+      var id = join(projectRoot, "TupleWorklet.tsx");
+      var 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", function () {
   it("registers scale siblings and keeps monorepo assets inside assetsDest", async function () {
@@ -811,4 +1582,65 @@ globalThis.__vxrnConditionalExportProbe = helper()
     }
   });
 });
+describe("native Flow sources", function () {
+  it.each(["", `/* ${"license text ".repeat(150)} */
+`])("strips third-party Flow following a license header (%#)", async function (license) {
+    var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-flow-"));
+    var 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 {
+      var result = await buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.js"
+      });
+      var 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.native.js.map