@vxrn/vite-plugin-metro 1.27.1 → 2.0.0-beta.45.1

package/dist/cjs/transformer/metroNativeWorker.test.cjs

@@ -1,1054 +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_vitest = require("vitest");
-var vm = __toESM(require("node:vm"), 1);
-var import_oxc_parser = require("oxc-parser");
-var fs = __toESM(require("node:fs"), 1);
-var os = __toESM(require("node:os"), 1);
-var path = __toESM(require("node:path"), 1);
-var import_node_module = require("node:module");
-var import_metroNativeWorker = require("./metroNativeWorker.cjs");
-var import_getMetroConfigFromViteConfig = require("../metro-config/getMetroConfigFromViteConfig.cjs");
-const import_meta = {};
-const babelCalls = {
-  transform: 0,
-  transformSync: 0,
-  transformAsync: 0,
-  transformFromAstSync: 0,
-  parse: 0,
-  parseSync: 0
-};
-import_vitest.vi.mock("@babel/core", async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    transform: import_vitest.vi.fn((...args) => {
-      babelCalls.transform++;
-      return actual.transform(...args);
-    }),
-    transformSync: import_vitest.vi.fn((...args) => {
-      babelCalls.transformSync++;
-      return actual.transformSync(...args);
-    }),
-    transformAsync: import_vitest.vi.fn((...args) => {
-      babelCalls.transformAsync++;
-      return actual.transformAsync(...args);
-    }),
-    transformFromAstSync: import_vitest.vi.fn((...args) => {
-      babelCalls.transformFromAstSync++;
-      return actual.transformFromAstSync(...args);
-    }),
-    parse: import_vitest.vi.fn((...args) => {
-      babelCalls.parse++;
-      return actual.parse(...args);
-    }),
-    parseSync: import_vitest.vi.fn((...args) => {
-      babelCalls.parseSync++;
-      return actual.parseSync(...args);
-    })
-  };
-});
-(0, import_vitest.beforeEach)(() => {
-  babelCalls.transform = 0;
-  babelCalls.transformSync = 0;
-  babelCalls.transformAsync = 0;
-  babelCalls.transformFromAstSync = 0;
-  babelCalls.parse = 0;
-  babelCalls.parseSync = 0;
-});
-function assertZeroBabelCalls() {
-  (0, import_vitest.expect)(babelCalls.transform).toBe(0);
-  (0, import_vitest.expect)(babelCalls.transformSync).toBe(0);
-  (0, import_vitest.expect)(babelCalls.transformAsync).toBe(0);
-  (0, import_vitest.expect)(babelCalls.transformFromAstSync).toBe(0);
-  (0, import_vitest.expect)(babelCalls.parse).toBe(0);
-  (0, import_vitest.expect)(babelCalls.parseSync).toBe(0);
-}
-(0, import_vitest.describe)("metroNativeWorker", () => {
-  import_vitest.it.each([["data.json", true], ["data.json", false], ["data.js", false]])("minifies %s with source maps enabled=%s without stale mappings", async (filename, sourceMap) => {
-    const result = await (0, import_metroNativeWorker.transform)({
-      minifierPath: (0, import_node_module.createRequire)(import_meta.url).resolve("metro-minify-terser"),
-      minifierConfig: {
-        sourceMap
-      }
-    }, "/project", filename, Buffer.from(filename.endsWith(".json") ? "{\"answer\":42}" : "module.exports = { answer: 42 }"), {
-      dev: false,
-      minify: true,
-      platform: "ios",
-      type: "module"
-    });
-    const module2 = {
-      exports: {}
-    };
-    const {
-      code,
-      map
-    } = result.output[0].data;
-    vm.runInNewContext(code, {
-      __d(factory) {
-        factory({}, () => {}, () => {}, () => {}, module2, module2.exports, []);
-      }
-    });
-    (0, import_vitest.expect)(module2.exports.answer).toBe(42);
-    (0, import_vitest.expect)(map.every(entry => entry.length === 2)).toBe(true);
-    assertZeroBabelCalls();
-  });
-  (0, import_vitest.it)("minifies production modules with executable output and original source locations", async () => {
-    const source = "exports.answer = function answer(value) {\n  return value + 42\n}\n";
-    const {
-      code,
-      map
-    } = (await (0, import_metroNativeWorker.transform)({
-      minifierPath: (0, import_node_module.createRequire)(import_meta.url).resolve("metro-minify-terser"),
-      minifierConfig: {
-        mangle: true
-      }
-    }, "/project", "answer.js", Buffer.from(source), {
-      dev: false,
-      minify: true,
-      platform: "ios",
-      type: "module"
-    })).output[0].data;
-    const module2 = {
-      exports: {}
-    };
-    vm.runInNewContext(code, {
-      __d(factory) {
-        factory({}, () => {}, () => {}, () => {}, module2, module2.exports, []);
-      }
-    });
-    (0, import_vitest.expect)(module2.exports.answer(8)).toBe(50);
-    const msm = await import("metro-source-map");
-    const fullMap = msm.fromRawMappings([{
-      code,
-      path: "answer.js",
-      source,
-      map
-    }]).toMap();
-    const offset = code.indexOf("42");
-    (0, import_vitest.expect)(offset).toBeGreaterThan(-1);
-    const prefix = code.slice(0, offset).split("\n");
-    const position = new msm.Consumer(fullMap).originalPositionFor({
-      line: prefix.length,
-      column: prefix.at(-1).length
-    });
-    (0, import_vitest.expect)(position.source).toBe("answer.js");
-    (0, import_vitest.expect)(position.line).toBe(2);
-    (0, import_vitest.expect)(position.column).toBe(17);
-    assertZeroBabelCalls();
-  });
-  (0, import_vitest.it)("extracts all dependencies with oxc-parser and zero Babel", () => {
-    const deps = (0, import_metroNativeWorker.extractDependencies)(`
-      import React, { useState } from 'react'
-      import * as RN from 'react-native'
-      import './global.css'
-      import type { UserType } from './user-types'
-      export { Button } from './Button'
-      export * from './icons'
-      export type { ThemeType } from './theme-types'
-      const helper = require('./helper')
-      async function loadAsync() {
-        const dyn = await import('./dynamic-module')
-      }
-    `, "TestComponent.tsx");
-    assertZeroBabelCalls();
-    const names = deps.map(d => d.name);
-    (0, import_vitest.expect)(names).toContain("react");
-    (0, import_vitest.expect)(names).toContain("react-native");
-    (0, import_vitest.expect)(names).toContain("./global.css");
-    (0, import_vitest.expect)(names).toContain("./Button");
-    (0, import_vitest.expect)(names).toContain("./icons");
-    (0, import_vitest.expect)(names).toContain("./helper");
-    (0, import_vitest.expect)(names).toContain("./dynamic-module");
-    (0, import_vitest.expect)(names).not.toContain("./user-types");
-    (0, import_vitest.expect)(names).not.toContain("./theme-types");
-    const reactDep = deps.find(d => d.name === "react");
-    (0, import_vitest.expect)(reactDep.data.isESMImportAtSource).toBe(true);
-    (0, import_vitest.expect)(reactDep.data.asyncType).toBeNull();
-    (0, import_vitest.expect)(reactDep.data.locs.length).toBeGreaterThan(0);
-    const loc = reactDep.data.locs[0];
-    (0, import_vitest.expect)(loc.start.line).toBeGreaterThan(0);
-    (0, import_vitest.expect)(loc.start.column).toBeGreaterThanOrEqual(0);
-    (0, import_vitest.expect)(loc.end.line).toBeGreaterThanOrEqual(loc.start.line);
-    (0, import_vitest.expect)(loc.end.column).toBeGreaterThanOrEqual(0);
-    const helperDep = deps.find(d => d.name === "./helper");
-    (0, import_vitest.expect)(helperDep.data.isESMImportAtSource).toBe(false);
-    (0, import_vitest.expect)(helperDep.data.asyncType).toBeNull();
-    const dynamicDep = deps.find(d => d.name === "./dynamic-module");
-    (0, import_vitest.expect)(dynamicDep.data.asyncType).toBe("async");
-  });
-  (0, import_vitest.it)("marks requires inside a try block optional", () => {
-    const code = `
-      let worklets
-      try {
-        worklets = require('react-native-worklets-core')
-      } catch {}
-      const always = require('./always-there')
-    `;
-    const off = (0, import_metroNativeWorker.extractDependencies)(code, "setup.js");
-    (0, import_vitest.expect)(off.find(d => d.name === "react-native-worklets-core").data.isOptional).toBeUndefined();
-    const on = (0, import_metroNativeWorker.extractDependencies)(code, "setup.js", {
-      allowOptionalDependencies: true
-    });
-    (0, import_vitest.expect)(on.find(d => d.name === "react-native-worklets-core").data.isOptional).toBe(true);
-    (0, import_vitest.expect)(on.find(d => d.name === "./always-there").data.isOptional).toBeUndefined();
-    const excluded = (0, import_metroNativeWorker.extractDependencies)(code, "setup.js", {
-      allowOptionalDependencies: {
-        exclude: ["react-native-worklets-core"]
-      }
-    });
-    (0, import_vitest.expect)(excluded.find(d => d.name === "react-native-worklets-core").data.isOptional).toBeUndefined();
-  });
-  (0, import_vitest.it)("wraps modules in Metro CommonJS format with and without moduleId", () => {
-    const code = "exports.val = 123;";
-    const wrappedWithoutId = (0, import_metroNativeWorker.wrapModule)(code);
-    (0, import_vitest.expect)(wrappedWithoutId).toContain("__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {");
-    (0, import_vitest.expect)(wrappedWithoutId).toContain("var require = _$$_REQUIRE;");
-    (0, import_vitest.expect)(wrappedWithoutId).toContain("exports.val = 123;");
-    (0, import_vitest.expect)(wrappedWithoutId.endsWith(");")).toBe(true);
-    const wrappedWithId = (0, import_metroNativeWorker.wrapModule)(code, {
-      moduleId: 99,
-      dependencyIds: [1, 2, 3]
-    });
-    (0, import_vitest.expect)(wrappedWithId).toContain(", 99, [1,2,3]);");
-  });
-  (0, import_vitest.it)("transforms TSX with React JSX, Hermes lowering, and ZERO Babel", async () => {
-    const result = await (0, import_metroNativeWorker.transform)({}, "/project", "Greeter.tsx", Buffer.from(`
-      import React from 'react'
-      import { View, Text } from 'react-native'
-      const helper = require('./helper')
-
-      export class Greeter extends React.Component {
-        greeting = 'Hello from Native'
-
-        async fetchGreeting() {
-          return this.greeting
-        }
-
-        render() {
-          return (
-            <View testID="greeter">
-              <Text>{this.greeting}</Text>
-            </View>
-          )
-        }
-      }
-    `, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(result.output).toHaveLength(1);
-    const output = result.output[0];
-    (0, import_vitest.expect)(output.type).toBe("js/module");
-    (0, import_vitest.expect)(output.data.lineCount).toBeGreaterThan(0);
-    (0, import_vitest.expect)(output.data.map.length).toBeGreaterThan(0);
-    const code = output.data.code;
-    (0, import_vitest.expect)(code).toContain("__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {");
-    (0, import_vitest.expect)(code).toContain("var require = _$$_REQUIRE;");
-    (0, import_vitest.expect)(code).not.toContain("<View");
-    (0, import_vitest.expect)(code).not.toContain("<Text");
-    (0, import_vitest.expect)(code).toContain("this.greeting = \"Hello from Native\"");
-    const depNames = result.dependencies.map(d => d.name);
-    (0, import_vitest.expect)(depNames).toContain("react");
-    (0, import_vitest.expect)(depNames).toContain("react-native");
-    (0, import_vitest.expect)(depNames).toContain("./helper");
-    (0, import_vitest.expect)(depNames).toContain("react/jsx-dev-runtime");
-  });
-  (0, import_vitest.it)("lowers async generators, including the method shorthand Hermes also rejects", async () => {
-    for (const [filename, sourceCode] of Object.entries({
-      "cursor.ts": `
-        export class Cursor {
-          async *rows() {
-            yield await Promise.resolve(1)
-          }
-        }
-      `,
-      "stream.ts": `
-        export async function* stream() {
-          yield 1
-        }
-      `,
-      "drain.ts": `
-        export async function drain(src) {
-          for await (const x of src) {
-            console.log(x)
-          }
-        }
-      `
-    })) {
-      const result = await (0, import_metroNativeWorker.transform)({}, "/project", filename, Buffer.from(sourceCode, "utf8"), {
-        dev: true,
-        platform: "ios",
-        type: "module"
-      });
-      assertZeroBabelCalls();
-      const code = result.output[0].data.code;
-      (0, import_vitest.expect)(code, filename).not.toMatch(/\basync\s+function\s*\*/);
-      (0, import_vitest.expect)(code, filename).not.toMatch(/\basync\s*\*\s*[\w$[]/);
-      (0, import_vitest.expect)(code, filename).not.toMatch(/\bfor\s+await\s*\(/);
-    }
-  });
-  (0, import_vitest.it)("handles JSON files without Babel", async () => {
-    const jsonSource = JSON.stringify({
-      name: "my-package",
-      version: "1.0.0"
-    });
-    const result = await (0, import_metroNativeWorker.transform)({}, "/project", "package.json", Buffer.from(jsonSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(result.dependencies).toEqual([]);
-    (0, import_vitest.expect)(result.output).toHaveLength(1);
-    (0, import_vitest.expect)(result.output[0].type).toBe("js/module");
-    (0, import_vitest.expect)(result.output[0].data.code).toContain("module.exports = {\"name\":\"my-package\",\"version\":\"1.0.0\"}");
-    (0, import_vitest.expect)(result.output[0].data.code).toContain("__d(function (global, require");
-  });
-  (0, import_vitest.it)("handles Asset files without Babel", async () => {
-    const result = await (0, import_metroNativeWorker.transform)({
-      assetRegistryPath: "react-native/Libraries/Image/AssetRegistry",
-      publicPath: "/assets"
-    }, "/project", "logo.png", Buffer.from("fake-png-binary-data", "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "asset"
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(result.output[0].type).toBe("js/module/asset");
-    (0, import_vitest.expect)(result.output[0].data.code).toContain("registerAsset(");
-    (0, import_vitest.expect)(result.output[0].data.code).toContain("__d(function");
-    const depNames = result.dependencies.map(d => d.name);
-    (0, import_vitest.expect)(depNames).toContain("react-native/Libraries/Image/AssetRegistry");
-  });
-  (0, import_vitest.it)("handles Flow files by stripping types without Babel", async () => {
-    const result = await (0, import_metroNativeWorker.transform)({}, "/project", "math.js", Buffer.from(`
-      // @flow
-      function add(a: number, b: number): number {
-        return a + b;
-      }
-      export default add;
-    `, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(result.output[0].data.code).not.toContain(": number");
-    (0, import_vitest.expect)(result.output[0].data.code).toContain("function add(a, b)");
-  });
-  (0, import_vitest.it)("generates a deterministic cache key without Babel", () => {
-    const key1 = (0, import_metroNativeWorker.getCacheKey)({
-      globalPrefix: "__one_",
-      minifierPath: "terser"
-    }, {
-      projectRoot: "/app"
-    });
-    const key2 = (0, import_metroNativeWorker.getCacheKey)({
-      globalPrefix: "__one_",
-      minifierPath: "terser"
-    }, {
-      projectRoot: "/app"
-    });
-    const key3 = (0, import_metroNativeWorker.getCacheKey)({
-      globalPrefix: "__other_"
-    }, {
-      projectRoot: "/app"
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(key1).toBe(key2);
-    (0, import_vitest.expect)(key1).not.toBe(key3);
-    (0, import_vitest.expect)(typeof key1).toBe("string");
-    (0, import_vitest.expect)(key1.length).toBe(64);
-  });
-  (0, import_vitest.it)("correctly sets transformerPath in buildMetroConfigInputFromViteConfig when active", async () => {
-    const mockViteConfig = {
-      root: process.cwd()
-    };
-    delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-    const configDefault = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-    (0, import_vitest.expect)(configDefault.defaultConfig.transformerPath).toContain("metroNativeWorker");
-    (0, import_vitest.expect)(configDefault.defaultConfig.transformer.transformerPath).toBeUndefined();
-    const configOptOff = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {
-      nativeTransforms: false
-    });
-    (0, import_vitest.expect)(configOptOff.defaultConfig.transformerPath).not.toContain("metroNativeWorker");
-    process.env.ONE_METRO_NATIVE_TRANSFORMS = "0";
-    const configEnvOff = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-    (0, import_vitest.expect)(configEnvOff.defaultConfig.transformerPath).not.toContain("metroNativeWorker");
-    process.env.ONE_METRO_NATIVE_TRANSFORMS = "1";
-    const configEnvOn = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {
-      nativeTransforms: false
-    });
-    (0, import_vitest.expect)(configEnvOn.defaultConfig.transformerPath).toContain("metroNativeWorker");
-    delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-  });
-  (0, import_vitest.it)("falls back to default Metro babel transformer when a user babel config exists", async () => {
-    const tempDir = path.join(process.cwd(), `.tmp-metro-test-${Date.now()}`);
-    fs.mkdirSync(tempDir, {
-      recursive: true
-    });
-    fs.writeFileSync(path.join(tempDir, "package.json"), "{}");
-    try {
-      const mockViteConfig = {
-        root: tempDir
-      };
-      delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-      const config1 = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-      (0, import_vitest.expect)(config1.defaultConfig.transformerPath).toContain("metroNativeWorker");
-      const babelConfigPath = path.join(tempDir, "babel.config.js");
-      fs.writeFileSync(babelConfigPath, "// @one-generated\nmodule.exports = {}");
-      const config2 = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-      (0, import_vitest.expect)(config2.defaultConfig.transformerPath).toContain("metroNativeWorker");
-      fs.writeFileSync(babelConfigPath, "module.exports = { plugins: [\"my-plugin\"] }");
-      const config3 = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-      (0, import_vitest.expect)(config3.defaultConfig.transformerPath).not.toContain("metroNativeWorker");
-      process.env.ONE_METRO_NATIVE_TRANSFORMS = "1";
-      const config4 = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-      (0, import_vitest.expect)(config4.defaultConfig.transformerPath).toContain("metroNativeWorker");
-      delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-      const config5 = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {
-        nativeTransforms: true
-      });
-      (0, import_vitest.expect)(config5.defaultConfig.transformerPath).toContain("metroNativeWorker");
-    } finally {
-      delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-      fs.rmSync(tempDir, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-  (0, import_vitest.it)("warns naming the ignored user babel config when native transforms are forced", async () => {
-    const tempDir = fs.realpathSync(fs.mkdtempSync(path.join(process.cwd(), ".tmp-metro-test-")));
-    fs.writeFileSync(path.join(tempDir, "package.json"), "{}");
-    const babelConfigPath = path.join(tempDir, "babel.config.js");
-    fs.writeFileSync(babelConfigPath, "module.exports = { plugins: [] }");
-    try {
-      delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-      const mockViteConfig = {
-        root: tempDir
-      };
-      const warnsWithConfig = spy => spy.mock.calls.some(args => args.join(" ").includes(babelConfigPath));
-      const optionWarn = import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const forced = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {
-          nativeTransforms: true
-        });
-        (0, import_vitest.expect)(forced.defaultConfig.transformerPath).toContain("metroNativeWorker");
-        (0, import_vitest.expect)(warnsWithConfig(optionWarn)).toBe(true);
-      } finally {
-        optionWarn.mockRestore();
-      }
-      const envWarn = import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        process.env.ONE_METRO_NATIVE_TRANSFORMS = "1";
-        const envForced = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-        (0, import_vitest.expect)(envForced.defaultConfig.transformerPath).toContain("metroNativeWorker");
-        (0, import_vitest.expect)(warnsWithConfig(envWarn)).toBe(true);
-      } finally {
-        envWarn.mockRestore();
-        delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-      }
-      const respectedWarn = import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const respected = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-        (0, import_vitest.expect)(respected.defaultConfig.transformerPath).not.toContain("metroNativeWorker");
-        (0, import_vitest.expect)(warnsWithConfig(respectedWarn)).toBe(false);
-      } finally {
-        respectedWarn.mockRestore();
-      }
-    } finally {
-      delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-      fs.rmSync(tempDir, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-  (0, import_vitest.it)("selects the same transformer in both metro config builders", async () => {
-    const tempDir = fs.realpathSync(fs.mkdtempSync(path.join(process.cwd(), ".tmp-metro-test-")));
-    fs.writeFileSync(path.join(tempDir, "package.json"), "{}");
-    try {
-      delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-      const mockViteConfig = {
-        root: tempDir
-      };
-      const nativeInput = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-      const nativeFull = await (0, import_getMetroConfigFromViteConfig.getMetroConfigFromViteConfig)(mockViteConfig, {});
-      (0, import_vitest.expect)(nativeInput.defaultConfig.transformerPath).toContain("metroNativeWorker");
-      (0, import_vitest.expect)(nativeFull.transformerPath).toContain("metroNativeWorker");
-      const babelConfigPath = path.join(tempDir, "babel.config.js");
-      fs.writeFileSync(babelConfigPath, "module.exports = { plugins: [] }");
-      const fallbackInput = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {});
-      const fallbackFull = await (0, import_getMetroConfigFromViteConfig.getMetroConfigFromViteConfig)(mockViteConfig, {});
-      (0, import_vitest.expect)(fallbackInput.defaultConfig.transformerPath).not.toContain("metroNativeWorker");
-      (0, import_vitest.expect)(fallbackFull.transformerPath).not.toContain("metroNativeWorker");
-      const forcedWarn = import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
-      try {
-        const forcedInput = await (0, import_getMetroConfigFromViteConfig.buildMetroConfigInputFromViteConfig)(mockViteConfig, {
-          nativeTransforms: true
-        });
-        const forcedFull = await (0, import_getMetroConfigFromViteConfig.getMetroConfigFromViteConfig)(mockViteConfig, {
-          nativeTransforms: true
-        });
-        (0, import_vitest.expect)(forcedInput.defaultConfig.transformerPath).toContain("metroNativeWorker");
-        (0, import_vitest.expect)(forcedFull.transformerPath).toContain("metroNativeWorker");
-        (0, import_vitest.expect)(forcedWarn.mock.calls.some(args => args.join(" ").includes(babelConfigPath))).toBe(true);
-      } finally {
-        forcedWarn.mockRestore();
-      }
-    } finally {
-      delete process.env.ONE_METRO_NATIVE_TRANSFORMS;
-      fs.rmSync(tempDir, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-  (0, import_vitest.it)("transforms and executes a real 2-module Metro bundle through metro-runtime require polyfill", async () => {
-    const depSource = "exports.value = 42;";
-    const aSource = "const dep = require(\"./dep\"); module.exports = { doubled: dep.value * 2 };";
-    const depRes = await (0, import_metroNativeWorker.transform)({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module",
-      moduleId: 2,
-      dependencyIds: []
-    });
-    const aRes = await (0, import_metroNativeWorker.transform)({}, "/project", "a.js", Buffer.from(aSource, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module",
-      moduleId: 1,
-      dependencyIds: [2]
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(aRes.dependencies).toHaveLength(1);
-    (0, import_vitest.expect)(aRes.dependencies[0].name).toBe("./dep");
-    const aEmittedCode = aRes.output[0].data.code;
-    (0, import_vitest.expect)(aEmittedCode).toContain("require(_dependencyMap[0], \"./dep\")");
-    const polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const contextObj = {
-      __DEV__: false,
-      __METRO_GLOBAL_PREFIX__: "",
-      console
-    };
-    contextObj.global = contextObj;
-    vm.createContext(contextObj);
-    vm.runInContext(polyfillCode, contextObj);
-    vm.runInContext(depRes.output[0].data.code, contextObj);
-    vm.runInContext(aEmittedCode, contextObj);
-    const executedExports = vm.runInContext("global.__r(1)", contextObj);
-    (0, import_vitest.expect)(executedExports).toEqual({
-      doubled: 84
-    });
-  });
-  (0, import_vitest.it)("transforms and executes a 2-module Metro bundle with ESM imports in dev mode", async () => {
-    const depSource = "export const greeting = \"Hello Metro Native\";";
-    const aSource = "import { greeting } from \"./dep\"; export const message = greeting.toUpperCase();";
-    const depRes = await (0, import_metroNativeWorker.transform)({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      moduleId: 2,
-      dependencyIds: []
-    });
-    const aRes = await (0, import_metroNativeWorker.transform)({}, "/project", "a.js", Buffer.from(aSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      moduleId: 1,
-      dependencyIds: [2]
-    });
-    assertZeroBabelCalls();
-    const polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const contextObj = {
-      __DEV__: true,
-      __METRO_GLOBAL_PREFIX__: "",
-      console
-    };
-    contextObj.global = contextObj;
-    vm.createContext(contextObj);
-    vm.runInContext(polyfillCode, contextObj);
-    vm.runInContext(depRes.output[0].data.code, contextObj);
-    vm.runInContext(aRes.output[0].data.code, contextObj);
-    const executedExports = vm.runInContext("global.__r(1)", contextObj);
-    (0, import_vitest.expect)(executedExports.message).toBe("HELLO METRO NATIVE");
-  });
-  (0, import_vitest.it)("respects lexical scope shadowing for require calls (Astra probe)", async () => {
-    const res = await (0, import_metroNativeWorker.transform)({}, "/project", "shadowed.js", Buffer.from("function f(require){return require(\"./local\")}; module.exports=f(x=>x);", "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module",
-      moduleId: 1,
-      dependencyIds: []
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(res.dependencies).toHaveLength(0);
-    const emitted = res.output[0].data.code;
-    (0, import_vitest.expect)(emitted).not.toContain("_dependencyMap[0]");
-    (0, import_vitest.expect)(emitted).toMatch(/require\d*\("\.\/local"\)/);
-    const polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const contextObj = {
-      __DEV__: false,
-      __METRO_GLOBAL_PREFIX__: "",
-      console
-    };
-    contextObj.global = contextObj;
-    vm.createContext(contextObj);
-    vm.runInContext(polyfillCode, contextObj);
-    vm.runInContext(emitted, contextObj);
-    const result = vm.runInContext("global.__r(1)", contextObj);
-    (0, import_vitest.expect)(result).toBe("./local");
-  });
-  (0, import_vitest.it)("preserves distinct indexed identity for duplicate and mixed sync/async dependencies", async () => {
-    const res = await (0, import_metroNativeWorker.transform)({}, "/project", "index.js", Buffer.from(`
-      const a = require('./dep');
-      const b = require('./dep');
-      async function load() {
-        const c = await import('./dep');
-      }
-    `, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    const depNames = res.dependencies.map(d => d.name);
-    (0, import_vitest.expect)(depNames).toContain("./dep");
-    const syncDep = res.dependencies.find(d => d.name === "./dep" && d.data.asyncType === null);
-    const asyncDep = res.dependencies.find(d => d.name === "./dep" && d.data.asyncType === "async");
-    (0, import_vitest.expect)(syncDep).toBeDefined();
-    (0, import_vitest.expect)(asyncDep).toBeDefined();
-    (0, import_vitest.expect)(syncDep.data.index).not.toEqual(asyncDep.data.index);
-    const emitted = res.output[0].data.code;
-    const syncIndex = syncDep.data.index;
-    (0, import_vitest.expect)(emitted).toContain(`require(_dependencyMap[${syncIndex}], "./dep")`);
-  });
-  (0, import_vitest.it)("conforms to Metro map ABI with raw mapping segment tuples and accurate symbolication", async () => {
-    const res = await (0, import_metroNativeWorker.transform)({}, "/project", "math.ts", Buffer.from(`
-      export function add(a: number, b: number): number {
-        return a + b;
-      }
-    `, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    const map = res.output[0].data.map;
-    (0, import_vitest.expect)(Array.isArray(map)).toBe(true);
-    (0, import_vitest.expect)(map.length).toBeGreaterThan(0);
-    for (const tuple of map) {
-      (0, import_vitest.expect)(Array.isArray(tuple)).toBe(true);
-      (0, import_vitest.expect)(typeof tuple[0]).toBe("number");
-      (0, import_vitest.expect)(typeof tuple[1]).toBe("number");
-      (0, import_vitest.expect)(tuple).not.toHaveProperty("version");
-      (0, import_vitest.expect)(tuple).not.toHaveProperty("mappings");
-    }
-    const msm = await import("metro-source-map");
-    const fullMap = msm.fromRawMappings([{
-      code: res.output[0].data.code,
-      source: "math.ts",
-      map
-    }]).toMap();
-    const consumer = new msm.Consumer(fullMap);
-    const addLineIndex = res.output[0].data.code.split("\n").findIndex(l => l.includes("function add"));
-    (0, import_vitest.expect)(addLineIndex).toBeGreaterThan(0);
-    const pos = consumer.originalPositionFor({
-      line: addLineIndex + 1,
-      column: 16
-    });
-    (0, import_vitest.expect)(pos.line).toBe(2);
-  });
-  (0, import_vitest.it)("models JS hoisting in ScopeTracker for functions and vars (Astra probe)", async () => {
-    const res = await (0, import_metroNativeWorker.transform)({}, "/project", "hoisted.js", Buffer.from("function f(){const x=require(\"./local\"); function require(x){return x}; return x} module.exports=f();", "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module",
-      moduleId: 1,
-      dependencyIds: []
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(res.dependencies).toHaveLength(0);
-    const emitted = res.output[0].data.code;
-    (0, import_vitest.expect)(emitted).not.toContain("_dependencyMap[0]");
-    (0, import_vitest.expect)(emitted).toMatch(/require\d*\("\.\/local"\)/);
-    const polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const contextObj = {
-      __DEV__: false,
-      __METRO_GLOBAL_PREFIX__: "",
-      console
-    };
-    contextObj.global = contextObj;
-    vm.createContext(contextObj);
-    vm.runInContext(polyfillCode, contextObj);
-    vm.runInContext(emitted, contextObj);
-    const result = vm.runInContext("global.__r(1)", contextObj);
-    (0, import_vitest.expect)(result).toBe("./local");
-  });
-  (0, import_vitest.it)("rewrites dynamic import to Metro asyncRequire and executes promise resolution in dev and release", async () => {
-    const depSource = "exports.message = \"hello dynamic\";";
-    const mainSource = "module.exports = () => import(\"./dep\");";
-    const depRes = await (0, import_metroNativeWorker.transform)({}, "/project", "dep.js", Buffer.from(depSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      moduleId: 2,
-      dependencyIds: []
-    });
-    const mainRes = await (0, import_metroNativeWorker.transform)({}, "/project", "main.js", Buffer.from(mainSource, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      moduleId: 0,
-      dependencyIds: [2, 1]
-    });
-    assertZeroBabelCalls();
-    const depNames = mainRes.dependencies.map(d => d.name);
-    (0, import_vitest.expect)(depNames).toContain("./dep");
-    (0, import_vitest.expect)(depNames).toContain("metro-runtime/src/modules/asyncRequire");
-    const dynDep = mainRes.dependencies.find(d => d.name === "./dep");
-    (0, import_vitest.expect)(dynDep.data.asyncType).toBe("async");
-    const emittedMain = mainRes.output[0].data.code;
-    (0, import_vitest.expect)(emittedMain).not.toContain("import(\"./dep\")");
-    (0, import_vitest.expect)(emittedMain).toContain("require(_dependencyMap[1], \"metro-runtime/src/modules/asyncRequire\")(_dependencyMap[0], _dependencyMap.paths, \"./dep\")");
-    const polyfillPath = require.resolve("metro-runtime/src/polyfills/require.js");
-    const polyfillCode = fs.readFileSync(polyfillPath, "utf8");
-    const asyncRequirePath = require.resolve("metro-runtime/src/modules/asyncRequire.js");
-    const asyncRequireSource = fs.readFileSync(asyncRequirePath, "utf8");
-    const wrappedAsyncRequire = (0, import_metroNativeWorker.wrapModule)(asyncRequireSource, {
-      moduleId: 1,
-      dependencyIds: []
-    });
-    for (const isDev of [true, false]) {
-      const contextObj = {
-        __DEV__: isDev,
-        __METRO_GLOBAL_PREFIX__: "",
-        console
-      };
-      contextObj.global = contextObj;
-      vm.createContext(contextObj);
-      vm.runInContext(polyfillCode, contextObj);
-      vm.runInContext(wrappedAsyncRequire, contextObj);
-      vm.runInContext(depRes.output[0].data.code, contextObj);
-      vm.runInContext(emittedMain, contextObj);
-      const mainFn = vm.runInContext("global.__r(0)", contextObj);
-      (0, import_vitest.expect)(typeof mainFn).toBe("function");
-      const promise = mainFn();
-      (0, import_vitest.expect)(promise instanceof Promise || promise && typeof promise.then === "function").toBe(true);
-      const resolved = await promise;
-      (0, import_vitest.expect)(resolved.message).toBe("hello dynamic");
-      (0, import_vitest.expect)(resolved.default.message).toBe("hello dynamic");
-    }
-  });
-  (0, import_vitest.it)("preserves accurate sourcemap for tokens after rewritten require calls on the same line", async () => {
-    const sourceCode = "const a = require(\"./dep\"), b = 42;";
-    const resWrapped = await (0, import_metroNativeWorker.transform)({}, "/project", "app.js", Buffer.from(sourceCode, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    assertZeroBabelCalls();
-    const msm = await import("metro-source-map");
-    const fullMapWrapped = msm.fromRawMappings([{
-      code: resWrapped.output[0].data.code,
-      source: "app.js",
-      map: resWrapped.output[0].data.map
-    }]).toMap();
-    const consumerWrapped = new msm.Consumer(fullMapWrapped);
-    const linesWrapped = resWrapped.output[0].data.code.split("\n");
-    const lineIndexWrapped = linesWrapped.findIndex(l => l.includes("b = 42"));
-    (0, import_vitest.expect)(lineIndexWrapped).toBeGreaterThanOrEqual(0);
-    const generatedColWrapped = linesWrapped[lineIndexWrapped].indexOf("b = 42");
-    (0, import_vitest.expect)(generatedColWrapped).toBeGreaterThan(0);
-    const posWrapped = consumerWrapped.originalPositionFor({
-      line: lineIndexWrapped + 1,
-      column: generatedColWrapped
-    });
-    (0, import_vitest.expect)(posWrapped.line).toBe(1);
-    (0, import_vitest.expect)(posWrapped.column).toBe(28);
-    (0, import_vitest.expect)(sourceCode.slice(Number(posWrapped.column))).toContain("b = 42;");
-    const resUnwrapped = await (0, import_metroNativeWorker.transform)({
-      unstable_disableModuleWrapping: true
-    }, "/project", "app.js", Buffer.from(sourceCode, "utf8"), {
-      dev: false,
-      platform: "ios",
-      type: "module"
-    });
-    const fullMapUnwrapped = msm.fromRawMappings([{
-      code: resUnwrapped.output[0].data.code,
-      source: "app.js",
-      map: resUnwrapped.output[0].data.map
-    }]).toMap();
-    const consumerUnwrapped = new msm.Consumer(fullMapUnwrapped);
-    const linesUnwrapped = resUnwrapped.output[0].data.code.split("\n");
-    const lineIndexUnwrapped = linesUnwrapped.findIndex(l => l.includes("b = 42"));
-    (0, import_vitest.expect)(lineIndexUnwrapped).toBeGreaterThanOrEqual(0);
-    const generatedColUnwrapped = linesUnwrapped[lineIndexUnwrapped].indexOf("b = 42");
-    const posUnwrapped = consumerUnwrapped.originalPositionFor({
-      line: lineIndexUnwrapped + 1,
-      column: generatedColUnwrapped
-    });
-    (0, import_vitest.expect)(posUnwrapped.line).toBe(1);
-    (0, import_vitest.expect)(posUnwrapped.column).toBe(28);
-  });
-  (0, import_vitest.it)("routes a require.context whose directory is held in a variable through the dependency map", async () => {
-    const result = await (0, import_metroNativeWorker.transform)({}, "/project", "entry.js", Buffer.from(`
-      const routeRoot = './app'
-      export const ctx = require.context(routeRoot, true, /\\.tsx$/)
-    `, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module"
-    });
-    const contextDep = result.dependencies.find(d => d.data.contextParams != null);
-    (0, import_vitest.expect)(contextDep?.name).toBe("./app");
-    const calls = [];
-    let ctx;
-    vm.runInNewContext(result.output[0].data.code, {
-      __d: factory => {
-        const module2 = {
-          exports: {}
-        };
-        const req = (...args) => {
-          calls.push(args);
-          return {
-            keys: () => []
-          };
-        };
-        req.context = () => {
-          throw new Error("fallbackRequireContext reached");
-        };
-        factory({}, req, () => ({}), () => ({}), module2, module2.exports, ["./app"]);
-        ctx = module2.exports.ctx;
-      }
-    });
-    (0, import_vitest.expect)(ctx).toBeDefined();
-    (0, import_vitest.expect)(calls[0][1]).toBe("./app");
-  });
-  (0, import_vitest.it)("gives loop bodies per-iteration bindings that survive a runtime without them", async () => {
-    const asHermesWouldSeeIt = (await (0, import_metroNativeWorker.transform)({}, "/project", "loops.ts", Buffer.from(`
-      export function collect() {
-        const out = []
-        for (let i = 0; i < 2; i++) out.push(() => i)
-        for (const label of ['a', 'b']) out.push(() => label)
-        for (const key in { x: 1, y: 2 }) out.push(() => key)
-        return out.map((f) => f())
-      }
-    `, "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module"
-    })).output[0].data.code.replace(/\bfor\s*\(\s*(let|const)\b/g, "for (var");
-    let collect;
-    vm.runInNewContext(asHermesWouldSeeIt, {
-      __d: factory => {
-        const module2 = {
-          exports: {}
-        };
-        factory({}, () => ({}), () => ({}), () => ({}), module2, module2.exports, []);
-        collect = module2.exports.collect;
-      }
-    });
-    (0, import_vitest.expect)(collect()).toEqual([0, 1, "a", "b", "x", "y"]);
-  });
-});
-(0, import_vitest.describe)("one native transform ports", () => {
-  (0, import_vitest.it)("inlines process.env.ONE_SERVER_URL so a native bundle can find its loaders", () => {
-    process.env.ONE_SERVER_URL = "https://example.test";
-    try {
-      const out = (0, import_metroNativeWorker.applyInlineEnvVars)("export const url = process.env.ONE_SERVER_URL;", "loader.ts", false);
-      (0, import_vitest.expect)(out).toBe("export const url = \"https://example.test\";");
-    } finally {
-      process.env.ONE_SERVER_URL = void 0;
-    }
-  });
-  (0, import_vitest.it)("leaves ONE_SERVER_URL alone when it is only a string", () => {
-    const src = "export const key = \"process.env.ONE_SERVER_URL\";";
-    (0, import_vitest.expect)((0, import_metroNativeWorker.applyInlineEnvVars)(src, "a.ts", false)).toBe(src);
-  });
-  (0, import_vitest.it)("inlines import.meta.env reads, which oxc otherwise lowers to an empty object", () => {
-    const out = (0, import_metroNativeWorker.applyInlineEnvVars)(`export const key = import.meta.env.VITE_POSTHOG_API_KEY;
-export const target = import.meta.env?.TAMAGUI_TARGET;
-export const missing = import.meta.env.NOT_SET;
-export const all = { ...import.meta.env };`, "env.ts", true, {
-      DEV: false,
-      VITE_POSTHOG_API_KEY: "pk_live",
-      TAMAGUI_TARGET: "native"
-    });
-    (0, import_vitest.expect)(out).toContain("export const key = \"pk_live\";");
-    (0, import_vitest.expect)(out).toContain("export const target = \"native\";");
-    (0, import_vitest.expect)(out).toContain("export const missing = undefined;");
-    (0, import_vitest.expect)(out).toContain("\"VITE_POSTHOG_API_KEY\":\"pk_live\"");
-    (0, import_vitest.expect)(out).not.toContain("import.meta");
-  });
-  (0, import_vitest.it)("inlines process.env keys the vite env map defines", () => {
-    const out = (0, import_metroNativeWorker.applyInlineEnvVars)("export const t = process.env.TAMAGUI_TARGET; export const u = process.env.UNKNOWN_THING;", "env.ts", true, {
-      TAMAGUI_TARGET: "native"
-    });
-    (0, import_vitest.expect)(out).toContain("export const t = \"native\";");
-    (0, import_vitest.expect)(out).toContain("process.env.UNKNOWN_THING");
-  });
-  (0, import_vitest.it)("never rewrites an env read in an assignment target", () => {
-    const src = "process.env.VITE_ENVIRONMENT = \"ssr\";";
-    (0, import_vitest.expect)((0, import_metroNativeWorker.applyInlineEnvVars)(src, "a.ts", true, {
-      VITE_ENVIRONMENT: "ios"
-    })).toBe(src);
-  });
-  (0, import_vitest.it)("folds branches the inlining made constant so metro never resolves dead imports", () => {
-    const out = (0, import_metroNativeWorker.applyInlineEnvVars)(`if (import.meta.env.SSR) { require('./server-only-thing') } else { load(import.meta.env.API) }`, "branch.ts", true, {
-      SSR: false,
-      API: "https://api.test"
-    });
-    (0, import_vitest.expect)(out).not.toContain("server-only-thing");
-    (0, import_vitest.expect)(out).toContain("load(\"https://api.test\")");
-  });
-  (0, import_vitest.it)("folds a ternary and keeps a branch it cannot resolve", () => {
-    (0, import_vitest.expect)((0, import_metroNativeWorker.applyInlineEnvVars)("const a = import.meta.env.DEV ? x : y;", "a.ts", true, {
-      DEV: false
-    })).toContain("const a = y;");
-    const dynamic = "const a = flag ? x : y;";
-    (0, import_vitest.expect)((0, import_metroNativeWorker.applyInlineEnvVars)(dynamic, "a.ts", true, {
-      DEV: false
-    })).toBe(dynamic);
-  });
-  (0, import_vitest.it)("runs the user native transforms that stand in for their babel plugins", async () => {
-    const result = await (0, import_metroNativeWorker.transform)({}, import_meta.dirname, "ota.ts", Buffer.from("export const id = __EXAMPLE_BUILD_ID; export const from = __EXAMPLE_FILENAME;", "utf8"), {
-      dev: true,
-      platform: "ios",
-      type: "module",
-      customTransformOptions: {
-        vite: {
-          nativeTransformModules: ["./__fixtures__/exampleNativeTransform.cjs"]
-        }
-      }
-    });
-    assertZeroBabelCalls();
-    (0, import_vitest.expect)(result.output[0].data.code).toContain("\"ios-build\"");
-    (0, import_vitest.expect)(result.output[0].data.code).not.toContain("__EXAMPLE_BUILD_ID");
-    (0, import_vitest.expect)(result.output[0].data.code).toContain(JSON.stringify(path.join(import_meta.dirname, "ota.ts")));
-  });
-  (0, import_vitest.it)("refuses to build when a user babel plugin has no native port", () => {
-    const withPlugins = plugins => ({
-      customTransformOptions: {
-        vite: {
-          babelConfig: {
-            plugins
-          }
-        }
-      }
-    });
-    (0, import_vitest.expect)(() => (0, import_metroNativeWorker.assertNoUnportedBabelPlugins)(withPlugins([["@vxrn/vite-plugin-metro/babel-plugins/import-meta-env-plugin", {
-      env: {}
-    }], "one/babel-plugin-environment-guard", "hot-updater/babel-plugin"]))).toThrow(/hot-updater\/babel-plugin/);
-    (0, import_vitest.expect)(() => (0, import_metroNativeWorker.assertNoUnportedBabelPlugins)(withPlugins([["@vxrn/vite-plugin-metro/babel-plugins/import-meta-env-plugin", {
-      env: {}
-    }], "one/babel-plugin-environment-guard", ["one/babel-plugin-remove-server-code", {
-      routerRoot: "app"
-    }], ["babel-plugin-module-resolver", {
-      alias: {}
-    }], ["one/babel-plugin-one-router-metro", {}], "one/babel-plugin-inline-one-server-url", "babel-plugin-react-compiler", "react-native-reanimated/plugin"]))).not.toThrow();
-  });
-  (0, import_vitest.it)("turns a server-only import into a throw and drops native-only", () => {
-    const out = (0, import_metroNativeWorker.applyEnvironmentGuard)(`import 'native-only'
-import 'server-only'
-export const a = 1`, "route.ts");
-    (0, import_vitest.expect)(out).not.toContain("native-only");
-    (0, import_vitest.expect)(out).toContain("server-only cannot be imported in a native environment");
-    const parsed = (0, import_oxc_parser.parseSync)("route.ts", out, {
-      lang: "ts"
-    });
-    (0, import_vitest.expect)(parsed.errors).toEqual([]);
-    (0, import_vitest.expect)(parsed.program.body.map(n => n.type)).toContain("ThrowStatement");
-  });
-  (0, import_vitest.it)("reads the router root off one's remove-server-code plugin entry", () => {
-    (0, import_vitest.expect)((0, import_metroNativeWorker.getRemoveServerCodeRouterRoot)({
-      customTransformOptions: {
-        vite: {
-          babelConfig: {
-            plugins: [["one/babel-plugin-remove-server-code", {
-              routerRoot: "src/app"
-            }]]
-          }
-        }
-      }
-    })).toBe("src/app");
-    (0, import_vitest.expect)((0, import_metroNativeWorker.getRemoveServerCodeRouterRoot)({
-      customTransformOptions: {}
-    })).toBe(void 0);
-  });
-});
-(0, import_vitest.describe)("metro babel fallback config names", () => {
-  (0, import_vitest.it)("extends json babel configs just like the compiler detection does", async () => {
-    for (const name of ["babel.config.json", ".babelrc.json"]) {
-      import_vitest.vi.resetModules();
-      const {
-        loadBabelConfig: loadBabelConfig2
-      } = await import("./loadBabelConfig");
-      const tempDir2 = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "vxrn-babel-json-")));
-      try {
-        fs.writeFileSync(path.join(tempDir2, name), JSON.stringify({
-          plugins: []
-        }));
-        (0, import_vitest.expect)(loadBabelConfig2({
-          projectRoot: tempDir2
-        })).toEqual({
-          extends: path.join(tempDir2, name)
-        });
-      } finally {
-        fs.rmSync(tempDir2, {
-          recursive: true,
-          force: true
-        });
-      }
-    }
-    import_vitest.vi.resetModules();
-    const {
-      loadBabelConfig
-    } = await import("./loadBabelConfig");
-    const tempDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "vxrn-babel-json-")));
-    try {
-      fs.writeFileSync(path.join(tempDir, "babel.config.js"), "module.exports = { plugins: [] }");
-      (0, import_vitest.expect)(loadBabelConfig({
-        projectRoot: tempDir
-      })).toEqual({
-        extends: path.join(tempDir, "babel.config.js")
-      });
-    } finally {
-      fs.rmSync(tempDir, {
-        recursive: true,
-        force: true
-      });
-    }
-  });
-});