vxrn 1.25.8 → 1.25.9

package/dist/utils/createNativeDevEngine.test.mjs

@@ -1,10 +1,64 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { runInNewContext } from "node:vm";
 import { rolldown } from "rolldown";
 import { dev } from "rolldown/experimental";
 import { describe, expect, it } from "vitest";
-import { getHermesSWCIncludes, getHmrRuntimeSource, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.mjs";
+import { getNativePrelude } from "../runtime/native-prelude.mjs";
+import { buildNativeBundle, createNativeDevAssetRegistry, getHermesSWCIncludes, getHmrRuntimeSource, getNativeAssetData, getNativeTransformConfig, hermesCompatSWCPlugin, hmrClientNoopPlugin, nativeAnimatedGuardPlugin, normalizeNativeCommonJSInterop, vxrnCompilerPlugin, wrapNativeBundleModuleScope } from "./createNativeDevEngine.mjs";
+const nativeTransformProbe = `
+export const transformProbe = () => {
+  'worklet'
+  return 'transformed'
+}
+`;
+async function createWorkletsProject(throwOnTransform = true) {
+  const testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-transform-failure-"));
+  const 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", () => {
+  it("does not advertise a host event API that cannot remove listeners", () => {
+    const context = {
+      addEventListener() {}
+    };
+    runInNewContext(getNativePrelude({
+      dev: false,
+      platform: "ios"
+    }), context);
+    expect(Reflect.get(context, "addEventListener")).toBeUndefined();
+  });
+  it("preserves a complete host event API", () => {
+    const addEventListener = () => {};
+    const removeEventListener = () => {};
+    const 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", () => {
   it("registers a Rolldown 1.2 client and applies a self-accepted patch", {
     timeout: 3e4
@@ -63,7 +117,8 @@ if (import.meta.hot) {
       await writeFile(entry, source("v2"));
       const patch = (await Promise.race([hmrUpdate, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */new Error("timed out waiting for HMR patch")), 1e4))])).updates.find(item => item.clientId === runtime.clientId && item.update.type === "Patch")?.update;
       expect(patch).toBeTruthy();
-      expect(runtime.applyHmrUpdate(patch.code, patch.changedIds, patch.seq)).toBe(true);
+      const 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 {
@@ -77,6 +132,130 @@ if (import.meta.hot) {
       delete globalThis.__vxrnHmrAccepted;
     }
   });
+  it("propagates a non-component update to a React Refresh boundary", {
+    timeout: 3e4
+  }, async () => {
+    const testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-refresh-boundary-"));
+    const entry = join(testRoot, "entry.js");
+    const 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'`);
+    let resolveInitialOutput;
+    const initialOutput = new Promise(resolve => {
+      resolveInitialOutput = resolve;
+    });
+    let resolveHmrUpdate;
+    const hmrUpdate = new Promise(resolve => {
+      resolveHmrUpdate = resolve;
+    });
+    let registeredClientId;
+    const engine = await dev({
+      cwd: testRoot,
+      input: entry,
+      experimental: {
+        devMode: {
+          implement: getHmrRuntimeSource()
+        }
+      }
+    }, {
+      format: "esm"
+    }, {
+      onOutput(result) {
+        resolveInitialOutput(result);
+      },
+      onHmrUpdates(result) {
+        if (!(result instanceof Error) && result.updates.some(item => item.clientId === registeredClientId && item.update.type === "Patch")) resolveHmrUpdate(result);
+      }
+    });
+    const previousRefreshRuntime = Reflect.get(globalThis, "__ReactRefresh");
+    Reflect.set(globalThis, "__ReactRefresh", {
+      isLikelyComponentType(value) {
+        return typeof value === "function";
+      }
+    });
+    try {
+      await engine.run();
+      const initial = await initialOutput;
+      if (initial instanceof Error) throw initial;
+      const chunk = initial.output.find(item => 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")}`);
+      const runtime = Reflect.get(globalThis, "__rolldown_runtime__");
+      registeredClientId = runtime.clientId;
+      await engine.registerClient(runtime.clientId);
+      await writeFile(leaf, `export const value = 'v2'`);
+      const patch = (await Promise.race([hmrUpdate, new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */new Error("timed out waiting for HMR patch")), 1e4))])).updates.find(item => item.clientId === runtime.clientId && item.update.type === "Patch")?.update;
+      expect(patch).toBeTruthy();
+      const 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", () => {
+  it("emits a Hermes-compatible bundle for guarded import.meta.env reads", async () => {
+    const 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 {
+      const result = await buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.js"
+      });
+      expect(result.code).not.toContain("typeof import.meta");
+      const 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", () => {
+  it("preserves line count and returns a composable source map", async () => {
+    const plugin = nativeAnimatedGuardPlugin();
+    if (typeof plugin.transform !== "function") throw new Error("native animated guard transform hook is not callable");
+    const source = ["function call(methodName) {", "  const method = nullthrows(NativeAnimatedModule)[methodName];", "  method();", "}"].join("\n");
+    const 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"
+    });
+  });
 });
 const root = "/tmp/vxrn-native-env-define-test-nonexistent";
 describe("getNativeTransformConfig platform env defines", () => {
@@ -94,6 +273,21 @@ describe("getNativeTransformConfig platform env defines", () => {
     expect(envObject.TAMAGUI_TARGET).toBe("native");
     expect(envObject.TAMAGUI_ENVIRONMENT).toBe(platform);
   });
+  it("inlines EXPO_PUBLIC values supplied by the native build environment", () => {
+    const key = "EXPO_PUBLIC_VXRN_NATIVE_ENV_PROBE";
+    const previous = process.env[key];
+    process.env[key] = "native-env-value";
+    try {
+      const {
+        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", () => {
   const RUNTIME_MARKER = "//#region \\0rolldown/runtime.js";
@@ -116,15 +310,51 @@ globalThis.__rolldown_runtime__ = {};
   });
 });
 describe("getHermesSWCIncludes", () => {
-  const CLASS_SET = ["transform-classes", "transform-parameters", "transform-class-properties", "transform-class-static-block", "transform-private-methods", "transform-private-property-in-object"];
+  const 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)", () => {
     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", () => {
-    expect(getHermesSWCIncludes(true)).not.toContain("transform-async-to-generator");
+  it("adds transform-async-to-generator in development and production", () => {
+    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 () => {
+    const plugin = hermesCompatSWCPlugin(true);
+    if (typeof plugin.transform !== "function") throw new Error("Hermes compatibility transform hook is not callable");
+    const result = await Reflect.apply(plugin.transform, void 0, ["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 () => {
+    const plugin = hermesCompatSWCPlugin(true);
+    if (typeof plugin.transform !== "function") throw new Error("Hermes compatibility transform hook is not callable");
+    const result = await Reflect.apply(plugin.transform, void 0, [`
+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 () => {
     const testRoot = await mkdtemp(join(tmpdir(), "vxrn-hermes-parameters-"));
     const entry = join(testRoot, "entry.js");
@@ -196,9 +426,309 @@ describe("vxrnCompilerPlugin React Refresh registration", () => {
       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", () => {
+  it.each([true, false])("rejects valid worklet source when its required compiler transform fails (dev=%s)", async dev2 => {
+    const testRoot = await createWorkletsProject();
+    const compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true
+    });
+    try {
+      const 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 () => {
+    const testRoot = await createWorkletsProject();
+    const compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true
+    });
+    let resolveOutput;
+    const output = new Promise(resolve => {
+      resolveOutput = resolve;
+    });
+    const engine = await dev({
+      cwd: testRoot,
+      input: join(testRoot, "entry.ts"),
+      plugins: [vxrnCompilerPlugin("ios", true, testRoot)]
+    }, {
+      format: "esm"
+    }, {
+      onOutput: resolveOutput
+    });
+    try {
+      await engine.run();
+      const 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 () => {
+    const testRoot = await createWorkletsProject();
+    const 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 () => {
+    const 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 () => {
+    const testRoot = await createWorkletsProject(false);
+    const compiler = await import("@vxrn/compiler");
+    compiler.configureVXRNCompilerPlugin({
+      enableReanimated: true
+    });
+    try {
+      const 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();
+      const 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", () => {
+  it("registers scale siblings and keeps monorepo assets inside assetsDest", async () => {
+    const testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-assets-"));
+    const appRoot = join(testRoot, "workspace/apps/native-app");
+    const appAssets = join(appRoot, "assets");
+    const packageAssets = join(testRoot, "workspace/node_modules/example/assets");
+    const 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 {
+      const assetData = await getNativeAssetData(join(appAssets, "icon.png"), appRoot, "ios");
+      expect(assetData.scales).toEqual([1, 2, 3]);
+      expect(assetData.files.map(file => file.slice(appAssets.length + 1))).toEqual(["icon.png", "icon@2x.png", "icon@3x.png"]);
+      expect(assetData.hash).not.toBe("");
+      const registry = createNativeDevAssetRegistry();
+      registry.register(assetData);
+      expect(registry.resolve("/assets/assets/icon@2x.png", assetData.hash)?.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 (const file of ["icon.png", "icon@2x.png", "icon@3x.png"]) expect(existsSync(join(assetsDest, "assets/assets", file))).toBe(true);
+      for (const file of ["back.png", "back@2x.png"]) expect(existsSync(join(assetsDest, "assets/_/_/node_modules/example/assets", file))).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", () => {
+  it("uses the require condition for CommonJS calls", async () => {
+    const testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-conditions-"));
+    const 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 {
+      const result = await buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.cjs",
+        dev: true
+      });
+      const 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 () => {
+    const testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-cjs-default-"));
+    const 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`);
+    let resolveOutput;
+    const output = new Promise(resolve => {
+      resolveOutput = resolve;
+    });
+    const 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();
+      const result = await output;
+      if (result instanceof Error) throw result;
+      const chunk = result.output.find(item => item.type === "chunk" && item.isEntry);
+      if (!chunk || chunk.type !== "chunk") throw new Error("Rolldown did not emit a native dev entry chunk");
+      const 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");
+      const 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 () => {
+    const testRoot = await mkdtemp(join(tmpdir(), "vxrn-native-prod-cjs-default-"));
+    const 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 {
+      const result = await buildNativeBundle({
+        root: testRoot,
+        platform: "ios",
+        entryFile: "entry.js"
+      });
+      const context = {
+        clearTimeout,
+        console,
+        process: {
+          env: {}
+        },
+        setTimeout
+      };
+      runInNewContext(result.code, context);
+      expect(Reflect.get(context, "__vxrnProdCjsDefaultProbe")).toBe("function");
+    } finally {
+      await rm(testRoot, {
+        recursive: true,
+        force: true
+      });
+    }
+  });
+});
 //# sourceMappingURL=createNativeDevEngine.test.mjs.map