vxrn 1.25.8 → 1.25.9

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

@@ -1,10 +1,13 @@
-import { mkdtemp, rm, writeFile } from "fs/promises";
+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 { rolldown } from "rolldown";
 import { dev } from "rolldown/experimental";
 import { describe, expect, it } from "vitest";
-import { getHermesSWCIncludes, getHmrRuntimeSource, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.native.js";
+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";
 function _instanceof(left, right) {
   if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) return !!right[Symbol.hasInstance](left);else return left instanceof right;
 }
@@ -13,6 +16,58 @@ function _type_of(obj) {
 
   return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
+var nativeTransformProbe = `
+export const transformProbe = () => {
+  'worklet'
+  return 'transformed'
+}
+`;
+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-"));
+  var packageRoot = join(testRoot, "node_modules/react-native-worklets");
+  await mkdir(packageRoot, {
+    recursive: true
+  });
+  await writeFile(join(packageRoot, "package.json"), JSON.stringify({
+    name: "react-native-worklets"
+  }));
+  await writeFile(join(packageRoot, "plugin.js"), throwOnTransform ? `module.exports = () => ({
+      visitor: {
+        Program() {
+          throw new Error('NATIVE_TRANSFORM_NEGATIVE_CONTROL')
+        }
+      }
+    })` : `module.exports = () => ({ visitor: {} })`);
+  await writeFile(join(testRoot, "entry.ts"), nativeTransformProbe);
+  return testRoot;
+}
+describe("native prelude", function () {
+  it("does not advertise a host event API that cannot remove listeners", function () {
+    var context = {
+      addEventListener() {}
+    };
+    runInNewContext(getNativePrelude({
+      dev: false,
+      platform: "ios"
+    }), context);
+    expect(Reflect.get(context, "addEventListener")).toBeUndefined();
+  });
+  it("preserves a complete host event API", function () {
+    var addEventListener = function () {};
+    var removeEventListener = function () {};
+    var context = {
+      addEventListener,
+      removeEventListener
+    };
+    runInNewContext(getNativePrelude({
+      dev: false,
+      platform: "ios"
+    }), context);
+    expect(context.addEventListener).toBe(addEventListener);
+    expect(context.removeEventListener).toBe(removeEventListener);
+  });
+});
 describe("native Rolldown HMR runtime", function () {
   it("registers a Rolldown 1.2 client and applies a self-accepted patch", {
     timeout: 3e4
@@ -84,7 +139,8 @@ if (import.meta.hot) {
         return item.clientId === runtime.clientId && item.update.type === "Patch";
       })) === null || _result_updates_find === void 0 ? void 0 : _result_updates_find.update;
       expect(patch).toBeTruthy();
-      expect(runtime.applyHmrUpdate(patch.code, patch.changedIds, patch.seq)).toBe(true);
+      var applyHmrUpdate = Reflect.get(runtime, "applyHmrUpdate");
+      expect(Reflect.apply(applyHmrUpdate, runtime, [patch.code, patch.changedIds, patch.seq])).toBe(true);
       expect(globalThis.__vxrnHmrBody).toBe("v2");
       expect(globalThis.__vxrnHmrAccepted).toBe("v2");
     } finally {
@@ -98,6 +154,141 @@ if (import.meta.hot) {
       delete globalThis.__vxrnHmrAccepted;
     }
   });
