@tamagui/static 2.7.7 → 3.0.0-beta.1097.1

package/dist/cjs/helpers/memoize.cjs

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var memoize_exports = {};
+__export(memoize_exports, { memoize: () => memoize });
+module.exports = __toCommonJS(memoize_exports);
+function memoize(func, resolver) {
+	if (typeof func !== "function" || resolver != null && typeof resolver !== "function") {
+		throw new TypeError("Expected a function");
+	}
+	const memoized = function(...args) {
+		const key = resolver ? resolver.apply(this, args) : args[0];
+		const cache = memoized.cache;
+		if (cache.has(key)) {
+			return cache.get(key);
+		}
+		const result = func.apply(this, args);
+		memoized.cache = cache.set(key, result) || cache;
+		return result;
+	};
+	memoized.cache = new (memoize.Cache || Map)();
+	return memoized;
+}
+memoize.Cache = Map;

package/dist/cjs/helpers/requireTamaguiCore.cjs

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var requireTamaguiCore_exports = {};
+__export(requireTamaguiCore_exports, { requireTamaguiCore: () => requireTamaguiCore });
+module.exports = __toCommonJS(requireTamaguiCore_exports);
+var import_node_module = require("node:module");
+const import_meta = {};
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+function requireTamaguiCore(platform, ogRequire = nodeRequire) {
+	if (!platform) {
+		throw new Error(`No platform given to requireTamaguiCore`);
+	}
+	const og1 = process.env.TAMAGUI_IS_SERVER;
+	const og2 = process.env.TAMAGUI_KEEP_THEMES;
+	process.env.TAMAGUI_IS_SERVER ||= "1";
+	process.env.TAMAGUI_KEEP_THEMES ||= "1";
+	const exported = ogRequire(platform === "native" ? "@tamagui/core/native" : "@tamagui/core");
+	process.env.TAMAGUI_IS_SERVER = og1;
+	process.env.TAMAGUI_KEEP_THEMES = og2;
+	return exported;
+}

package/dist/cjs/index.cjs

@@ -0,0 +1,33 @@
+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 __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, { default: () => index_default });
+module.exports = __toCommonJS(index_exports);
+var Static1 = __toESM(require("./exports.cjs"), 1);
+__reExport(index_exports, require("./exports.cjs"), module.exports);
+var index_default = Static1;

package/dist/cjs/registerRequire.cjs

