@tamagui/vite-plugin 2.7.7 → 3.0.0-beta.643.1

package/dist/esm/plugin.mjs

@@ -1,435 +1,1075 @@
-import * as Static from "@tamagui/static-worker";
-import { getPragmaOptions } from "@tamagui/static-worker";
+import Static from "@tamagui/static";
 import { createHash } from "node:crypto";
-import { readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { gzipSync } from "node:zlib";
+import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { loadTamaguiBuildConfig, getLoadPromise, getTamaguiOptions, ensureFullConfigLoaded } from "./loadTamagui.mjs";
-const _pluginRequire = createRequire(typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url));
-const resolve = name => _pluginRequire.resolve(name);
-const normalizePath = value => value.replace(/\\/g, "/");
-const CACHE_KEY = "__tamagui_vite_cache__";
-const CACHE_SIZE_KEY = "__tamagui_vite_cache_size__";
-const PENDING_KEY = "__tamagui_vite_pending__";
-function getSharedCache() {
-  if (!globalThis[CACHE_KEY]) {
-    ;
-    globalThis[CACHE_KEY] = {};
-  }
-  return globalThis[CACHE_KEY];
+import { createIdResolver, createRunnableDevEnvironment, defaultClientConditions, defaultClientMainFields, isRunnableDevEnvironment, resolveConfig } from "vite";
+import { TAMAGUI_EVALUATION_ENVIRONMENT, createViteTamaguiLoader } from "./loadTamagui.mjs";
+import { createCompilerStatsReport, formatCompilerStatsReport } from "./compilerStats.mjs";
+import { ZERO_CSS_FILENAME, ZERO_ISLAND_DIRNAME, assertZeroGraph, buildIsland, createZeroRuntimeController, finalizeZeroCSS, zeroModuleKey } from "./zeroRuntime.mjs";
+
+const environmentSpecificTransformPluginNames = /* @__PURE__ */ new Set(["one:compiler", "one:compiler-css-to-js"]);
+const oneTsconfigPathsPluginName = "one:tsconfig-paths";
+const bareTamaguiPackage = /^@tamagui\/[^/?#]+(?:[/?#]|$)/;
+const inlineEvaluationTamaguiPackage = /^@tamagui\/(?:config|core|slider|web)(?:[/?#]|$)/;
+const externalizablePackageExtensions = /* @__PURE__ */ new Set([
+	"",
+	".js",
+	".mjs",
+	".cjs"
+]);
+function createEvaluationResolveId(plugin, resolveBarePackage) {
+	const resolveId = plugin.resolveId;
+	if (plugin.name !== oneTsconfigPathsPluginName || !resolveId) return resolveId;
+	const handler = typeof resolveId === "object" ? resolveId.handler : resolveId;
+	const evaluationHandler = function(source, ...args) {
+		if (bareTamaguiPackage.test(source)) {
+			const importer = typeof args[0] === "string" ? args[0] : void 0;
+			return resolveBarePackage?.(this.environment, source, importer);
+		}
+		return Reflect.apply(handler, this, [source, ...args]);
+	};
+	return typeof resolveId === "object" ? {
+		...resolveId,
+		handler: evaluationHandler
+	} : evaluationHandler;
+}
+function createEvaluationPluginFacade(plugin, resolveBarePackage) {
+	return {
+		name: plugin.name,
+		enforce: plugin.enforce,
+		resolveId: createEvaluationResolveId(plugin, resolveBarePackage),
+		load: plugin.load,
+		transform: environmentSpecificTransformPluginNames.has(plugin.name) ? void 0 : plugin.transform
+	};
+}
+const tamaguiEvaluationPluginNames = /* @__PURE__ */ new Set([
+	"tamagui",
+	"tamagui-extract",
+	"tamagui-rnw-lite"
+]);
+function isEvaluationUserPlugin(plugin) {
+	return !!(plugin.resolveId || plugin.load || plugin.transform) && plugin.name !== "alias" && !plugin.name.startsWith("native:") && !plugin.name.startsWith("vite:") && !plugin.name.startsWith("builtin:vite-") && !tamaguiEvaluationPluginNames.has(plugin.name);
+}
+function isEvaluationCorePlugin(plugin) {
+	return plugin.name === "alias" || plugin.name.startsWith("vite:") || plugin.name.startsWith("builtin:vite-");
+}
+function isConfiguredEvaluationPackage(source, packages) {
+	const cleanSource = source.split(/[?#]/, 1)[0];
+	return [...packages].some((packageName) => cleanSource === packageName || cleanSource.startsWith(`${packageName}/`));
+}
+function getEvaluationPackageName(source) {
+	if (!source) return;
+	const cleanSource = source.split(/[?#]/, 1)[0];
+	if (!cleanSource || cleanSource.startsWith(".") || cleanSource.startsWith("#") || cleanSource.startsWith("\0") || path.isAbsolute(cleanSource)) return;
+	if (cleanSource.startsWith("@")) {
+		const [scope, name2] = cleanSource.split("/");
+		return scope && name2 ? `${scope}/${name2}` : void 0;
+	}
+	const [name] = cleanSource.split("/");
+	return name && !path.extname(name) ? name : void 0;
+}
+function getInstalledTamaguiPackages(root, configuredEvaluationPackages) {
+	const packageRequire = createRequire(path.join(root, "package.json"));
+	const packages = /* @__PURE__ */ new Set();
+	for (const modulePath of packageRequire.resolve.paths("@tamagui/core") || []) {
+		const scopePath = path.join(modulePath, "@tamagui");
+		if (!existsSync(scopePath)) continue;
+		for (const entry of readdirSync(scopePath, { withFileTypes: true })) {
+			if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+			const packageName = `@tamagui/${entry.name}`;
+			if (!inlineEvaluationTamaguiPackage.test(packageName) && !configuredEvaluationPackages.has(packageName)) packages.add(packageName);
+		}
+	}
+	return packages;
+}
+function getEvaluationResolve(resolve2, root, disableTsconfigPaths, configuredEvaluationPackages) {
+	return {
+		...resolve2,
+		external: resolve2.external === true ? true : [.../* @__PURE__ */ new Set([...(resolve2.external || []).filter((packageName) => !isConfiguredEvaluationPackage(packageName, configuredEvaluationPackages)), ...getInstalledTamaguiPackages(root, configuredEvaluationPackages)])],
+		...disableTsconfigPaths && { tsconfigPaths: false }
+	};
+}
+function isConfiguredExternalPackage(source, external) {
+	if (external === true) return true;
+	const cleanSource = source.split(/[?#]/, 1)[0];
+	return external?.some((packageName) => cleanSource === packageName || cleanSource.startsWith(`${packageName}/`));
+}
+function createServeEvaluationConfig(config, configuredEvaluationPackages) {
+	const environment = config.environments[TAMAGUI_EVALUATION_ENVIRONMENT];
+	let packageResolver;
+	const resolveBarePackage = async (evaluationEnvironment, source, importer) => {
+		const resolved = await packageResolver?.(evaluationEnvironment, source, importer);
+		if (!resolved) return;
+		const cleanResolved = resolved.split(/[?#]/, 1)[0];
+		if (!inlineEvaluationTamaguiPackage.test(source) && !isConfiguredEvaluationPackage(source, configuredEvaluationPackages) && isConfiguredExternalPackage(source, evaluationEnvironment.config.resolve.external)) return {
+			id: source,
+			external: true
+		};
+		if (inlineEvaluationTamaguiPackage.test(source) || isConfiguredEvaluationPackage(source, configuredEvaluationPackages) || !normalizePath(cleanResolved).includes("/node_modules/") || !externalizablePackageExtensions.has(path.extname(cleanResolved))) return resolved;
+		return {
+			id: source,
+			external: true
+		};
+	};
+	const plugins = environment.plugins.flatMap((plugin) => {
+		if (isEvaluationCorePlugin(plugin)) return [plugin];
+		if (isEvaluationUserPlugin(plugin)) return [createEvaluationPluginFacade(plugin, resolveBarePackage)];
+		return [];
+	});
+	const resolve2 = getEvaluationResolve(environment.resolve, config.root, plugins.some((plugin) => plugin.name === oneTsconfigPathsPluginName), configuredEvaluationPackages);
+	const evaluationConfig = {
+		...config,
+		environments: {
+			...config.environments,
+			[TAMAGUI_EVALUATION_ENVIRONMENT]: {
+				...environment,
+				plugins,
+				resolve: resolve2
+			}
+		}
+	};
+	packageResolver = createIdResolver(evaluationConfig);
+	return evaluationConfig;
 }
-function getSharedCacheSize() {
-  return globalThis[CACHE_SIZE_KEY] || 0;
+async function createOwnedEvaluationConfig(config, configuredEvaluationPackages) {
+	const environment = config.environments[TAMAGUI_EVALUATION_ENVIRONMENT];
+	const plugins = environment.plugins.filter(isEvaluationUserPlugin).map((plugin) => createEvaluationPluginFacade(plugin));
+	const resolve2 = getEvaluationResolve(environment.resolve, config.root, plugins.some((plugin) => plugin.name === oneTsconfigPathsPluginName), configuredEvaluationPackages);
+	const { createEnvironment: _createEnvironment, ...dev } = environment.dev;
+	return resolveConfig({
+		configFile: false,
+		root: config.root,
+		mode: config.mode,
+		logLevel: config.logLevel,
+		plugins,
+		define: environment.define,
+		resolve: resolve2,
+		environments: { [TAMAGUI_EVALUATION_ENVIRONMENT]: {
+			consumer: environment.consumer,
+			keepProcessEnv: environment.keepProcessEnv,
+			define: environment.define,
+			resolve: resolve2,
+			optimizeDeps: environment.optimizeDeps,
+			dev: {
+				...dev,
+				moduleRunnerTransform: true
+			}
+		} }
+	}, "serve", config.mode);
 }
-function setSharedCacheSize(size) {
-  ;
-  globalThis[CACHE_SIZE_KEY] = size;
+const _pluginRequire = createRequire(typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url));
+const resolve = (name) => _pluginRequire.resolve(name);
+const normalizePath = (value) => value.replace(/\\/g, "/");
+const PLUGIN_INSTANCE_KEY = "__tamagui_vite_plugin_instance__";
+function reportCompilerStats(root, reports) {
+	const report = createCompilerStatsReport(root, reports);
+	console.info(formatCompilerStatsReport(report, process.env.TAMAGUI_COMPILER_STATS === "verbose"));
+	if (process.env.TAMAGUI_COMPILER_STATS_FILE) {
+		const outputPath = path.resolve(root, process.env.TAMAGUI_COMPILER_STATS_FILE);
+		writeFileSync(outputPath, `${JSON.stringify(report, null, 2)}
+`);
+		console.info(`[tamagui] compiler stats JSON: ${path.relative(process.cwd(), outputPath)}`);
+	}
 }
-function clearSharedCache() {
-  ;
-  globalThis[CACHE_KEY] = {};
-  globalThis[CACHE_SIZE_KEY] = 0;
+function getNextPluginInstanceId() {
+	const next = (globalThis[PLUGIN_INSTANCE_KEY] || 0) + 1;
+	globalThis[PLUGIN_INSTANCE_KEY] = next;
+	return next;
 }
 function isInstalled(projectRoot, id) {
-  try {
-    const req = createRequire(path.join(projectRoot, "package.json"));
-    req.resolve(id);
-    return true;
-  } catch {
-    return false;
-  }
+	try {
+		createRequire(path.join(projectRoot, "package.json")).resolve(id);
+		return true;
+	} catch {
+		return false;
+	}
 }
 function addIfInstalled(userConf, projectRoot, ids) {
-  const root = projectRoot || process.cwd();
-  userConf.optimizeDeps ||= {};
-  userConf.optimizeDeps.include ||= [];
-  for (const id of ids) {
-    if (!userConf.optimizeDeps.include.includes(id) && isInstalled(root, id)) {
-      userConf.optimizeDeps.include.push(id);
-    }
-  }
-}
-function getPendingExtractions() {
-  if (!globalThis[PENDING_KEY]) {
-    ;
-    globalThis[PENDING_KEY] = /* @__PURE__ */new Map();
-  }
-  return globalThis[PENDING_KEY];
+	const root = projectRoot || process.cwd();
+	userConf.optimizeDeps ||= {};
+	userConf.optimizeDeps.include ||= [];
+	for (const id of ids) if (!userConf.optimizeDeps.include.includes(id) && isInstalled(root, id)) userConf.optimizeDeps.include.push(id);
 }
 function tamaguiAliases(options = {}) {
-  const aliases = [];
-  if (options.svg) {
-    aliases.push({
-      find: "react-native-svg",
-      replacement: resolve("@tamagui/react-native-svg")
-    });
-  }
-  if (options.rnwLite) {
-    const rnwlBase = path.dirname(resolve("@tamagui/react-native-web-lite/package.json"));
-    const rnwl = normalizePath(path.join(rnwlBase, options.rnwLite === "without-animated" ? "dist/esm/without-animated.mjs" : "dist/esm/index.mjs"));
-    const rnwlFlatModules = readdirSync(path.join(rnwlBase, "dist/esm")).filter(file => file.endsWith(".mjs")).map(file => file.slice(0, -".mjs".length)).filter(name => /^[A-Za-z0-9_]+$/.test(name));
-    aliases.push({
-      // map deep RNW paths like dist/exports/StyleSheet/preprocess to rnw-lite's flat structure
-      // extracts the final path segment (e.g. "preprocess" or "createReactDOMStyle")
-      //
-      // only match segments rnw-lite actually ships. it implements part of
-      // react-native-web's export surface, not all of it, and there is no
-      // flat StyleSheet.mjs. expo sdk 56 added
-      // expo/src/launch/AppRegistry.web.tsx, which does
-      // `require('react-native-web/dist/exports/StyleSheet')`; the unscoped
-      // pattern rewrote that onto a file that does not exist and failed the
-      // whole optimize. anything lite lacks now falls through to the real
-      // package.
-      find: new RegExp(`^react-native(?:-web)?\\/dist\\/(?:exports|modules)\\/(?:.*\\/)?(${rnwlFlatModules.join("|")})$`),
-      replacement: `${normalizePath(rnwlBase)}/dist/esm/$1.mjs`
-    }, {
-      find: /^react-native$/,
-      replacement: rnwl
-    }, {
-      find: /^react-native\/(Libraries\/Utilities\/codegenNativeComponent|Libraries\/Utilities\/codegenNativeCommand)$/,
-      replacement: `${rnwlBase}/$1`
-    }, {
-      find: "react-native/package.json",
-      replacement: resolve("@tamagui/react-native-web-lite/package.json")
-    }, {
-      find: /^react-native-web$/,
-      replacement: rnwl
-    });
-  }
-  return aliases;
+	const aliases = [];
+	if (options.svg) aliases.push({
+		find: "react-native-svg",
+		replacement: resolve("@tamagui/react-native-svg")
+	});
+	if (options.rnwLite) {
+		const rnwlBase = path.dirname(resolve("@tamagui/react-native-web-lite/package.json"));
+		const rnwl = normalizePath(path.join(rnwlBase, options.rnwLite === "without-animated" ? "dist/esm/without-animated.mjs" : "dist/esm/index.mjs"));
+		const rnwlFlatModules = readdirSync(path.join(rnwlBase, "dist/esm")).filter((file) => file.endsWith(".mjs")).map((file) => file.slice(0, -4)).filter((name) => /^[A-Za-z0-9_]+$/.test(name));
+		aliases.push({
+			find: new RegExp(`^react-native(?:-web)?\\/dist\\/(?:exports|modules)\\/(?:.*\\/)?(${rnwlFlatModules.join("|")})$`),
+			replacement: `${normalizePath(rnwlBase)}/dist/esm/$1.mjs`
+		}, {
+			find: /^react-native$/,
+			replacement: rnwl
+		}, {
+			find: /^react-native\/(Libraries\/Utilities\/codegenNativeComponent|Libraries\/Utilities\/codegenNativeCommand)$/,
+			replacement: `${rnwlBase}/$1`
+		}, {
+			find: "react-native/package.json",
+			replacement: resolve("@tamagui/react-native-web-lite/package.json")
+		}, {
+			find: /^react-native-web$/,
+			replacement: rnwl
+		});
+	}
+	return aliases;
 }
-function tamaguiPlugin({
-  disableResolveConfig,
-  ...tamaguiOptionsIn
-} = {}) {
-  let shouldExtract = !tamaguiOptionsIn.disableExtraction;
-  let watcher;
-  const enableNativeEnv = !!globalThis.__vxrnEnableNativeEnv;
-  const extensions = [`.web.mjs`, `.web.js`, `.web.jsx`, `.web.ts`, `.web.tsx`, ".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx", ".json"];
-  loadTamaguiBuildConfig(tamaguiOptionsIn);
-  const ensureLoaded = async () => {
-    const promise = getLoadPromise();
-    if (promise) await promise;
-    const options = getTamaguiOptions();
-    if (options) {
-      shouldExtract = !options.disableExtraction;
-    }
-    return options;
-  };
-  const getHash = input => createHash("sha1").update(input).digest("base64");
-  const memoryCache = getSharedCache();
-  const cssMap = /* @__PURE__ */new Map();
-  let config;
-  let server;
-  const virtualExt = `.tamagui.css`;
-  const getAbsoluteVirtualFileId = filePath => {
-    if (filePath.startsWith(config.root)) {
-      return filePath;
-    }
-    return normalizePath(path.join(config.root, filePath));
-  };
-  function isNotClient(environment) {
-    return environment?.name && environment.name !== "client";
-  }
-  function isNative(environment) {
-    return environment?.name && (environment.name === "ios" || environment.name === "android");
-  }
-  function invalidateModule(absoluteId) {
-    if (!server) return;
-    const {
-      moduleGraph
-    } = server;
-    const modules = moduleGraph.getModulesByFile(absoluteId);
-    if (modules) {
-      for (const module of modules) {
-        moduleGraph.invalidateModule(module);
-        module.lastHMRTimestamp = module.lastInvalidationTimestamp || Date.now();
-      }
-    }
-  }
-  const basePlugin = {
-    name: "tamagui",
-    enforce: "pre",
-    configureServer(_server) {
-      server = _server;
-    },
-    async buildEnd() {
-      await watcher?.then(res => {
-        res?.dispose();
-      });
-    },
-    async config(_, env) {
-      const options = await ensureLoaded();
-      if (!options) {
-        throw new Error(`No tamagui options loaded`);
-      }
-      const useReactNativeWebLite = tamaguiOptionsIn.useReactNativeWebLite ?? options.useReactNativeWebLite;
-      if (!options.disableWatchTamaguiConfig) {
-        watcher = Static.watchTamaguiConfig({
-          components: ["tamagui"],
-          config: "./src/tamagui.config.ts",
-          ...options
-        }).catch(err => {
-          console.error(` [Tamagui] Error watching config: ${err}`);
-        });
-      }
-      return {
-        envPrefix: ["TAMAGUI_"],
-        environments: {
-          client: {
-            define: {
-              "process.env.TAMAGUI_IS_CLIENT": JSON.stringify(true),
-              "process.env.TAMAGUI_ENVIRONMENT": '"client"'
-            }
-          }
-        },
-        define: {
-          // reanimated support
-          _frameTimestamp: void 0,
-          _WORKLET: false,
-          __DEV__: `${env.mode === "development"}`,
-          "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || env.mode),
-          "process.env.ENABLE_RSC": JSON.stringify(process.env.ENABLE_RSC || ""),
-          "process.env.ENABLE_STEPS": JSON.stringify(process.env.ENABLE_STEPS || ""),
-          "process.env.IS_STATIC": JSON.stringify(false),
-          ...(env.mode === "production" && {
-            "process.env.TAMAGUI_OPTIMIZE_THEMES": JSON.stringify(true)
-          })
-        },
-        resolve: disableResolveConfig || enableNativeEnv ? {} : {
-          extensions,
-          alias: {
-            ...(options.platform !== "native" && {
-              "react-native/Libraries/Renderer/shims/ReactFabric": resolve("@tamagui/proxy-worm"),
-              "react-native/Libraries/Utilities/codegenNativeComponent": resolve("@tamagui/proxy-worm"),
-              "react-native-svg": resolve("@tamagui/react-native-svg"),
-              ...(!useReactNativeWebLite && {
-                "react-native": resolve("react-native-web")
-              })
-            })
-          }
-        }
-      };
-    }
-  };
-  const rnwLitePlugin = {
-    name: "tamagui-rnw-lite",
-    // framework plugins may add their default react-native-web aliases from a
-    // normal config hook. apply the explicit lite choice after those defaults.
-    enforce: "post",
-    config() {
-      if (enableNativeEnv) {
-        return {};
-      }
-      const options = getTamaguiOptions();
-      const useReactNativeWebLite = tamaguiOptionsIn.useReactNativeWebLite ?? options?.useReactNativeWebLite;
-      if (!useReactNativeWebLite) {
-        return {};
-      }
-      const include = [];
-      for (const dependency of ["memoize-one", "@react-native/normalize-color"]) {
-        if (isInstalled(process.cwd(), dependency)) include.push(dependency);
-      }
-      return {
-        resolve: {
-          alias: tamaguiAliases({
-            rnwLite: useReactNativeWebLite
-          })
-        },
-        optimizeDeps: {
-          // upstream react-native-web must not be pre-bundled when aliased to lite
-          exclude: ["react-native-web"],
-          include
-        }
-      };
-    }
-  };
-  const extractPlugin = {
-    name: "tamagui-extract",
-    enforce: "pre",
-    async config(userConf) {
-      const options = await ensureLoaded();
-      userConf.optimizeDeps ||= {};
-      userConf.optimizeDeps.include ||= [];
-      userConf.optimizeDeps.include.push("inline-style-prefixer");
-      addIfInstalled(userConf, userConf.root, ["@tamagui/toast", "@tamagui/toast/v2", "@tamagui/sheet", "@tamagui/sheet/controller"]);
-      userConf.resolve ||= {};
-      userConf.resolve.dedupe ||= [];
-      for (const id of ["tamagui", "@tamagui/core", "@tamagui/web", "@tamagui/toast", "@tamagui/sheet"]) {
-        if (!userConf.resolve.dedupe.includes(id) && isInstalled(userConf.root || process.cwd(), id)) {
-          userConf.resolve.dedupe.push(id);
-        }
-      }
-      if (!shouldExtract) return;
-      userConf.optimizeDeps.include.push("@tamagui/core/inject-styles");
-    },
-    async configResolved(resolvedConfig) {
-      config = resolvedConfig;
-    },
-    async resolveId(source) {
-      if (!shouldExtract) return;
-      if (isNative(this.environment)) {
-        return;
-      }
-      if (isNotClient(this.environment)) {
-        return;
-      }
-      const [validId, query] = source.split("?");
-      if (!validId.endsWith(virtualExt)) {
-        return;
-      }
-      const absoluteId = source.startsWith(config.root) ? source : getAbsoluteVirtualFileId(validId);
-      if (cssMap.has(absoluteId)) {
-        return absoluteId + (query ? `?${query}` : "");
-      }
-    },
-    async load(id) {
-      if (!shouldExtract) return;
-      const options = getTamaguiOptions();
-      if (options?.disable) {
-        return;
-      }
-      if (isNative(this.environment)) {
-        return;
-      }
-      if (isNotClient(this.environment)) {
-        return;
-      }
-      const [validId] = id.split("?");
-      return cssMap.get(validId);
-    },
-    transform: {
-      order: "pre",
-      async handler(code, id) {
-        const options = await ensureLoaded();
-        await ensureFullConfigLoaded();
-        if (options?.disable) {
-          return;
-        }
-        if (isNative(this.environment)) {
-          return;
-        }
-        const [validId] = id.split("?");
-        if (!validId.endsWith(".tsx")) {
-          return;
-        }
-        const {
-          shouldDisable,
-          shouldPrintDebug
-        } = await getPragmaOptions({
-          source: code,
-          path: validId
-        });
-        if (shouldPrintDebug) {
-          console.trace(`Current file: ${id} in environment: ${this.environment?.name}, shouldDisable: ${shouldDisable}`);
-          console.info(`
-
-Original source:
-${code}
-
+function createTamaguiNativePlugin(tamaguiOptionsIn, nativeContext) {
+	let compilerFrontend = new Static.CompilerFrontend();
+	const projectDependencies = /* @__PURE__ */ new Set();
+	let root = nativeContext?.root || process.cwd();
+	let projectPromise = null;
+	let rebuildProject = false;
+	let generation = 0;
+	const loadProject = async (resolveModule) => {
+		if (projectPromise) return projectPromise;
+		const shouldRebuild = rebuildProject;
+		rebuildProject = false;
+		const guarded = (async () => {
+			projectDependencies.clear();
+			const loadedOptions = await Static.loadTamaguiBuildConfigAsync({
+				...tamaguiOptionsIn,
+				root,
+				platform: "native",
+				outputCSS: void 0
+			});
+			const options = {
+				...loadedOptions,
+				root,
+				outputCSS: void 0
+			};
+			for (const dependency of Static.getTamaguiBuildConfigDependencies(loadedOptions)) projectDependencies.add(normalizePath(dependency));
+			if (options.disable || options.disableExtraction) return null;
+			const project = await Static.loadCompilerProject({
+				root,
+				target: "native",
+				options,
+				rebuild: shouldRebuild,
+				generation: `vite-native:${generation + 1}`,
+				missingProjectMessage: "Unable to load the Tamagui project for Vite native compilation",
+				async resolveComponents(moduleNames) {
+					return Promise.all(moduleNames.map(async (moduleName) => {
+						const id = await resolveModule(moduleName);
+						projectDependencies.add(normalizePath(id.split(/[?#]/, 1)[0]));
+						return {
+							moduleName,
+							id
+						};
+					}));
+				}
+			});
+			for (const dependency of project.projectInfo.dependencies ?? []) projectDependencies.add(normalizePath(dependency.split(/[?#]/, 1)[0]));
+			const configPath = options.config || "tamagui.config.ts";
+			projectDependencies.add(normalizePath(path.isAbsolute(configPath) ? configPath : path.resolve(root, configPath)));
+			const buildFile = options.buildFile || "tamagui.build.ts";
+			projectDependencies.add(normalizePath(path.isAbsolute(buildFile) ? buildFile : path.resolve(root, buildFile)));
+			if (options.themeBuilder?.input) projectDependencies.add(normalizePath(path.isAbsolute(options.themeBuilder.input) ? options.themeBuilder.input : path.resolve(root, options.themeBuilder.input)));
+			generation++;
+			return project;
+		})().catch((error) => {
+			if (projectPromise === guarded) projectPromise = null;
+			rebuildProject = true;
+			throw error;
+		});
+		projectPromise = guarded;
+		return projectPromise;
+	};
+	return {
+		name: "tamagui-native-compiler",
+		enforce: "post",
+		configResolved(config) {
+			root = config.root;
+		},
+		watchChange(id) {
+			if (projectDependencies.has(normalizePath(id.split(/[?#]/, 1)[0]))) {
+				rebuildProject = true;
+				projectPromise = null;
+				compilerFrontend = new Static.CompilerFrontend();
+			}
+		},
+		transform: {
+			order: "pre",
+			async handler(code, id) {
+				const environmentName = nativeContext?.platform || this.environment?.name;
+				if (environmentName !== "ios" && environmentName !== "android") return;
+				const [validId] = id.split("?");
+				if (!validId || !/\.[jt]sx$/.test(validId) || normalizePath(validId).split("/").includes("node_modules")) return;
+				const { shouldDisable } = await Static.getPragmaOptions({
+					source: code,
+					path: validId
+				});
+				if (shouldDisable) return;
+				const resolve2 = async (specifier, importer) => {
+					const resolution = await this.resolve(specifier, importer, { skipSelf: true });
+					return resolution ? {
+						id: resolution.id,
+						external: resolution.external === true
+					} : null;
+				};
+				const project = await loadProject(async (specifier) => {
+					const resolution = await resolve2(specifier, path.join(root, "__tamagui_native.tsx"));
+					if (!resolution) throw new Error(`Unable to resolve native compiler component ${specifier}`);
+					return resolution.id;
+				});
+				if (!project) return;
+				for (const dependency of projectDependencies) this.addWatchFile(dependency);
+				const result = await compilerFrontend.compile({
+					id: validId,
+					source: code,
+					root,
+					target: "native",
+					project,
+					resolve: resolve2,
+					load: async (dependencyId) => {
+						const cleanDependencyId = dependencyId.split(/[?#]/, 1)[0];
+						if (!path.isAbsolute(cleanDependencyId)) return null;
+						try {
+							return await readFile(cleanDependencyId, "utf8");
+						} catch {
+							return null;
+						}
+					}
+				});
+				for (const dependency of result.plan.dependencies) if (path.isAbsolute(dependency)) this.addWatchFile(dependency);
+				if (result.plan.css) throw new Error(`Native Tamagui compilation produced unexpected CSS for ${validId}`);
+				return result.output.changed ? {
+					code: result.output.code,
+					map: result.output.map
+				} : void 0;
+			}
+		}
+	};
+}
+function tamaguiNativePlugin(tamaguiOptionsIn = {}) {
+	const plugin = createTamaguiNativePlugin(tamaguiOptionsIn);
+	const api = plugin.api && typeof plugin.api === "object" ? plugin.api : {};
+	return {
+		...plugin,
+		api: {
+			...api,
+			vxrnNative: (context) => createTamaguiNativePlugin(tamaguiOptionsIn, context)
+		}
+	};
+}
+function createTamaguiPlugins({ disableResolveConfig, wrapExtractedCSS = (css) => css, zeroIslandBuild, ...tamaguiOptionsIn } = {}) {
+	let shouldExtract = !tamaguiOptionsIn.disableExtraction;
+	const enableNativeEnv = !!globalThis.__vxrnEnableNativeEnv;
+	const tamaguiLoader = createViteTamaguiLoader(tamaguiOptionsIn);
+	const compilerFrontend = new Static.CompilerFrontend();
+	const pluginInstanceId = getNextPluginInstanceId();
+	const configuredEvaluationPackages = /* @__PURE__ */ new Set();
+	let buildEnvironmentPromise = null;
+	let buildCleanupPromise = null;
+	const activeBuildEnvironments = /* @__PURE__ */ new Set();
+	const compilerReports = process.env.TAMAGUI_COMPILER_STATS || process.env.TAMAGUI_COMPILER_STATS_FILE ? /* @__PURE__ */ new Map() : null;
+	const releaseBuildEnvironment = async (environment) => {
+		if (!activeBuildEnvironments.delete(environment) || activeBuildEnvironments.size) return;
+		if (compilerReports?.size) reportCompilerStats(config?.root ?? process.cwd(), compilerReports);
+		const currentCleanup = Promise.resolve().then(async () => {
+			try {
+				await tamaguiLoader.cleanup();
+			} finally {
+				buildEnvironmentPromise = null;
+			}
+		});
+		buildCleanupPromise = currentCleanup;
+		try {
+			await currentCleanup;
+		} finally {
+			if (buildCleanupPromise === currentCleanup) buildCleanupPromise = null;
+		}
+	};
+	const extensions = [
+		`.web.mjs`,
+		`.web.js`,
+		`.web.jsx`,
+		`.web.ts`,
+		`.web.tsx`,
+		".mjs",
+		".js",
+		".mts",
+		".ts",
+		".jsx",
+		".tsx",
+		".json"
+	];
+	const getEvaluationEnvironmentOptions = () => ({
+		consumer: "server",
+		keepProcessEnv: true,
+		define: {
+			"process.env.IS_STATIC": JSON.stringify("is_static"),
+			"process.env.TAMAGUI_IS_CLIENT": JSON.stringify(false),
+			"process.env.TAMAGUI_IS_SERVER": JSON.stringify(true),
+			"process.env.TAMAGUI_TARGET": JSON.stringify("web"),
+			"process.env.TAMAGUI_ENVIRONMENT": JSON.stringify(TAMAGUI_EVALUATION_ENVIRONMENT),
+			"process.env.TAMAGUI_RUNTIME": JSON.stringify("full"),
+			"process.env.TAMAGUI_DID_OUTPUT_CSS": JSON.stringify(""),
+			"process.env.VITE_ENVIRONMENT": JSON.stringify("ssr"),
+			"process.env.TAMAGUI_DISABLE_SLIDER_INTERVAL": JSON.stringify("1")
+		},
+		resolve: {
+			conditions: [...defaultClientConditions],
+			mainFields: [...defaultClientMainFields],
+			noExternal: [inlineEvaluationTamaguiPackage, ...configuredEvaluationPackages],
+			extensions
+		},
+		dev: {
+			createEnvironment(name, resolved) {
+				return createRunnableDevEnvironment(name, createServeEvaluationConfig(resolved, configuredEvaluationPackages));
+			},
+			moduleRunnerTransform: true
+		}
+	});
+	tamaguiLoader.loadTamaguiBuildConfig();
+	const ensureLoaded = async () => {
+		const promise = tamaguiLoader.getLoadPromise();
+		if (promise) await promise;
+		const options = tamaguiLoader.getTamaguiOptions();
+		if (options) shouldExtract = !options.disableExtraction;
+		return options;
+	};
+	const getHash = (input) => createHash("sha1").update(input).digest("base64");
+	const cssMap = /* @__PURE__ */ new Map();
+	const transformedModuleIds = /* @__PURE__ */ new Set();
+	const compilerHotUpdateSignatures = /* @__PURE__ */ new Map();
+	const compilerHotReloadSignatures = /* @__PURE__ */ new Map();
+	let config;
+	let server;
+	let zero = null;
+	let zeroReceipt = null;
+	let zeroBuildFailed = false;
+	let globalCSS = null;
+	let globalCSSExpected = null;
+	let zeroHtmlEntries = 0;
+	let zeroDevIslands = Promise.resolve();
+	const virtualExt = `.tamagui.css`;
+	const getAbsoluteVirtualFileId = (filePath) => {
+		if (filePath.startsWith(config.root)) return filePath;
+		return normalizePath(path.join(config.root, filePath));
+	};
+	const isAppJSXSource = (filePath) => {
+		if (!/\.[jt]sx$/.test(filePath)) return false;
+		const relative = path.relative(config.root, filePath);
+		return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !relative.split(path.sep).includes("node_modules");
+	};
+	const isFrameworkAnalysisRequest = (id) => id.includes("__react-router-build-client-route");
+	function isNotClient(environment) {
+		return environment?.name && environment.name !== "client";
+	}
+	function isNative(environment) {
+		return environment?.name && (environment.name === "ios" || environment.name === "android");
+	}
+	function invalidateCompilerModules() {
+		if (server) {
+			const ids = /* @__PURE__ */ new Set([...transformedModuleIds, ...cssMap.keys()]);
+			for (const environment of Object.values(server.environments)) {
+				if (environment.name === TAMAGUI_EVALUATION_ENVIRONMENT) continue;
+				for (const id of ids) {
+					const modules = environment.moduleGraph.getModulesByFile(id);
+					if (!modules) continue;
+					for (const module of modules) environment.moduleGraph.invalidateModule(module);
+				}
+			}
+		}
+		cssMap.clear();
+	}
+	return {
+		plugins: [
+			{
+				name: "tamagui",
+				enforce: "pre",
+				configureServer(_server) {
+					server = _server;
+					const evaluationEnvironment = server.environments[TAMAGUI_EVALUATION_ENVIRONMENT];
+					if (!isRunnableDevEnvironment(evaluationEnvironment)) throw new Error(`The ${TAMAGUI_EVALUATION_ENVIRONMENT} Vite environment must support ModuleRunner evaluation`);
+					tamaguiLoader.setEnvironment(evaluationEnvironment);
+				},
+				async buildEnd() {
+					await releaseBuildEnvironment(this.environment);
+				},
+				async config(userConfig, env) {
+					const options = await ensureLoaded();
+					if (!options) throw new Error(`No tamagui options loaded`);
+					const useReactNativeWebLite = tamaguiOptionsIn.useReactNativeWebLite ?? options.useReactNativeWebLite;
+					for (const source of [options.config, ...options.components || []]) {
+						const packageName = getEvaluationPackageName(source);
+						if (packageName) configuredEvaluationPackages.add(packageName);
+					}
+					const resolvedRoot = userConfig.root ? path.resolve(userConfig.root) : process.cwd();
+					zero = zeroIslandBuild ? null : await createZeroRuntimeController(options, resolvedRoot, userConfig.base || "/");
+					globalCSS = zeroIslandBuild || env.command !== "build" ? null : Static.resolveGlobalCSSOwnership(options, resolvedRoot);
+					return {
+						envPrefix: ["TAMAGUI_"],
+						environments: {
+							client: { define: {
+								"process.env.TAMAGUI_IS_CLIENT": JSON.stringify(true),
+								"process.env.TAMAGUI_ENVIRONMENT": "\"client\"",
+								...zero?.isEnforcing && { "process.env.TAMAGUI_RUNTIME": JSON.stringify("zero") },
+								...globalCSS && { "process.env.TAMAGUI_DID_OUTPUT_CSS": JSON.stringify("1") }
+							} },
+							[TAMAGUI_EVALUATION_ENVIRONMENT]: getEvaluationEnvironmentOptions()
+						},
+						define: {
+							"process.env.TAMAGUI_RUNTIME": JSON.stringify("full"),
+							_frameTimestamp: void 0,
+							_WORKLET: false,
+							__DEV__: `${env.mode === "development"}`,
+							"process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || env.mode),
+							"process.env.ENABLE_RSC": JSON.stringify(process.env.ENABLE_RSC || ""),
+							"process.env.ENABLE_STEPS": JSON.stringify(process.env.ENABLE_STEPS || ""),
+							"process.env.IS_STATIC": JSON.stringify(false),
+							...env.mode === "production" && { "process.env.TAMAGUI_OPTIMIZE_THEMES": JSON.stringify(true) }
+						},
+						resolve: disableResolveConfig || enableNativeEnv ? {} : {
+							extensions,
+							alias: { ...options.platform !== "native" && {
+								"react-native/Libraries/Renderer/shims/ReactFabric": resolve("@tamagui/proxy-worm"),
+								"react-native/Libraries/Utilities/codegenNativeComponent": resolve("@tamagui/proxy-worm"),
+								"react-native-svg": resolve("@tamagui/react-native-svg"),
+								...!useReactNativeWebLite && { "react-native": resolve("react-native-web") }
+							} }
+						}
+					};
+				}
+			},
+			{
+				name: "tamagui-rnw-lite",
+				enforce: "post",
+				config() {
+					if (enableNativeEnv) return {};
+					const options = tamaguiLoader.getTamaguiOptions();
+					const useReactNativeWebLite = tamaguiOptionsIn.useReactNativeWebLite ?? options?.useReactNativeWebLite;
+					if (!useReactNativeWebLite) return {};
+					const include = [];
+					for (const dependency of ["memoize-one", "@react-native/normalize-color"]) if (isInstalled(process.cwd(), dependency)) include.push(dependency);
+					return {
+						resolve: { alias: tamaguiAliases({ rnwLite: useReactNativeWebLite }) },
+						ssr: { noExternal: [
+							/^@tamagui\//,
+							"tamagui",
+							"react-native",
+							"react-native-web"
+						] },
+						optimizeDeps: {
+							exclude: ["react-native-web"],
+							include
+						}
+					};
+				}
+			},
+			{
+				name: "tamagui-extract",
+				enforce: "pre",
+				async config(userConf) {
+					await ensureLoaded();
+					userConf.optimizeDeps ||= {};
+					userConf.optimizeDeps.include ||= [];
+					userConf.optimizeDeps.include.push("inline-style-prefixer");
+					addIfInstalled(userConf, userConf.root, ["@react-native/normalize-color"]);
+					addIfInstalled(userConf, userConf.root, [
+						"@tamagui/core",
+						"@tamagui/web",
+						"@tamagui/toast",
+						"@tamagui/sheet",
+						"@tamagui/sheet/controller"
+					]);
+					userConf.resolve ||= {};
+					userConf.resolve.dedupe ||= [];
+					for (const id of [
+						"tamagui",
+						"@tamagui/core",
+						"@tamagui/web",
+						"@tamagui/toast",
+						"@tamagui/sheet"
+					]) if (!userConf.resolve.dedupe.includes(id) && isInstalled(userConf.root || process.cwd(), id)) userConf.resolve.dedupe.push(id);
+					if (!shouldExtract) return;
+					userConf.optimizeDeps.include.push("@tamagui/core/inject-styles");
+				},
+				async configResolved(resolvedConfig) {
+					config = resolvedConfig;
+				},
+				async buildStart() {
+					const buildConfig = this.environment.getTopLevelConfig();
+					if (buildConfig.command !== "build") return;
+					const pendingCleanup = buildCleanupPromise;
+					if (pendingCleanup) await pendingCleanup;
+					const buildEnvironment = this.environment;
+					activeBuildEnvironments.add(buildEnvironment);
+					try {
+						if (!tamaguiLoader.getEnvironment()) {
+							await tamaguiLoader.loadTamaguiBuildConfig();
+							buildEnvironmentPromise ||= (async () => {
+								const evaluationEnvironment = createRunnableDevEnvironment(TAMAGUI_EVALUATION_ENVIRONMENT, await createOwnedEvaluationConfig(buildConfig, configuredEvaluationPackages), { hot: false });
+								try {
+									await evaluationEnvironment.init();
+								} catch (error) {
+									await evaluationEnvironment.close().catch(() => void 0);
+									throw error;
+								}
+								tamaguiLoader.setEnvironment(evaluationEnvironment, { owned: true });
+							})();
+							await buildEnvironmentPromise;
+						}
+					} catch (error) {
+						await releaseBuildEnvironment(buildEnvironment);
+						throw error;
+					}
+				},
+				hotUpdate: {
+					order: "post",
+					async handler(options) {
+						if (!tamaguiLoader.isEvaluationDependency(options.file)) {
+							if (this.environment.name !== "client") return;
+							const source = options.type === "delete" ? null : await options.read();
+							const affectedModules = /* @__PURE__ */ new Set();
+							const compilerHmrRoots = new Set(compilerFrontend.dependentsOf(options.file));
+							if (compilerHmrRoots.size || compilerFrontend.has(options.file)) compilerHmrRoots.add(options.file);
+							if (compilerFrontend.has(options.file) || compilerHmrRoots.size > 0) {
+								if (!(await ensureLoaded())?.disable) {
+									const invalidatedIds = options.type === "delete" ? (await compilerFrontend.remove(options.file)).invalidatedIds : await compilerFrontend.update({
+										id: options.file,
+										source,
+										root: config.root,
+										project: {
+											...await tamaguiLoader.getCompilerProject(),
+											generation: `${pluginInstanceId}:${tamaguiLoader.getGeneration()}`
+										},
+										resolve: async (specifier, importer) => {
+											const resolution = await this.environment.pluginContainer.resolveId(specifier, importer);
+											return resolution ? {
+												id: resolution.id,
+												external: resolution.external === true
+											} : null;
+										},
+										load: async (dependencyId) => {
+											const cleanDependencyId = dependencyId.split(/[?#]/, 1)[0];
+											if (!path.isAbsolute(cleanDependencyId)) return null;
+											try {
+												return await readFile(cleanDependencyId, "utf8");
+											} catch {
+												return null;
+											}
+										}
+									});
+									for (const invalidatedId of invalidatedIds) {
+										for (const module of this.environment.moduleGraph.getModulesByFile(invalidatedId) ?? []) {
+											this.environment.moduleGraph.invalidateModule(module);
+											if (compilerHmrRoots.has(invalidatedId) || module.isSelfAccepting) affectedModules.add(module);
+										}
+										const cssId = getAbsoluteVirtualFileId(`${invalidatedId}${virtualExt}`);
+										const cssModule = this.environment.moduleGraph.getModuleById(cssId);
+										if (cssModule) this.environment.moduleGraph.invalidateModule(cssModule);
+									}
+								}
+							}
+							return affectedModules.size ? [...affectedModules] : void 0;
+						}
+						const signature = await (async () => {
+							if (options.type === "delete") return getHash(`${options.type}:${options.file}`);
+							try {
+								return getHash(`${options.type}:${options.file}:${await options.read()}`);
+							} catch {
+								return getHash(`${options.type}:${options.file}:${options.timestamp}`);
+							}
+						})();
+						if (compilerHotUpdateSignatures.get(options.file) !== signature) {
+							compilerHotUpdateSignatures.set(options.file, signature);
+							tamaguiLoader.invalidate(options.file);
+							invalidateCompilerModules();
+						}
+						if (this.environment.name === "client" && compilerHotReloadSignatures.get(options.file) !== signature) {
+							compilerHotReloadSignatures.set(options.file, signature);
+							this.environment.hot.send({
+								type: "full-reload",
+								path: "*",
+								triggeredBy: options.file
+							});
+						}
+						return [];
+					}
+				},
+				async watchChange(id) {
+					if (config.command !== "build") return;
+					if (tamaguiLoader.isEvaluationDependency(id)) {
+						tamaguiLoader.invalidate(id);
+						invalidateCompilerModules();
+					}
+				},
+				async resolveId(source) {
+					if (isNative(this.environment)) return;
+					if (isNotClient(this.environment)) return;
+					if (!shouldExtract) return;
+					const [validId, query] = source.split("?");
+					if (!validId.endsWith(virtualExt)) return;
+					const absoluteId = validId.startsWith(config.root) ? validId : getAbsoluteVirtualFileId(validId);
+					if (cssMap.has(absoluteId)) return absoluteId + (query ? `?${query}` : "");
+				},
+				async load(id) {
+					if (tamaguiLoader.getTamaguiOptions()?.disable) return;
+					if (isNative(this.environment)) return;
+					if (isNotClient(this.environment)) return;
+					if (!shouldExtract) return;
+					const [validId] = id.split("?");
+					return cssMap.get(validId);
+				}
+			},
+			{
+				name: "tamagui-compiler",
+				enforce: "post",
+				transform: {
+					order: "pre",
+					async handler(code, id) {
+						if (this.environment?.name === TAMAGUI_EVALUATION_ENVIRONMENT) return;
+						if (!tamaguiLoader.getEnvironment()) return;
+						if (isNative(this.environment)) return;
+						const [validId] = id.split("?");
+						if (isFrameworkAnalysisRequest(id) || !isAppJSXSource(validId) || !/\.[jt]sx$/.test(validId)) return;
+						if ((await ensureLoaded())?.disable || !shouldExtract) return;
+						const { shouldDisable } = await Static.getPragmaOptions({
+							source: code,
+							path: validId
+						});
+						if (shouldDisable) return;
+						const evaluationDependencies = await tamaguiLoader.ensureFullConfigLoaded();
+						for (const dependency of evaluationDependencies) this.addWatchFile(dependency);
+						const compilerProject = await tamaguiLoader.getCompilerProject();
+						const result = await compilerFrontend.compile({
+							id: validId,
+							source: code,
+							root: config.root,
+							target: "web",
+							project: {
+								...compilerProject,
+								generation: `${pluginInstanceId}:${tamaguiLoader.getGeneration()}`,
+								zeroRuntime: zero !== null
+							},
+							resolve: async (specifier, importer) => {
+								const resolution = await this.resolve(specifier, importer, { skipSelf: true });
+								return resolution ? {
+									id: resolution.id,
+									external: resolution.external === true
+								} : null;
+							},
+							load: async (dependencyId) => {
+								const cleanDependencyId = dependencyId.split(/[?#]/, 1)[0];
+								if (!path.isAbsolute(cleanDependencyId)) return null;
+								try {
+									return await readFile(cleanDependencyId, "utf8");
+								} catch {
+									return null;
+								}
+							}
+						});
+						transformedModuleIds.add(validId);
+						compilerReports?.set(validId, {
+							stats: result.plan.stats,
+							diagnostics: result.plan.diagnostics
+						});
+						for (const dependency of result.plan.dependencies) if (path.isAbsolute(dependency)) this.addWatchFile(dependency);
+						if (zeroIslandBuild) {
+							zeroIslandBuild.artifact.setIslandModuleCSS(zeroIslandBuild.islandId, validId, wrapExtractedCSS(result.plan.css));
+							return result.output.changed ? {
+								code: result.output.code,
+								map: result.output.map
+							} : void 0;
+						}
+						if (zero) {
+							const zeroResult = Static.transformZeroModule({
+								mode: zero.isEnforcing ? "enforce" : "report",
+								id: validId,
+								root: config.root,
+								source: code,
+								plan: result.plan,
+								config: await tamaguiLoader.getTamaguiConfig(),
+								isTamaguiSpecifier: (specifier) => specifier === "tamagui" || specifier.startsWith("@tamagui/"),
+								resolveIslandLoader: (specifier) => {
+									const islandId = zero.loaderIds.get(zeroModuleKey(path.resolve(path.dirname(validId), specifier)));
+									return islandId ? { islandId } : null;
+								},
+								resolveIslandModule: (specifier) => zero.islandModuleIds.get(zeroModuleKey(path.resolve(path.dirname(validId), specifier))) ?? null
+							});
+							zero.transformed.add(validId);
+							if (zeroResult.erased.exports.length) zero.erasedExports.set(validId, zeroResult.erased.exports);
+							for (const violation of zeroResult.violations) {
+								const { line, column } = Static.offsetToLineColumn(code, violation.span.start);
+								zero.violations.push({
+									file: path.relative(config.root, validId),
+									line,
+									column,
+									rule: violation.rule,
+									code: violation.code,
+									component: violation.component,
+									message: violation.message
+								});
+							}
+							if (zero.isEnforcing) {
+								Static.mergeIslandBridges(zero.bridges, zeroResult.bridges);
+								const moduleCSS = [wrapExtractedCSS(result.plan.css), ...[...zeroResult.bridgeCSS.values()]].filter(Boolean).join("\n");
+								if (config.command !== "build") {
+									let cssImport2 = "";
+									if (moduleCSS) {
+										const rootRelativeId = `${validId}${virtualExt}`;
+										cssMap.set(getAbsoluteVirtualFileId(rootRelativeId), moduleCSS);
+										this.addWatchFile(rootRelativeId);
+										cssImport2 = `
+import "${rootRelativeId}";`;
+									}
+									return {
+										code: `${zeroResult.output.code}${cssImport2}`,
+										map: zeroResult.output.map
+									};
+								}
+								for (const [identifier, rules] of zeroResult.bridgeCSS) zero.artifact.setBridgeRules(identifier, rules);
+								zero.artifact.setZeroModuleCSS(validId, wrapExtractedCSS(result.plan.css));
+								return zeroResult.output.changed ? {
+									code: zeroResult.output.code,
+									map: zeroResult.output.map
+								} : void 0;
+							}
+						}
+						const isSSR = isNotClient(this.environment);
+						let cssImport = null;
+						if (result.plan.css) {
+							const rootRelativeId = `${validId}${virtualExt}`;
+							const absoluteId = getAbsoluteVirtualFileId(rootRelativeId);
+							cssMap.set(absoluteId, wrapExtractedCSS(result.plan.css));
+							this.addWatchFile(rootRelativeId);
+							if (!isSSR) cssImport = `import "${rootRelativeId}";`;
+						}
+						const finalCode = cssImport ? `${result.output.code}
+${cssImport}` : result.output.code;
+						return result.output.changed || cssImport ? {
+							code: finalCode,
+							map: result.output.map
+						} : void 0;
+					}
+				}
+			},
+			{
+				name: "tamagui-zero-runtime",
+				enforce: "post",
+				async buildStart() {
+					if (!zero || this.environment.name !== "client") return;
+					await tamaguiLoader.ensureFullConfigLoaded();
+					const tamaguiConfig = await tamaguiLoader.getTamaguiConfig();
+					if (!tamaguiConfig) throw new Error(`[tamagui zero-runtime] the Tamagui config did not evaluate, so no CSS artifact can be generated`);
+					zero.violations.length = 0;
+					zero.transformed.clear();
+					zero.erasedExports.clear();
+					if (!zero.isEnforcing) return;
+					Static.assertZeroConfigDrivers(tamaguiConfig);
+					zero.artifact.clearGraphs();
+					zero.bridges.clear();
+					zeroHtmlEntries = 0;
+					zero.artifact.setConfigCSS(tamaguiConfig.getCSS());
+					if (config.command !== "build") {
+						const islands = zero;
+						zeroDevIslands = Promise.all(islands.resolved.islands.map((island) => buildIsland({
+							island,
+							controller: islands,
+							root: config.root,
+							outDir: zeroDevIslandDir(islands),
+							mode: "development"
+						})));
+						await zeroDevIslands;
+					}
+				},
+				async configureServer(devServer) {
+					if (!zero?.isEnforcing) return;
+					const islandBase = `${zero.cssHref.replace(ZERO_CSS_FILENAME, "")}${ZERO_ISLAND_DIRNAME}/`;
+					devServer.middlewares.use(async (request, response, next) => {
+						const url = (request.url || "").split("?")[0];
+						if (url !== zero.cssHref && !url.startsWith(islandBase)) return next();
+						await zeroDevIslands;
+						if (url === zero.cssHref) {
+							response.setHeader("content-type", "text/css; charset=utf-8");
+							response.setHeader("cache-control", "no-cache");
+							response.end(zero.artifact.css());
+							return;
+						}
+						const islandId = url.slice(islandBase.length).replace(/\.js$/, "");
+						const file = path.join(zeroDevIslandDir(zero), ZERO_ISLAND_DIRNAME, `${islandId}.js`);
+						if (!existsSync(file)) return next();
+						response.setHeader("content-type", "text/javascript; charset=utf-8");
+						response.setHeader("cache-control", "no-cache");
+						response.end(readFileSync(file));
+					});
+				},
+				buildEnd(error) {
+					if (!zero || this.environment.name !== "client") return;
+					if (error) {
+						zeroBuildFailed = true;
+						return;
+					}
+					if (!zero.isEnforcing) return;
+					const importers = /* @__PURE__ */ new Map();
+					for (const moduleId of this.getModuleIds()) importers.set(moduleId, this.getModuleInfo(moduleId)?.importers ?? []);
+					const escape = Static.erasedExportEscape({
+						integration: "vite",
+						transformed: zero.transformed,
+						erasedExports: zero.erasedExports,
+						importersOf: importers
+					});
+					if (escape) {
+						zeroBuildFailed = true;
+						throw new Error(escape);
+					}
+				},
+				transformIndexHtml: {
+					order: "post",
+					handler(html) {
+						if (!zero?.isEnforcing) return;
+						zeroHtmlEntries++;
+						return {
+							html,
+							tags: [{
+								tag: "link",
+								attrs: {
+									rel: "stylesheet",
+									href: zero.cssHref
+								},
+								injectTo: "head"
+							}]
+						};
+					}
+				},
+				generateBundle(_outputOptions, bundle) {
+					if (!zero?.isEnforcing || this.environment.name !== "client") return;
+					const importers = /* @__PURE__ */ new Map();
+					for (const moduleId of this.getModuleIds()) for (const imported of this.getModuleInfo(moduleId)?.importedIds ?? []) {
+						const list = importers.get(imported);
+						if (list) list.push(moduleId);
+						else importers.set(imported, [moduleId]);
+					}
+					const entries = [];
+					const modules = [];
+					for (const chunk of Object.values(bundle)) {
+						if (chunk.type !== "chunk") continue;
+						for (const moduleId of Object.keys(chunk.modules)) {
+							modules.push({
+								id: moduleId,
+								importers: importers.get(moduleId) ?? []
+							});
+							if (this.getModuleInfo(moduleId)?.isEntry) entries.push(moduleId);
+						}
+					}
+					const checked = Static.checkZeroGraph({
+						entries,
+						modules,
+						importerEdges: importers,
+						root: zero.resolved.root
+					});
+					zeroReceipt = {
+						integration: "vite",
+						graph: "zero",
+						entries: entries.sort(),
+						moduleCount: modules.length,
+						tamaguiModules: checked.tamaguiModules,
+						forbidden: checked.forbidden,
+						cssArtifact: null,
+						identity: "",
+						gzip: Object.fromEntries(Object.values(bundle).filter((chunk) => chunk.type === "chunk").map((chunk) => [chunk.fileName, gzipSync(Buffer.from(chunk.code), { level: 9 }).length]))
+					};
+				},
+				async closeBundle() {
+					if (!zero || this.environment.name !== "client") return;
+					const outDir = path.resolve(config.root, this.environment.config.build.outDir);
+					const receiptName = `vite-${path.basename(outDir)}`;
+					Static.writeZeroViolationReport(zero.resolved.outDir, receiptName, {
+						integration: "vite",
+						mode: zero.isEnforcing ? "enforce" : "report",
+						violations: zero.violations
+					});
+					if (!zero.isEnforcing || zeroBuildFailed) return;
+					if (zero.violations.length) throw new Error(Static.formatZeroViolations(zero.violations));
+					const islandOutputHashes = {};
+					for (const island of zero.resolved.islands) {
+						const built = await buildIsland({
+							island,
+							controller: zero,
+							root: config.root,
+							outDir,
+							mode: config.mode
+						});
+						islandOutputHashes[island.id] = built.hash;
+					}
+					if (zeroHtmlEntries === 0) throw new Error(`[tamagui zero-runtime] the zero entry graph has no HTML entry, so the one generated CSS artifact ${zero.cssHref} is never loaded. Build a zero entry through its HTML document.`);
+					const css = finalizeZeroCSS(zero, outDir);
+					const bridgeManifest = Static.canonicalizeBridgeManifest(Object.fromEntries([...zero.bridges.entries()].sort(([left], [right]) => left < right ? -1 : 1)));
+					const identityInputs = {
+						runtimeLiteral: "zero",
+						target: "web",
+						configGeneration: `${pluginInstanceId}:${tamaguiLoader.getGeneration()}`,
+						cssHash: css.hash,
+						compilerVersion: Static.ZERO_COMPILER_VERSION,
+						islandEntries: zero.resolved.islands.map((island) => island.module),
+						bridgeManifestHash: Static.hashBridgeManifest(bridgeManifest),
+						islandOutputHashes
+					};
+					const identity = Static.hashZeroIdentity(identityInputs);
+					if (!zeroReceipt) throw new Error(`[tamagui zero-runtime] no module graph was recorded for the zero entry`);
+					zeroReceipt.cssArtifact = {
+						path: css.href,
+						hash: css.hash
+					};
+					zeroReceipt.identity = identity;
+					Static.writeZeroGraphReceipt(zero.resolved.outDir, receiptName, zeroReceipt);
+					writeFileSync(path.join(zero.resolved.outDir, `${receiptName}.bridges.json`), `${JSON.stringify({
+						identity,
+						identityInputs,
+						cssGzip: css.gzip,
+						bridges: bridgeManifest
+					}, null, 2)}
 `);
-        }
-        if (shouldDisable) {
-          return;
-        }
-        const isSSR = isNotClient(this.environment);
-        const cacheKey = getHash(`${code}${id}`);
-        const pending = getPendingExtractions();
-        const formatResult = entry => {
-          const finalCode = !isSSR && entry.cssImport ? `${entry.js}
-${entry.cssImport}` : entry.js;
-          return {
-            code: finalCode,
-            map: entry.map
-          };
-        };
-        const cached = memoryCache[cacheKey];
-        if (cached) {
-          if (process.env.DEBUG_TAMAGUI_CACHE) {
-            console.info(`[tamagui-cache] HIT ${this.environment?.name || "unknown"} ${id.split("/").pop()} key=${cacheKey.slice(0, 8)}`);
-          }
-          return formatResult(cached);
-        }
-        const pendingExtraction = pending.get(cacheKey);
-        if (pendingExtraction) {
-          if (process.env.DEBUG_TAMAGUI_CACHE) {
-            console.info(`[tamagui-cache] WAIT ${this.environment?.name || "unknown"} ${id.split("/").pop()} key=${cacheKey.slice(0, 8)}`);
-          }
-          const result = await pendingExtraction;
-          if (result) {
-            return formatResult(result);
-          }
-          return;
-        }
-        if (process.env.DEBUG_TAMAGUI_CACHE) {
-          console.info(`[tamagui-cache] EXTRACT ${this.environment?.name || "unknown"} ${id.split("/").pop()} key=${cacheKey.slice(0, 8)}`);
-        }
-        const extractionPromise = (async () => {
-          let extracted;
-          try {
-            extracted = await Static.extractToClassNames({
-              source: code,
-              sourcePath: validId,
-              options,
-              shouldPrintDebug
-            });
-          } catch (err) {
-            if (process.env.DEBUG_TAMAGUI_CACHE) {
-              console.info(`[tamagui-cache] ERROR extracting ${id.split("/").pop()}:`, err);
-            }
-            console.error(err instanceof Error ? err.message : String(err));
-            return null;
-          }
-          if (!extracted) {
-            if (process.env.DEBUG_TAMAGUI_CACHE) {
-              console.info(`[tamagui-cache] no extraction result for ${id.split("/").pop()}`);
-            }
-            return null;
-          }
-          const rootRelativeId = `${validId}${virtualExt}`;
-          const absoluteId = getAbsoluteVirtualFileId(rootRelativeId);
-          let cssImport = null;
-          if (extracted.styles) {
-            this.addWatchFile(rootRelativeId);
-            if (server && cssMap.has(absoluteId)) {
-              invalidateModule(rootRelativeId);
-            }
-            cssImport = `import "${rootRelativeId}";`;
-            cssMap.set(absoluteId, extracted.styles);
-          }
-          const jsCode = extracted.js.toString();
-          const cacheEntry = {
-            js: jsCode,
-            map: extracted.map,
-            cssImport
-          };
-          const newSize = getSharedCacheSize() + jsCode.length;
-          if (newSize > 67108864) {
-            clearSharedCache();
-          } else {
-            setSharedCacheSize(newSize);
-          }
-          memoryCache[cacheKey] = cacheEntry;
-          if (process.env.DEBUG_TAMAGUI_CACHE) {
-            console.info(`[tamagui-cache] WRITE key=${cacheKey.slice(0, 8)} cacheSize=${Object.keys(memoryCache).length}`);
-          }
-          return cacheEntry;
-        })();
-        pending.set(cacheKey, extractionPromise);
-        try {
-          const result = await extractionPromise;
-          if (result) {
-            return formatResult(result);
-          }
-          return;
-        } finally {
-          pending.delete(cacheKey);
-        }
-      }
-    }
-  };
-  return [basePlugin, rnwLitePlugin, extractPlugin];
+					assertZeroGraph(zeroReceipt);
+				}
+			},
+			{
+				name: "tamagui-global-css",
+				enforce: "post",
+				apply: "build",
+				async buildStart() {
+					if (!globalCSS || this.environment.name !== "client") return;
+					await tamaguiLoader.ensureFullConfigLoaded();
+					const tamaguiConfig = await tamaguiLoader.getTamaguiConfig();
+					if (!tamaguiConfig) throw new Error(`[tamagui] outputCSS is set but the Tamagui config did not evaluate, so no CSS artifact can be generated`);
+					globalCSSExpected = tamaguiConfig.getCSS();
+				},
+				generateBundle() {
+					if (!globalCSS || this.environment.name !== "client") return;
+					const failure = Static.checkGlobalCSSArtifact({
+						cssPath: globalCSS.cssPath,
+						expectedCSS: globalCSSExpected ?? "",
+						loadedModuleIds: this.getModuleIds(),
+						importHint: `Import it once from your client entry: import ${JSON.stringify(relativeImportSpecifier(config.root, globalCSS.cssPath))}`
+					});
+					if (failure) throw new Error(failure.message);
+				}
+			},
+			tamaguiNativePlugin(tamaguiOptionsIn)
+		],
+		loader: tamaguiLoader
+	};
+}
+function zeroDevIslandDir(zero) {
+	return path.join(zero.resolved.outDir, "dev");
+}
+function relativeImportSpecifier(from, to) {
+	const relative = normalizePath(path.relative(from, to));
+	return relative.startsWith(".") ? relative : `./${relative}`;
 }
-export { tamaguiAliases, tamaguiPlugin };
+function tamaguiPlugin(options = {}) {
+	return createTamaguiPlugins(options).plugins;
+}
+
+export { createTamaguiPlugins, tamaguiAliases, tamaguiNativePlugin, tamaguiPlugin };
 //# sourceMappingURL=plugin.mjs.map