@vxrn/compiler 2.0.0-beta.33.1 → 2.0.0-beta.45.1

package/dist/cjs/transformWorklets.test.cjs

@@ -1,604 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-// If the importer is in node compatibility mode or this is not an ESM
-// file that has been converted to a CommonJS file using a Babel-
-// compatible transform (i.e. "__esModule" has not been set), then set
-// "default" to the CommonJS "module.exports" for node compatibility.
-isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-  value: mod,
-  enumerable: true
-}) : target, mod));
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_vitest = require("vitest");
-var import_configure = require("./configure.cjs");
-var import_transformWorklets = require("./transformWorklets.cjs");
-(0, import_vitest.afterEach)(() => {
-  (0, import_configure.configureVXRNCompilerPlugin)({
-    enableReanimated: false,
-    enableNativeWorklets: false
-  });
-});
-(0, import_vitest.describe)("shouldTransformWorklets", () => {
-  (0, import_vitest.it)("returns false when enableReanimated is false", () => {
-    (0, import_configure.configureVXRNCompilerPlugin)({
-      enableReanimated: false,
-      enableNativeWorklets: true
-    });
-    (0, import_vitest.expect)((0, import_transformWorklets.shouldTransformWorklets)({
-      id: "/app/index.tsx",
-      code: `export const foo = () => { 'worklet'; return 1; }`
-    })).toBe(false);
-  });
-  (0, import_vitest.it)("returns false by default when enableNativeWorklets is false even if enableReanimated is true", () => {
-    (0, import_configure.configureVXRNCompilerPlugin)({
-      enableReanimated: true,
-      enableNativeWorklets: false
-    });
-    (0, import_vitest.expect)((0, import_transformWorklets.shouldTransformWorklets)({
-      id: "/app/index.tsx",
-      code: `export const foo = () => { 'worklet'; return 1; }`
-    })).toBe(false);
-  });
-  (0, import_vitest.it)("returns true when both enableReanimated and enableNativeWorklets are true and worklet keyword is present", () => {
-    (0, import_configure.configureVXRNCompilerPlugin)({
-      enableReanimated: true,
-      enableNativeWorklets: true
-    });
-    (0, import_vitest.expect)((0, import_transformWorklets.shouldTransformWorklets)({
-      id: "/app/index.tsx",
-      code: `export const foo = () => { 'worklet'; return 1; }`
-    })).toBe(true);
-  });
-  (0, import_vitest.it)("returns false for ignored paths such as react-native internals", () => {
-    (0, import_configure.configureVXRNCompilerPlugin)({
-      enableReanimated: true,
-      enableNativeWorklets: true
-    });
-    (0, import_vitest.expect)((0, import_transformWorklets.shouldTransformWorklets)({
-      id: "/project/node_modules/react-native/Libraries/StyleSheet/index.js",
-      code: `export const foo = () => { 'worklet'; return 1; }`
-    })).toBe(false);
-  });
-});
-(0, import_vitest.describe)("transformWorklets", () => {
-  (0, import_vitest.it)("transforms functions with worklet directive", async () => {
-    const code2 = `
-      export function animate() {
-        'worklet'
-        return 42
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/animate.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("__workletHash");
-    (0, import_vitest.expect)(result2.code).toContain("__initData");
-    (0, import_vitest.expect)(result2.code).toContain("__closure");
-    (0, import_vitest.expect)(result2.map).toBeUndefined();
-  });
-  (0, import_vitest.it)("ignores calls whose callee name collides with Object.prototype", async () => {
-    const code2 = `
-      const out = value.constructor(1)
-      const s = thing.toString()
-      const h = obj.hasOwnProperty('x')
-      const v = obj.valueOf()
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/collide.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).not.toContain("__workletHash");
-  });
-  (0, import_vitest.it)("workletizes gesture callbacks only when the receiver is a Gesture chain", async () => {
-    const gesture = await (0, import_transformWorklets.transformWorklets)("/app/gesture.ts", `const g = Gesture.Pan().onStart((e) => { scale.value = e.x }).onChange((e) => { scale.value = e.y })`, false);
-    (0, import_vitest.expect)((gesture.code.match(/__workletHash/g) ?? []).length).toBe(2);
-    const notAGesture = await (0, import_transformWorklets.transformWorklets)("/app/plain.ts", `onChange((d) => d + scrollDiff); emitter.onStart(function () { return count })`, false);
-    (0, import_vitest.expect)(notAGesture.code).not.toContain("__workletHash");
-  });
-  (0, import_vitest.it)("workletizes withCallback only on a layout animation chain", async () => {
-    const layout = await (0, import_transformWorklets.transformWorklets)("/app/layout.ts", `const a = FadeIn.duration(300).withCallback((finished) => { done.value = finished })`, false);
-    (0, import_vitest.expect)(layout.code).toContain("__workletHash");
-    const plain = await (0, import_transformWorklets.transformWorklets)("/app/plain-callback.ts", `queue.withCallback((finished) => { done.value = finished })`, false);
-    (0, import_vitest.expect)(plain.code).not.toContain("__workletHash");
-  });
-  (0, import_vitest.it)("transforms closure variables into worklet parameters", async () => {
-    const code2 = `
-      const factor = 2
-      export function multiply(x: number) {
-        'worklet'
-        return x * factor
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/multiply.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("__closure");
-    (0, import_vitest.expect)(result2.code).toContain("factor");
-  });
-  (0, import_vitest.it)("transforms an anonymous function expression worklet", async () => {
-    const code2 = `
-      register(function (e) {
-        'worklet'
-        return e.x
-      })
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/handler.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("__workletHash");
-    (0, import_vitest.expect)(result2.code).toMatch(/code: "function _worklet\(e\)/);
-    (0, import_vitest.expect)(result2.code).toContain("var _worklet = function _worklet(e)");
-  });
-  (0, import_vitest.it)("does not capture hoisted declarations used before their declaration", async () => {
-    const code2 = `
-      export function setupLoop() {
-        'worklet'
-        function nativeFlush(t: number) {
-          flushQueue(t)
-        }
-        globalThis.__native(nativeFlush)
-        function flushQueue(t: number) {
-          globalThis.__stamp = t
-        }
-        const start = () => later()
-        const later = () => start
-        return start
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/setupLoop.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toMatch(/setupLoop\.__closure = \{\s*\}/);
-    const init = result2.code.match(/code: "function setupLoop[^"]*"/);
-    (0, import_vitest.expect)(init, "serialized worklet code").toBeTruthy();
-    (0, import_vitest.expect)(init[0]).not.toContain("this.__closure");
-    (0, import_vitest.expect)(init[0]).toContain("flushQueue");
-  });
-  (0, import_vitest.it)("honors no-worklet-closure and limit-init-data-hoisting the way the worklets runtime needs", async () => {
-    const code2 = `
-      const outerModuleValue = 1
-      export function installUnpacker() {
-        'worklet'
-        'no-worklet-closure'
-        const proxy = globalThis.__proxy
-        proxy.register(outerModuleValue)
-        proxy.install(() => {
-          'worklet'
-          'limit-init-data-hoisting'
-          return 42
-        })
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/installUnpacker.ts", code2, false);
-    const outerInit = result2.code.match(/code: "function installUnpacker[^"]*"/);
-    (0, import_vitest.expect)(outerInit, "outer worklet serialized code").toBeTruthy();
-    (0, import_vitest.expect)(outerInit[0]).not.toContain("this.__closure");
-    (0, import_vitest.expect)(result2.code).toMatch(/installUnpacker\.__closure = \{\s*\}/);
-    (0, import_vitest.expect)(outerInit[0]).not.toContain("no-worklet-closure");
-    const innerVar = result2.code.match(/var (_worklet_\d+_init_data) = \{\s*code: "function _worklet/);
-    (0, import_vitest.expect)(innerVar, "inner worklet init data").toBeTruthy();
-    const emitted = result2.code.slice(result2.code.indexOf("export var installUnpacker"));
-    (0, import_vitest.expect)(emitted).toContain(`var ${innerVar[1]} = {`);
-    (0, import_vitest.expect)(result2.code.slice(0, result2.code.indexOf("export var installUnpacker"))).not.toContain(`
-var ${innerVar[1]} = {`);
-  });
-  (0, import_vitest.it)("autoworkletizes hooks like useAnimatedStyle and withTiming", async () => {
-    const code2 = `
-      export function Card() {
-        const style = useAnimatedStyle(() => {
-          return {
-            opacity: withTiming(1),
-          }
-        })
-        return <div style={style} />
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/Card.tsx", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("__workletHash");
-    (0, import_vitest.expect)(result2.code).toContain("useAnimatedStyle");
-    (0, import_vitest.expect)(result2.code).toContain("<div style={style} />");
-  });
-  (0, import_vitest.it)("generates sourcemaps when requested", async () => {
-    const code2 = `
-      export const workletFn = () => {
-        'worklet'
-        return 'ok'
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/worklet.ts", code2, true);
-    (0, import_vitest.expect)(result2.map).toBeDefined();
-    (0, import_vitest.expect)(result2.map?.mappings).toBeDefined();
-  });
-  (0, import_vitest.it)("rejects on transform errors instead of returning untransformed source", async () => {
-    await (0, import_vitest.expect)((0, import_transformWorklets.transformWorklets)("/app/broken.ts", `export const fn = () => { 'worklet'; return ;;; const = }`, false)).rejects.toThrow();
-  });
-  (0, import_vitest.it)("stamps the package runtime version into __pluginVersion to avoid runtime mismatch", async () => {
-    const testRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-worklets-ver-")));
-    const packageRoot = import_node_path.default.join(testRoot, "node_modules", "react-native-worklets");
-    import_node_fs.default.mkdirSync(packageRoot, {
-      recursive: true
-    });
-    import_node_fs.default.writeFileSync(import_node_path.default.join(packageRoot, "package.json"), JSON.stringify({
-      name: "react-native-worklets",
-      version: "0.10.1"
-    }));
-    try {
-      const result2 = await (0, import_transformWorklets.transformWorklets)(import_node_path.default.join(testRoot, "entry.ts"), `export const fn = () => { 'worklet'; return 1; }`, false, {
-        projectRoot: testRoot
-      });
-      (0, import_vitest.expect)(result2.code).toContain('__pluginVersion = "0.10.1"');
-    } finally {
-      import_node_fs.default.rmSync(testRoot, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-  (0, import_vitest.it)("correctly resolves hoisted react-native-worklets in a monorepo when child has reanimated", async () => {
-    const rootDir = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-worklets-hoist-")));
-    const appDir = import_node_path.default.join(rootDir, "apps", "mobile");
-    const hoistedWorkletsDir = import_node_path.default.join(rootDir, "node_modules", "react-native-worklets");
-    const localReanimatedDir = import_node_path.default.join(appDir, "node_modules", "react-native-reanimated");
-    import_node_fs.default.mkdirSync(hoistedWorkletsDir, {
-      recursive: true
-    });
-    import_node_fs.default.writeFileSync(import_node_path.default.join(hoistedWorkletsDir, "package.json"), JSON.stringify({
-      name: "react-native-worklets",
-      version: "0.10.1"
-    }));
-    import_node_fs.default.mkdirSync(localReanimatedDir, {
-      recursive: true
-    });
-    import_node_fs.default.writeFileSync(import_node_path.default.join(localReanimatedDir, "package.json"), JSON.stringify({
-      name: "react-native-reanimated",
-      version: "4.5.1"
-    }));
-    import_node_fs.default.writeFileSync(import_node_path.default.join(appDir, "package.json"), JSON.stringify({
-      name: "mobile"
-    }));
-    try {
-      const result2 = await (0, import_transformWorklets.transformWorklets)(import_node_path.default.join(appDir, "entry.ts"), `export function test() { 'worklet'; return 1; }`, false, {
-        projectRoot: appDir
-      });
-      (0, import_vitest.expect)(result2.code).toContain('__pluginVersion = "0.10.1"');
-    } finally {
-      import_node_fs.default.rmSync(rootDir, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-  (0, import_vitest.it)("throws an actionable error when neither worklets nor reanimated can be resolved", async () => {
-    const emptyRoot = import_node_fs.default.realpathSync(import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "vxrn-worklets-empty-")));
-    import_node_fs.default.writeFileSync(import_node_path.default.join(emptyRoot, "package.json"), JSON.stringify({
-      name: "empty-test"
-    }));
-    try {
-      await (0, import_vitest.expect)((0, import_transformWorklets.transformWorklets)(import_node_path.default.join(emptyRoot, "entry.ts"), `export function test() { 'worklet'; return 1; }`, false, {
-        projectRoot: emptyRoot
-      })).rejects.toThrow(/Unable to resolve "react-native-worklets" or "react-native-reanimated"/);
-    } finally {
-      import_node_fs.default.rmSync(emptyRoot, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-  (0, import_vitest.it)("forwards plugin options such as bundleMode and globals", async () => {
-    const code2 = `
-      export function testCustom() {
-        'worklet'
-        return customGlobalValue * 2
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/custom.ts", code2, false, {
-      globals: ["customGlobalValue"],
-      bundleMode: false
-    });
-    (0, import_vitest.expect)(result2.code).toContain("__workletHash");
-    (0, import_vitest.expect)(result2.code).toContain("__initData");
-  });
-  (0, import_vitest.it)("satisfies runtime worklet serialization, local execution, and UI-thread reconstruction", async () => {
-    const code = `
-      const multiplier = 5
-      export function scale(val: number) {
-        'worklet'
-        return val * multiplier
-      }
-    `;
-    const result = await (0, import_transformWorklets.transformWorklets)("/app/scale.ts", code, false);
-    const sandbox = {
-      global: globalThis,
-      exports: {}
-    };
-    const runner = new Function("exports", "global", result.code.replace("export var scale", "exports.scale"));
-    runner(sandbox.exports, sandbox.global);
-    const scaleFn = sandbox.exports.scale;
-    (0, import_vitest.expect)(typeof scaleFn).toBe("function");
-    (0, import_vitest.expect)(scaleFn.__workletHash).toBeDefined();
-    (0, import_vitest.expect)(typeof scaleFn.__workletHash).toBe("number");
-    (0, import_vitest.expect)(scaleFn.__pluginVersion).toBe("0.10.1");
-    (0, import_vitest.expect)(scaleFn.__closure).toEqual({
-      multiplier: 5
-    });
-    (0, import_vitest.expect)(scaleFn.__initData).toBeDefined();
-    (0, import_vitest.expect)(scaleFn.__initData.code).toContain("__closure");
-    (0, import_vitest.expect)(scaleFn(10)).toBe(50);
-    const reconstructedUIFn = eval(`(${scaleFn.__initData.code})`);
-    const uiResult = reconstructedUIFn.call({
-      __closure: scaleFn.__closure
-    }, 10);
-    (0, import_vitest.expect)(uiResult).toBe(50);
-  });
-  (0, import_vitest.it)("autoworkletizes hook callbacks with closure capture and UI-thread execution parity", async () => {
-    const code = `
-      import { useAnimatedStyle } from 'react-native-reanimated'
-      const baseOpacity = 0.8
-      export function getCardStyle() {
-        return useAnimatedStyle(() => {
-          return { opacity: baseOpacity }
-        })
-      }
-    `;
-    const result = await (0, import_transformWorklets.transformWorklets)("/app/CardStyle.ts", code, false);
-    let capturedCallback = null;
-    const sandbox = {
-      global: globalThis,
-      exports: {},
-      useAnimatedStyle: cb => {
-        capturedCallback = cb;
-        return cb;
-      }
-    };
-    const runner = new Function("exports", "global", "useAnimatedStyle", result.code.replace(/import\s+{[^}]+}\s+from\s+['"][^'"]+['"];?/, "").replace("export function getCardStyle", "exports.getCardStyle = function getCardStyle"));
-    runner(sandbox.exports, sandbox.global, sandbox.useAnimatedStyle);
-    sandbox.exports.getCardStyle();
-    (0, import_vitest.expect)(capturedCallback).toBeDefined();
-    (0, import_vitest.expect)(capturedCallback.__workletHash).toBeDefined();
-    (0, import_vitest.expect)(capturedCallback.__closure).toEqual({
-      baseOpacity: 0.8
-    });
-    const reconstructedStyleFn = eval(`(${capturedCallback.__initData.code})`);
-    const styleResult = reconstructedStyleFn.call({
-      __closure: capturedCallback.__closure
-    });
-    (0, import_vitest.expect)(styleResult).toEqual({
-      opacity: 0.8
-    });
-  });
-  (0, import_vitest.it)("compiles UI-thread worklet function to valid Hermes Bytecode (HBC)", async () => {
-    const code2 = `
-      const factor = 10
-      export function calculate(val: number) {
-        'worklet'
-        return val * factor
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/calculate.ts", code2, false);
-    const match = result2.code.match(/code:\s*"([^"]+)"/);
-    (0, import_vitest.expect)(match).toBeDefined();
-    const uiCode = JSON.parse(`"${match[1]}"`);
-    const {
-      execFileSync
-    } = await import("node:child_process");
-    const hermescDir = process.platform === "darwin" ? "osx-bin" : process.platform === "win32" ? "win64-bin" : "linux64-bin";
-    const hermescPath = import_node_path.default.resolve(__dirname, `../../../node_modules/hermes-compiler/hermesc/${hermescDir}/hermesc${process.platform === "win32" ? ".exe" : ""}`);
-    if (import_node_fs.default.existsSync(hermescPath)) {
-      const tempDir = import_node_fs.default.mkdtempSync(import_node_path.default.join(import_node_os.default.tmpdir(), "hermes-worklet-test-"));
-      const jsPath = import_node_path.default.join(tempDir, "worklet.js");
-      const hbcPath = import_node_path.default.join(tempDir, "worklet.hbc");
-      try {
-        import_node_fs.default.writeFileSync(jsPath, `(${uiCode})`);
-        execFileSync(hermescPath, ["-emit-binary", "-out", hbcPath, jsPath]);
-        (0, import_vitest.expect)(import_node_fs.default.existsSync(hbcPath)).toBe(true);
-        (0, import_vitest.expect)(import_node_fs.default.statSync(hbcPath).size).toBeGreaterThan(0);
-      } finally {
-        import_node_fs.default.rmSync(tempDir, {
-          recursive: true,
-          force: true
-        });
-      }
-    }
-  });
-  (0, import_vitest.it)("transforms multiple worklets in the same file with independent closures", async () => {
-    const code2 = `
-      const a = 10
-      const b = 20
-      export function first() {
-        'worklet'
-        return a
-      }
-      export function second() {
-        'worklet'
-        return b
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/multiple.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("first");
-    (0, import_vitest.expect)(result2.code).toContain("second");
-    (0, import_vitest.expect)(result2.code).toContain("__closure = { a: a }");
-    (0, import_vitest.expect)(result2.code).toContain("__closure = { b: b }");
-  });
-  (0, import_vitest.it)("transforms concise arrow functions with useDerivedValue", async () => {
-    const code2 = `
-      import { useDerivedValue } from 'react-native-reanimated'
-      const multiplier = 3
-      export const derived = useDerivedValue(() => multiplier * 10)
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/derived.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("__workletHash");
-    (0, import_vitest.expect)(result2.code).toContain("multiplier");
-  });
-  (0, import_vitest.it)("transforms scroll handler with object methods", async () => {
-    const code2 = `
-      import { useAnimatedScrollHandler } from 'react-native-reanimated'
-      const offset = 5
-      export const handler = useAnimatedScrollHandler({
-        onScroll(event) {
-          'worklet'
-          return event.contentOffset.y + offset
-        }
-      })
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/handler.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("onScroll:");
-    (0, import_vitest.expect)(result2.code).toContain("__closure = { offset: offset }");
-  });
-  (0, import_vitest.it)("correctly handles default and destructuring parameters in closure capture", async () => {
-    const code = `
-      const factor = 4
-      export function compute({ x, y = 1 }: { x: number; y?: number }, z = 0) {
-        'worklet'
-        return (x + y + z) * factor
-      }
-    `;
-    const result = await (0, import_transformWorklets.transformWorklets)("/app/destructure.ts", code, false);
-    (0, import_vitest.expect)(result.code).toContain("__closure = { factor: factor }");
-    const sandbox = {
-      global: globalThis,
-      exports: {}
-    };
-    const runner = new Function("exports", "global", result.code.replace("export var compute", "exports.compute"));
-    runner(sandbox.exports, sandbox.global);
-    const computeFn = sandbox.exports.compute;
-    (0, import_vitest.expect)(computeFn({
-      x: 2
-    })).toBe(12);
-    const reconstructed = eval(`(${computeFn.__initData.code})`);
-    const uiRes = reconstructed.call({
-      __closure: computeFn.__closure
-    }, {
-      x: 2,
-      y: 3
-    }, 5);
-    (0, import_vitest.expect)(uiRes).toBe(40);
-  });
-  (0, import_vitest.it)("operates with 100% elimination of SWC (zero swc dependencies in transformWorklets)", async () => {
-    const fs2 = await import("node:fs");
-    const transformWorkletsSource = fs2.readFileSync(import_node_path.default.resolve(__dirname, "transformWorklets.ts"), "utf-8");
-    (0, import_vitest.expect)(transformWorkletsSource).not.toContain("@swc/core");
-    (0, import_vitest.expect)(transformWorkletsSource).not.toContain("@react-native-swc/worklets-plugin");
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/zeroSwc.ts", `export function zeroSwc() { 'worklet'; return 999; }`, false);
-    (0, import_vitest.expect)(result2.code).toContain("__workletHash");
-    (0, import_vitest.expect)(result2.code).toContain("__pluginVersion");
-    (0, import_vitest.expect)(result2.code).toContain("999");
-  });
-  (0, import_vitest.it)("correctly handles lexical block scope shadowing without losing outer bindings", async () => {
-    const code = `
-      const x = 7
-      export function f() {
-        'worklet'
-        {
-          const x = 1
-        }
-        return x
-      }
-    `;
-    const result = await (0, import_transformWorklets.transformWorklets)("/app/scope-shadow.ts", code, false);
-    (0, import_vitest.expect)(result.code).toContain("__closure = { x: x }");
-    const sandbox = {
-      global: globalThis,
-      exports: {}
-    };
-    const runner = new Function("exports", "global", result.code.replace("export var f", "exports.f"));
-    runner(sandbox.exports, sandbox.global);
-    const f = sandbox.exports.f;
-    (0, import_vitest.expect)(f()).toBe(7);
-    const reconstructed = eval(`(${f.__initData.code})`);
-    const uiRes = reconstructed.call({
-      __closure: f.__closure
-    });
-    (0, import_vitest.expect)(uiRes).toBe(7);
-  });
-  (0, import_vitest.it)("transforms nested worklets with bottom-up composition", async () => {
-    const code2 = `
-      export function outer() {
-        'worklet'
-        function inner() {
-          'worklet'
-          return 1
-        }
-        return inner()
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/nested.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("export var outer");
-    (0, import_vitest.expect)(result2.code).toContain("inner.__workletHash");
-    (0, import_vitest.expect)(result2.code).toContain("outer.__workletHash");
-    const sandbox2 = {
-      global: globalThis,
-      exports: {}
-    };
-    const runner2 = new Function("exports", "global", result2.code.replace("export var outer", "exports.outer"));
-    runner2(sandbox2.exports, sandbox2.global);
-    const outerFn = sandbox2.exports.outer;
-    (0, import_vitest.expect)(outerFn()).toBe(1);
-  });
-  (0, import_vitest.it)("transforms modules with >50 sibling worklets without truncation", async () => {
-    const fnCount = 60;
-    const code2 = Array.from({
-      length: fnCount
-    }, (_, i) => `export function f${i}() { 'worklet'; return ${i}; }`).join("\n");
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/many.ts", code2, false);
-    for (let i = 0; i < fnCount; i++) {
-      (0, import_vitest.expect)(result2.code).toContain(`export var f${i} =`);
-      (0, import_vitest.expect)(result2.code).toContain(`f${i}.__workletHash`);
-    }
-    const sandbox2 = {
-      global: globalThis,
-      exports: {}
-    };
-    const runner2 = new Function("exports", "global", result2.code.replace(/export var /g, "exports."));
-    runner2(sandbox2.exports, sandbox2.global);
-    (0, import_vitest.expect)(sandbox2.exports.f0()).toBe(0);
-    (0, import_vitest.expect)(sandbox2.exports.f50()).toBe(50);
-    (0, import_vitest.expect)(sandbox2.exports.f59()).toBe(59);
-  });
-  (0, import_vitest.it)("transforms deeply nested worklets (3 levels) bottom-up", async () => {
-    const code2 = `
-      export function level1() {
-        'worklet';
-        function level2() {
-          'worklet';
-          function level3() {
-            'worklet';
-            return 42;
-          }
-          return level3();
-        }
-        return level2();
-      }
-    `;
-    const result2 = await (0, import_transformWorklets.transformWorklets)("/app/deep.ts", code2, false);
-    (0, import_vitest.expect)(result2.code).toContain("level3.__workletHash");
-    (0, import_vitest.expect)(result2.code).toContain("level2.__workletHash");
-    (0, import_vitest.expect)(result2.code).toContain("level1.__workletHash");
-    const sandbox2 = {
-      global: globalThis,
-      exports: {}
-    };
-    const runner2 = new Function("exports", "global", result2.code.replace("export var level1", "exports.level1"));
-    runner2(sandbox2.exports, sandbox2.global);
-    (0, import_vitest.expect)(sandbox2.exports.level1()).toBe(42);
-  });
-});
-(0, import_vitest.describe)("worklet detection gate", () => {
-  (0, import_vitest.it)("accepts files whose only worklets come from gesture callbacks", () => {
-    (0, import_configure.configureVXRNCompilerPlugin)({
-      enableReanimated: true,
-      enableNativeWorklets: true
-    });
-    const code2 = `
-      const tap = Gesture.Tap().onBegin((e) => { setState(e) }).onTouchesMove((e) => {}).onEnd(() => {})
-    `;
-    (0, import_vitest.expect)((0, import_transformWorklets.shouldTransformWorklets)({
-      id: "/app/gesture.native.js",
-      code: code2
-    })).toBe(true);
-  });
-});