@@ -0,0 +1,219 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registerRequire_exports = {};
+__export(registerRequire_exports, {
+	getNameToPaths: () => getNameToPaths,
+	registerRequire: () => registerRequire,
+	setRequireResult: () => setRequireResult
+});
+module.exports = __toCommonJS(registerRequire_exports);
+var import_node_path = require("node:path");
+var import_esbuild = require("esbuild");
+var import_node = require("esbuild-register/dist/node");
+var import_node_module = require("node:module");
+var import_bundle = require("./extractor/bundle.cjs");
+var import_requireTamaguiCore = require("./helpers/requireTamaguiCore.cjs");
+var import_staticEvaluationIgnoredModules = require("./staticEvaluationIgnoredModules.cjs");
+const import_meta = {};
+const nameToPaths = {};
+const nodeRequire = (0, import_node_module.createRequire)(typeof __filename === "string" ? __filename : import_meta.url);
+const getNameToPaths = () => nameToPaths;
+const Module = nodeRequire("node:module");
+let isRegistered = false;
+let og;
+var StaticEvaluationError = class extends Error {
+	constructor(moduleName, importer, failedModule, reason, options) {
+		super(`[tamagui] Failed to evaluate module "${failedModule}" imported from "${importer}" while loading the Tamagui config and configured components.
+Reason: ${reason}
+Fix the module so it can run in Node during the build. If it is runtime-only and none of its exports create your Tamagui config or components, add "${moduleName}" to dangerouslyIgnoreStaticEvaluationModules in tamagui.build.ts.`, options);
+		this.moduleName = moduleName;
+		this.importer = importer;
+		this.failedModule = failedModule;
+		this.reason = reason;
+	}
+	moduleName;
+	importer;
+	failedModule;
+	reason;
+	code = "TAMAGUI_STATIC_EVALUATION_ERROR";
+};
+const compiled = {};
+function setRequireResult(name, result) {
+	compiled[name] = result;
+}
+function getStaticExtractionStub(path) {
+	switch (path) {
+		case "expo-constants": return {
+			__esModule: true,
+			default: { executionEnvironment: null },
+			ExecutionEnvironment: {
+				Bare: "bare",
+				Standalone: "standalone",
+				StoreClient: "storeClient"
+			}
+		};
+		case "expo-updates": return {
+			__esModule: true,
+			default: {
+				isEnabled: false,
+				isUsingEmbeddedAssets: true
+			},
+			checkForUpdateAsync: async () => ({ isAvailable: false }),
+			fetchUpdateAsync: async () => ({ isNew: false }),
+			reloadAsync: async () => {}
+		};
+		case "react-native-reanimated": {
+			const identity = (value) => value;
+			const sharedValue = (value) => ({
+				value,
+				get: () => value,
+				set: (next) => {
+					value = typeof next === "function" ? next(value) : next;
+				}
+			});
+			const Animated = {
+				createAnimatedComponent: identity,
+				View: () => null,
+				Text: () => null
+			};
+			return {
+				__esModule: true,
+				default: Animated,
+				cancelAnimation: () => {},
+				runOnJS: identity,
+				runOnUI: identity,
+				useAnimatedReaction: () => {},
+				useAnimatedStyle: (callback) => callback(),
+				useDerivedValue: (callback) => sharedValue(callback()),
+				useSharedValue: sharedValue,
+				withDelay: (_delay, animation) => animation,
+				withSpring: identity,
+				withTiming: identity
+			};
+		}
+		default: return null;
+	}
+}
+function registerRequire(platform, { ignoredModules = [] } = { ignoredModules: [] }) {
+	if (isRegistered) {
+		return {
+			tamaguiRequire: nodeRequire,
+			unregister: () => {}
+		};
+	}
+	const originalResolveFilename = Module._resolveFilename;
+	const { unregister } = (0, import_node.register)({
+		hookIgnoreNodeModules: false,
+		hookMatcher: (filename) => {
+			if (filename.includes("@tamagui") || /\/tamagui\/code\/(core|ui|packages)\//.test(filename)) {
+				return false;
+			}
+			return true;
+		}
+	});
+	const tsconfigPatchedResolve = Module._resolveFilename;
+	Module._resolveFilename = function(request, ...args) {
+		if (request.startsWith("@tamagui/")) {
+			return originalResolveFilename.call(this, request, ...args);
+		}
+		return tsconfigPatchedResolve.call(this, request, ...args);
+	};
+	if (!og) {
+		og = Module.prototype.require;
+	}
+	isRegistered = true;
+	Module.prototype.require = tamaguiRequire;
+	function tamaguiRequire(path) {
+		const staticExtractionStub = getStaticExtractionStub(path);
+		if (staticExtractionStub) {
+			return staticExtractionStub;
+		}
+		if (path === "tamagui" && platform === "native") {
+			return og.apply(this, ["tamagui/native"]);
+		}
+		if (path === "@tamagui/core") {
+			return (0, import_requireTamaguiCore.requireTamaguiCore)(platform, (path2) => {
+				return og.apply(this, [path2]);
+			});
+		}
+		const staticEvaluationReplacement = (0, import_staticEvaluationIgnoredModules.getStaticEvaluationModuleReplacement)(path);
+		if (staticEvaluationReplacement) {
+			if (!(path in compiled)) {
+				const replacementPath = nodeRequire.resolve(staticEvaluationReplacement);
+				const output = (0, import_esbuild.buildSync)({
+					entryPoints: [replacementPath],
+					bundle: true,
+					format: "cjs",
+					platform: "node",
+					write: false
+				}).outputFiles[0].text;
+				const replacementModule = new Module(replacementPath, this);
+				replacementModule.filename = replacementPath;
+				replacementModule.paths = Module._nodeModulePaths((0, import_node_path.dirname)(replacementPath));
+				replacementModule._compile(output, replacementPath);
+				compiled[path] = replacementModule.exports;
+			}
+			return compiled[path];
+		}
+		if (staticEvaluationReplacement === null || (0, import_staticEvaluationIgnoredModules.isIgnoredStaticEvaluationModule)(path, ignoredModules)) {
+			return {};
+		}
+		if (import_bundle.esbuildIgnoreFilesRegex.test(path)) {
+			return {};
+		}
+		if (path in compiled) {
+			return compiled[path];
+		}
+		if (path === "react-native-svg") {
+			return og.apply(this, ["@tamagui/react-native-svg"]);
+		}
+		if (path === "react-native/package.json") {
+			return og.apply(this, ["react-native-web/package.json"]);
+		}
+		if (path === "@tamagui/react-native-web-lite" || path === "react-native" || path.startsWith("react-native/") || path === "react-native-web" || path.startsWith("react-native-web/")) {
+			try {
+				return og.apply("react-native");
+			} catch {
+				return og.apply(this, ["@tamagui/react-native-web-lite"]);
+			}
+		}
+		try {
+			const out = og.apply(this, arguments);
+			return out;
+		} catch (err) {
+			if (err?.code === "TAMAGUI_STATIC_EVALUATION_ERROR") {
+				throw err;
+			}
+			const importer = this?.filename || this?.id || "<unknown module>";
+			const reason = err instanceof Error ? err.message : String(err);
+			const failedModule = reason.match(/Cannot find native module ['"]([^'"]+)['"]/)?.[1] || path;
+			throw new StaticEvaluationError(path, importer, failedModule, reason, { cause: err });
+		}
+	}
+	return {
+		tamaguiRequire,
+		unregister: () => {
+			unregister();
+			isRegistered = false;
+			Module.prototype.require = og;
+		}
+	};
+}