+  it("propagates a non-component update to a React Refresh boundary", {
+    timeout: 3e4
+  }, async function () {
+    var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-refresh-boundary-"));
+    var entry = join(testRoot, "entry.js");
+    var leaf = join(testRoot, "leaf.js");
+    await writeFile(entry, `
+import { value } from './leaf.js'
+globalThis.__vxrnRefreshBoundaryValue = value
+export function App() {}
+if (import.meta.hot) {
+  import.meta.hot.acceptReactRefresh(() => {
+    globalThis.__vxrnRefreshBoundaryAccepted = true
+  })
+}
+`);
+    await writeFile(leaf, `export const value = 'v1'`);
+    var resolveInitialOutput;
+    var initialOutput = new Promise(function (resolve) {
+      resolveInitialOutput = resolve;
+    });
+    var resolveHmrUpdate;
+    var hmrUpdate = new Promise(function (resolve) {
+      resolveHmrUpdate = resolve;
+    });
+    var registeredClientId;
+    var engine = await dev({
+      cwd: testRoot,
+      input: entry,
+      experimental: {
+        devMode: {
+          implement: getHmrRuntimeSource()
+        }
+      }
+    }, {
+      format: "esm"
+    }, {
+      onOutput(result2) {
+        resolveInitialOutput(result2);
+      },
+      onHmrUpdates(result2) {
+        if (!_instanceof(result2, Error) && result2.updates.some(function (item) {
+          return item.clientId === registeredClientId && item.update.type === "Patch";
+        })) resolveHmrUpdate(result2);
+      }
+    });
+    var previousRefreshRuntime = Reflect.get(globalThis, "__ReactRefresh");
+    Reflect.set(globalThis, "__ReactRefresh", {
+      isLikelyComponentType(value) {
+        return typeof value === "function";
+      }
+    });
+    try {
+      var _result_updates_find;
+      await engine.run();
+      var initial = await initialOutput;
+      if (_instanceof(initial, Error)) throw initial;
+      var chunk = initial.output.find(function (item) {
+        return item.type === "chunk" && item.isEntry;
+      });
+      expect(chunk).toBeTruthy();
+      Reflect.deleteProperty(globalThis, "__rolldown_runtime__");
+      await import(`data:text/javascript;base64,${Buffer.from(chunk.code).toString("base64")}`);
+      var runtime = Reflect.get(globalThis, "__rolldown_runtime__");
+      registeredClientId = runtime.clientId;
+      await engine.registerClient(runtime.clientId);
+      await writeFile(leaf, `export const value = 'v2'`);
+      var patch = (_result_updates_find = (await Promise.race([hmrUpdate, new Promise(function (_, reject) {
+        return setTimeout(function () {
+          return reject(/* @__PURE__ */new Error("timed out waiting for HMR patch"));
+        }, 1e4);
+      })])).updates.find(function (item) {
+        return item.clientId === runtime.clientId && item.update.type === "Patch";
+      })) === null || _result_updates_find === void 0 ? void 0 : _result_updates_find.update;
+      expect(patch).toBeTruthy();
+      var applyHmrUpdate = Reflect.get(runtime, "applyHmrUpdate");
+      expect(Reflect.apply(applyHmrUpdate, runtime, [patch.code, patch.changedIds, patch.seq])).toBe(true);
+      expect(Reflect.get(globalThis, "__vxrnRefreshBoundaryValue")).toBe("v2");
+      expect(Reflect.get(globalThis, "__vxrnRefreshBoundaryAccepted")).toBe(true);
+    } finally {
+      await engine.close();
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+      Reflect.deleteProperty(globalThis, "__rolldown_runtime__");
+      Reflect.deleteProperty(globalThis, "__vxrnRefreshBoundaryValue");
+      Reflect.deleteProperty(globalThis, "__vxrnRefreshBoundaryAccepted");
+      if (previousRefreshRuntime === void 0) Reflect.deleteProperty(globalThis, "__ReactRefresh");else Reflect.set(globalThis, "__ReactRefresh", previousRefreshRuntime);
+    }
+  });
+});
+describe("native production import.meta lowering", function () {
+  it("emits a Hermes-compatible bundle for guarded import.meta.env reads", async function () {
+    var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-import-meta-"));
+    await writeFile(join(testRoot, "entry.js"), `globalThis.__vxrnNativeImportMetaProbe = typeof import.meta !== 'undefined' && import.meta.env.DEV`);
+    try {
+      var result = await buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.js"
+      });
+      expect(result.code).not.toContain("typeof import.meta");
+      var context = {
+        globalThis: {},
+        process: {
+          env: {}
+        }
+      };
+      runInNewContext(result.code, context);
+      expect(Reflect.get(context.globalThis, "__vxrnNativeImportMetaProbe")).toBe(false);
+    } finally {
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
+describe("native animated guard transform", function () {
+  it("preserves line count and returns a composable source map", async function () {
+    var plugin = nativeAnimatedGuardPlugin();
+    if (typeof plugin.transform !== "function") throw new Error("native animated guard transform hook is not callable");
+    var source = ["function call(methodName) {", "  const method = nullthrows(NativeAnimatedModule)[methodName];", "  method();", "}"].join("\n");
+    var result = await Reflect.apply(plugin.transform, void 0, [source, "/project/node_modules/react-native/src/private/animated/NativeAnimatedHelper.js"]);
+    expect(result.code.split("\n")).toHaveLength(source.split("\n").length);
+    expect(result.code).toContain("if (typeof method !== 'function') return");
+    expect(result.map).toEqual({
+      version: 3,
+      sources: ["/project/node_modules/react-native/src/private/animated/NativeAnimatedHelper.js"],
+      sourcesContent: [source],
+      names: [],
+      mappings: "AAAA;AACA;AACA;AACA"
+    });
+  });
 });
 var root = "/tmp/vxrn-native-env-define-test-nonexistent";
 describe("getNativeTransformConfig platform env defines", function () {
@@ -123,6 +314,21 @@ describe("getNativeTransformConfig platform env defines", function () {
     for (var _i1 = 0, _iter1 = [true, false]; _i1 < _iter1.length; _i1++) _loop2(_i1, _iter1);
   };
   for (var _i = 0, _iter = ["ios", "android"]; _i < _iter.length; _i++) _loop(_i, _iter);
+  it("inlines EXPO_PUBLIC values supplied by the native build environment", function () {
+    var key = "EXPO_PUBLIC_VXRN_NATIVE_ENV_PROBE";
+    var previous = process.env[key];
+    process.env[key] = "native-env-value";
+    try {
+      var {
+        define
+      } = getNativeTransformConfig("ios", false, root);
+      expect(define[`process.env.${key}`]).toBe("\"native-env-value\"");
+      expect(define[`import.meta.env.${key}`]).toBe("\"native-env-value\"");
+      expect(JSON.parse(define["import.meta.env"])[key]).toBe("native-env-value");
+    } finally {
+      if (previous === void 0) delete process.env[key];else process.env[key] = previous;
+    }
+  });
 });
 describe("wrapNativeBundleModuleScope", function () {
   var RUNTIME_MARKER = "//#region \\0rolldown/runtime.js";
@@ -147,15 +353,51 @@ globalThis.__rolldown_runtime__ = {};
   });
 });
 describe("getHermesSWCIncludes", function () {
-  var CLASS_SET = ["transform-classes", "transform-parameters", "transform-class-properties", "transform-class-static-block", "transform-private-methods", "transform-private-property-in-object"];
+  var CLASS_SET = ["transform-classes", "transform-parameters", "transform-block-scoping", "transform-class-properties", "transform-class-static-block", "transform-private-methods", "transform-private-property-in-object"];
   it("always includes the full Hermes class-transform set (dev and prod)", function () {
     expect(getHermesSWCIncludes(true)).toEqual(expect.arrayContaining(CLASS_SET));
     expect(getHermesSWCIncludes(false)).toEqual(expect.arrayContaining(CLASS_SET));
   });
-  it("adds transform-async-to-generator only in production", function () {
-    expect(getHermesSWCIncludes(true)).not.toContain("transform-async-to-generator");
+  it("adds transform-async-to-generator in development and production", function () {
+    expect(getHermesSWCIncludes(true)).toContain("transform-async-to-generator");
     expect(getHermesSWCIncludes(false)).toContain("transform-async-to-generator");
   });
+  it("lowers async generators for the Hermes development interpreter", 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, ["export async function* values() { yield await Promise.resolve(1) }", "/project/async-generator.ts"]);
+    expect(result.code).not.toContain("async function*");
+    expect(result.code).not.toContain("async function *");
+  });
+  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");
+    var result = await Reflect.apply(plugin.transform, void 0, [`
+const installedGroups = new WeakMap()
+function install(inst, methods) {
+  const proto = Object.getPrototypeOf(inst)
+  for (const key in methods) {
+    const fn = methods[key]
+    Object.defineProperty(proto, key, {
+      get() { return fn.bind(this) }
+    })
+  }
+}
+function Schema() {
+  install(this, {
+    nullish() { return 'nullish' },
+    apply(fn) { return fn(this) }
+  })
+}
+globalThis.__vxrnBlockScopeProbe = new Schema().nullish()
+`, "/project/block-scope-loop.ts"]);
+    try {
+      new Function(result.code)();
+      expect(Reflect.get(globalThis, "__vxrnBlockScopeProbe")).toBe("nullish");
+    } finally {
+      Reflect.deleteProperty(globalThis, "__vxrnBlockScopeProbe");
+    }
+  });
   it("bundles lowered classes whose constructors use default and rest parameters", async function () {
     var testRoot = await mkdtemp(join(tmpdir(), "vxrn-hermes-parameters-"));
     var entry = join(testRoot, "entry.js");
@@ -232,9 +474,320 @@ describe("vxrnCompilerPlugin React Refresh registration", function () {
       expect(code).toContain("var __vxrnRefreshReg = globalThis.$RefreshReg$");
       expect(code).toContain("__vxrnRefreshReg(");
       expect(code).toContain("\"$RefreshReg$(\"");
+      expect(code).toContain("import.meta.hot.acceptReactRefresh(");
     } finally {
       process.env.NODE_ENV = previousNodeEnv;
     }
   });
 });
+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");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true
+    });
+    try {
+      var plugin = vxrnCompilerPlugin("ios", dev2, testRoot);
+      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 {
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false
+      });
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  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");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true
+    });
+    var resolveOutput;
+    var output = new Promise(function (resolve) {
+      resolveOutput = resolve;
+    });
+    var engine = await dev({
+      cwd: testRoot,
+      input: join(testRoot, "entry.ts"),
+      plugins: [vxrnCompilerPlugin("ios", true, testRoot)]
+    }, {
+      format: "esm"
+    }, {
+      onOutput: resolveOutput
+    });
+    try {
+      await engine.run();
+      var result = await output;
+      expect(result).toBeInstanceOf(Error);
+      expect(String(result)).toContain("NATIVE_TRANSFORM_NEGATIVE_CONTROL");
+    } finally {
+      await engine.close();
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false
+      });
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  it("emits no production bundle when the required compiler transform fails", async function () {
+    var testRoot = await createWorkletsProject();
+    var compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true
+    });
+    try {
+      await expect(buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.ts"
+      })).rejects.toThrow("NATIVE_TRANSFORM_NEGATIVE_CONTROL");
+    } finally {
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false
+      });
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  it("rejects Hermes compatibility transform errors instead of returning source", async function () {
+    var plugin = hermesCompatSWCPlugin(true);
+    if (typeof plugin.transform !== "function") throw new Error("Hermes compatibility transform hook is not callable");
+    await expect(Reflect.apply(plugin.transform, void 0, ["class TransformProbe { value = ; }", "/project/TransformProbe.ts"])).rejects.toBeTruthy();
+  });
+  it("returns maps for every required production transform", async function () {
+    var testRoot = await createWorkletsProject(false);
+    var compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true
+    });
+    try {
+      var compilerPlugin = vxrnCompilerPlugin("ios", false, testRoot, true);
+      if (typeof compilerPlugin.transform !== "function") throw new Error("vxrn compiler transform hook is not callable");
+      expect((await Reflect.apply(compilerPlugin.transform, void 0, [nativeTransformProbe, join(testRoot, "entry.ts")])).map).toBeTruthy();
+      var hermesPlugin = hermesCompatSWCPlugin(false, true);
+      if (typeof hermesPlugin.transform !== "function") throw new Error("Hermes compatibility transform hook is not callable");
+      expect((await Reflect.apply(hermesPlugin.transform, void 0, ["export class TransformProbe { value = 1 }", join(testRoot, "TransformProbe.ts")])).map).toBeTruthy();
+    } finally {
+      compiler.configureVXRNCompilerPlugin({
+        enableReanimated: false
+      });
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
+describe("native production assets", function () {
+  it("registers scale siblings and keeps monorepo assets inside assetsDest", async function () {
+    var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-assets-"));
+    var appRoot = join(testRoot, "workspace/apps/native-app");
+    var appAssets = join(appRoot, "assets");
+    var packageAssets = join(testRoot, "workspace/node_modules/example/assets");
+    var assetsDest = join(testRoot, "output");
+    await mkdir(appAssets, {
+      recursive: true
+    });
+    await mkdir(packageAssets, {
+      recursive: true
+    });
+    await writeFile(join(appAssets, "icon.png"), "icon-1x");
+    await writeFile(join(appAssets, "icon@2x.png"), "icon-2x");
+    await writeFile(join(appAssets, "icon@3x.png"), "icon-3x");
+    await writeFile(join(packageAssets, "back.png"), "back-1x");
+    await writeFile(join(packageAssets, "back@2x.png"), "back-2x");
+    await writeFile(join(appRoot, "entry.js"), `
+import icon from './assets/icon.png'
+import back from '../../node_modules/example/assets/back.png'
+globalThis.__nativeAssetProbe = [icon, back]
+`);
+    try {
+      var _registry_resolve;
+      var assetData = await getNativeAssetData(join(appAssets, "icon.png"), appRoot, "ios");
+      expect(assetData.scales).toEqual([1, 2, 3]);
+      expect(assetData.files.map(function (file2) {
+        return file2.slice(appAssets.length + 1);
+      })).toEqual(["icon.png", "icon@2x.png", "icon@3x.png"]);
+      expect(assetData.hash).not.toBe("");
+      var registry = createNativeDevAssetRegistry();
+      registry.register(assetData);
+      expect((_registry_resolve = registry.resolve("/assets/assets/icon@2x.png", assetData.hash)) === null || _registry_resolve === void 0 ? void 0 : _registry_resolve.filePath).toBe(join(appAssets, "icon@2x.png"));
+      expect(registry.resolve("/assets/assets/icon.png", "stale-content-hash")).toBeUndefined();
+      expect(registry.resolve("/assets/../../package.json", assetData.hash)).toBeUndefined();
+      expect((await buildNativeBundle({
+        root: appRoot,
+        platform: "ios",
+        entryFile: "entry.js",
+        assetsDest
+      })).code).toMatch(/"scales":\s*\[\s*1,\s*2,\s*3\s*\]/);
+      for (var _i = 0, _iter = ["icon.png", "icon@2x.png", "icon@3x.png"]; _i < _iter.length; _i++) {
+        var file = _iter[_i];
+        expect(existsSync(join(assetsDest, "assets/assets", file))).toBe(true);
+      }
+      for (var _i1 = 0, _iter1 = ["back.png", "back@2x.png"]; _i1 < _iter1.length; _i1++) {
+        var file1 = _iter1[_i1];
+        expect(existsSync(join(assetsDest, "assets/_/_/node_modules/example/assets", file1))).toBe(true);
+      }
+      expect(existsSync(join(testRoot, "node_modules/example/assets/back.png"))).toBe(false);
+    } finally {
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
+describe("native conditional exports", function () {
+  it("uses the require condition for CommonJS calls", async function () {
+    var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-conditions-"));
+    var packageRoot = join(testRoot, "node_modules/conditional-helper");
+    await mkdir(packageRoot, {
+      recursive: true
+    });
+    await writeFile(join(packageRoot, "package.json"), JSON.stringify({
+      name: "conditional-helper",
+      exports: {
+        ".": {
+          import: "./esm.js",
+          require: "./cjs.cjs"
+        }
+      },
+      type: "module"
+    }));
+    await writeFile(join(packageRoot, "esm.js"), `export default function helper() { return 'import' }`);
+    await writeFile(join(packageRoot, "cjs.cjs"), `module.exports = function helper() { return 'require' }`);
+    await writeFile(join(testRoot, "entry.cjs"), `
+const helper = require('conditional-helper')
+globalThis.__vxrnConditionalExportProbe = helper()
+`);
+    try {
+      var result = await buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.cjs",
+        dev: true
+      });
+      var context = {
+        clearTimeout,
+        console,
+        process: {
+          env: {}
+        },
+        setTimeout
+      };
+      runInNewContext(result.code, context);
+      expect(Reflect.get(context, "__vxrnConditionalExportProbe")).toBe("require");
+    } finally {
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  it("unwraps the default export of Babel CommonJS modules in dev output", {
+    timeout: 3e4
+  }, async function () {
+    var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-cjs-default-"));
+    var packageRoot = join(testRoot, "node_modules/default-export-helper");
+    await mkdir(packageRoot, {
+      recursive: true
+    });
+    await writeFile(join(packageRoot, "package.json"), JSON.stringify({
+      name: "default-export-helper",
+      main: "./index.js"
+    }));
+    await writeFile(join(packageRoot, "index.js"), `Object.defineProperty(exports, '__esModule', { value: true }); exports.default = function Component() {}`);
+    await writeFile(join(testRoot, "entry.js"), `import Component from 'default-export-helper'; globalThis.__vxrnCjsDefaultProbe = typeof Component`);
+    var resolveOutput;
+    var output = new Promise(function (resolve) {
+      resolveOutput = resolve;
+    });
+    var engine = await dev({
+      cwd: testRoot,
+      input: join(testRoot, "entry.js"),
+      experimental: {
+        devMode: {
+          implement: getHmrRuntimeSource()
+        }
+      }
+    }, {
+      format: "esm",
+      codeSplitting: false,
+      strictExecutionOrder: true
+    }, {
+      onOutput: resolveOutput
+    });
+    try {
+      await engine.run();
+      var result = await output;
+      if (_instanceof(result, Error)) throw result;
+      var chunk = result.output.find(function (item) {
+        return item.type === "chunk" && item.isEntry;
+      });
+      if (!chunk || chunk.type !== "chunk") throw new Error("Rolldown did not emit a native dev entry chunk");
+      var nodeModeCode = chunk.code.replace(/(\b__toESM(?:\$\d+)?\(\s*require[\w$]*\(\)\s*)\)/, "$1, 1)");
+      expect(nodeModeCode).not.toBe(chunk.code);
+      Reflect.deleteProperty(globalThis, "__rolldown_runtime__");
+      await import(`data:text/javascript;base64,${Buffer.from(nodeModeCode).toString("base64")}`);
+      expect(Reflect.get(globalThis, "__vxrnCjsDefaultProbe")).toBe("object");
+      Reflect.deleteProperty(globalThis, "__rolldown_runtime__");
+      Reflect.deleteProperty(globalThis, "__vxrnCjsDefaultProbe");
+      var normalized = normalizeNativeCommonJSInterop(nodeModeCode);
+      await import(`data:text/javascript;base64,${Buffer.from(normalized).toString("base64")}`);
+      expect(Reflect.get(globalThis, "__vxrnCjsDefaultProbe")).toBe("function");
+    } finally {
+      await engine.close();
+      Reflect.deleteProperty(globalThis, "__rolldown_runtime__");
+      Reflect.deleteProperty(globalThis, "__vxrnCjsDefaultProbe");
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+  it("unwraps the default export of Babel CommonJS modules in production output", async function () {
+    var testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-prod-cjs-default-"));
+    var packageRoot = join(testRoot, "node_modules/default-export-helper");
+    await mkdir(packageRoot, {
+      recursive: true
+    });
+    await writeFile(join(packageRoot, "package.json"), JSON.stringify({
+      name: "default-export-helper",
+      main: "./index.js"
+    }));
+    await writeFile(join(packageRoot, "index.js"), `Object.defineProperty(exports, '__esModule', { value: true }); exports.default = function Component() {}`);
+    await writeFile(join(testRoot, "entry.js"), `import Component from 'default-export-helper'; globalThis.__vxrnProdCjsDefaultProbe = typeof Component`);
+    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, "__vxrnProdCjsDefaultProbe")).toBe("function");
+    } finally {
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
 //# sourceMappingURL=createNativeDevEngine.test.native.js.map