package/dist/cjs/server.cjs

@@ -0,0 +1,65 @@
+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 __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, { startServer: () => startServer });
+module.exports = __toCommonJS(server_exports);
+var import_node_net = __toESM(require("node:net"), 1);
+async function startServer(options) {
+	const port = await getAvailablePort();
+	const server = import_node_net.default.createServer();
+	server.unref();
+	await new Promise((resolve, reject) => {
+		server.on("error", reject);
+		server.on("connection", (conn) => {
+			conn.on("data", (data) => {
+				console.info("got", data.toString());
+			});
+		});
+		server.listen({ port }, () => {
+			const { port: port2 } = server.address();
+			server.close(() => {
+				resolve(port2);
+			});
+		});
+	});
+}
+async function getAvailablePort(port = 8089) {
+	return checkAvailablePort(port).catch(() => getAvailablePort(port + 1));
+}
+function checkAvailablePort(port) {
+	return new Promise((resolve, reject) => {
+		const server = import_node_net.default.createServer();
+		server.unref();
+		server.on("error", reject);
+		server.listen({ port }, () => {
+			const { port: port2 } = server.address();
+			server.close(() => {
+				resolve(port2);
+			});
+		});
+	});
+}

package/dist/cjs/staticEvaluationIgnoredModules.cjs

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var staticEvaluationIgnoredModules_exports = {};
+__export(staticEvaluationIgnoredModules_exports, {
+	getStaticEvaluationModuleReplacement: () => getStaticEvaluationModuleReplacement,
+	isIgnoredStaticEvaluationModule: () => isIgnoredStaticEvaluationModule,
+	staticEvaluationIgnorePlugin: () => staticEvaluationIgnorePlugin,
+	tamaguiStaticEvaluationModules: () => tamaguiStaticEvaluationModules
+});
+module.exports = __toCommonJS(staticEvaluationIgnoredModules_exports);
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+const tamaguiStaticEvaluationModules = Object.freeze({
+	"react-native-safe-area-context": null,
+	"react-native-worklets": "react-native-worklets/lib/module/mock.js"
+});
+function getStaticEvaluationModuleReplacement(moduleName) {
+	return moduleName in tamaguiStaticEvaluationModules ? tamaguiStaticEvaluationModules[moduleName] : void 0;
+}
+function isIgnoredStaticEvaluationModule(moduleName, userIgnoredModules = []) {
+	return getStaticEvaluationModuleReplacement(moduleName) !== void 0 || userIgnoredModules.includes(moduleName);
+}
+function staticEvaluationIgnorePlugin(userIgnoredModules = []) {
+	return {
+		name: "tamagui-static-evaluation-ignore",
+		setup(build) {
+			build.onResolve({ filter: /.*/ }, (args) => {
+				if (isIgnoredStaticEvaluationModule(args.path, userIgnoredModules)) {
+					return {
+						path: args.path,
+						namespace: "tamagui-static-evaluation-ignore"
+					};
+				}
+				return null;
+			});
+			build.onLoad({
+				filter: /.*/,
+				namespace: "tamagui-static-evaluation-ignore"
+			}, async (args) => {
+				const replacement = getStaticEvaluationModuleReplacement(args.path);
+				if (replacement) {
+					const resolved = await build.resolve(replacement, {
+						kind: "require-call",
+						resolveDir: build.initialOptions.absWorkingDir || process.cwd()
+					});
+					if (resolved.errors.length) {
+						return {
+							errors: resolved.errors,
+							warnings: resolved.warnings
+						};
+					}
+					return {
+						contents: await (0, import_promises.readFile)(resolved.path, "utf8"),
+						loader: "js",
+						resolveDir: (0, import_node_path.dirname)(resolved.path),
+						warnings: resolved.warnings
+					};
+				}
+				return {
+					contents: "module.exports = {}",
+					loader: "js",
+					resolveDir: build.initialOptions.absWorkingDir || process.cwd()
+				};
+			});
+		}
+	};
+}

package/dist/cjs/types.cjs

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/zero/artifact.cjs

@@ -0,0 +1,144 @@
+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 __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var artifact_exports = {};
+__export(artifact_exports, { ZeroCSSArtifact: () => ZeroCSSArtifact });
+module.exports = __toCommonJS(artifact_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var ZeroCSSArtifact = class {
+	#config = null;
+	#zero = /* @__PURE__ */ new Map();
+	#islands = /* @__PURE__ */ new Map();
+	#bridges = /* @__PURE__ */ new Map();
+	#expectedIslands = [];
+	#cssPath;
+	constructor(cssPath) {
+		this.#cssPath = cssPath;
+	}
+	get cssPath() {
+		return this.#cssPath;
+	}
+	expectIslands(ids) {
+		this.#expectedIslands = [...ids].sort();
+	}
+	setConfigCSS(css) {
+		this.#config = css;
+	}
+	setZeroModuleCSS(moduleId, css) {
+		if (css) this.#zero.set(moduleId, css);
+		else this.#zero.delete(moduleId);
+	}
+	setIslandModuleCSS(islandId, moduleId, css) {
+		let bucket = this.#islands.get(islandId);
+		if (!bucket) {
+			bucket = /* @__PURE__ */ new Map();
+			this.#islands.set(islandId, bucket);
+		}
+		if (css) bucket.set(moduleId, css);
+		else bucket.delete(moduleId);
+	}
+	/** This island's collected rules, in deterministic module order. */
+	islandCSS(islandId) {
+		const bucket = this.#islands.get(islandId);
+		if (!bucket) return [];
+		return [...bucket.keys()].sort().map((moduleId) => bucket.get(moduleId));
+	}
+	/** Marks an island as compiled even when it contributed no atomic rules. */
+	markIslandComplete(islandId) {
+		if (!this.#islands.has(islandId)) this.#islands.set(islandId, /* @__PURE__ */ new Map());
+	}
+	/** Collected zero-graph module CSS, for an integration that persists it. */
+	zeroModuleEntries() {
+		return [...this.#zero.entries()].sort(([left], [right]) => left < right ? -1 : 1);
+	}
+	bridgeEntries() {
+		return [...this.#bridges.entries()].sort(([left], [right]) => left < right ? -1 : 1);
+	}
+	setBridgeRules(bridgeId, css) {
+		if (css) this.#bridges.set(bridgeId, css);
+		else this.#bridges.delete(bridgeId);
+	}
+	clearGraphs() {
+		this.#zero.clear();
+		this.#islands.clear();
+		this.#bridges.clear();
+	}
+	/** The missing pieces that block deriving TAMAGUI_DID_OUTPUT_CSS. */
+	missing() {
+		const missing = [];
+		if (this.#config === null) missing.push("config CSS");
+		for (const id of this.#expectedIslands) {
+			if (!this.#islands.has(id)) missing.push(`island ${id}`);
+		}
+		return missing;
+	}
+	isComplete() {
+		return this.missing().length === 0;
+	}
+	/** Deterministic order: config, zero atomic, island atomic, bridge classes. */
+	css() {
+		const parts = [];
+		if (this.#config) parts.push(this.#config);
+		for (const moduleId of [...this.#zero.keys()].sort()) {
+			parts.push(this.#zero.get(moduleId));
+		}
+		for (const islandId of [...this.#islands.keys()].sort()) {
+			const bucket = this.#islands.get(islandId);
+			for (const moduleId of [...bucket.keys()].sort()) parts.push(bucket.get(moduleId));
+		}
+		for (const bridgeId of [...this.#bridges.keys()].sort()) {
+			parts.push(this.#bridges.get(bridgeId));
+		}
+		return parts.join("\n");
+	}
+	hash() {
+		return (0, import_node_crypto.createHash)("sha256").update(this.css()).digest("hex").slice(0, 16);
+	}
+	/**
+	* Writes the artifact and returns whether the derived
+	* `TAMAGUI_DID_OUTPUT_CSS='1'` claim is now legal.
+	*/
+	write() {
+		const missing = this.missing();
+		const css = this.css();
+		(0, import_node_fs.mkdirSync)(import_node_path.default.dirname(this.#cssPath), { recursive: true });
+		let existing = null;
+		try {
+			existing = (0, import_node_fs.readFileSync)(this.#cssPath, "utf8");
+		} catch {
+			existing = null;
+		}
+		if (existing !== css) (0, import_node_fs.writeFileSync)(this.#cssPath, css);
+		return {
+			path: this.#cssPath,
+			hash: this.hash(),
+			complete: missing.length === 0,
+			missing
+		};
+	}
+};