@tamagui/static 2.7.7 → 3.0.0-beta.643.1

package/dist/cjs/server.cjs

@@ -0,0 +1,66 @@
+
+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,86 @@
+
+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 Object.hasOwn(tamaguiStaticEvaluationModules, moduleName) ? 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,17 @@
+
+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,145 @@
+
+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
+		};
+	}
+};

package/dist/cjs/zero/graph.cjs

@@ -0,0 +1,209 @@
+
+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 graph_exports = {};
+__export(graph_exports, {
+	checkZeroGraph: () => checkZeroGraph,
+	erasedExportEscape: () => erasedExportEscape,
+	formatZeroGraphFailure: () => formatZeroGraphFailure,
+	formatZeroViolations: () => formatZeroViolations,
+	isForbiddenZeroModuleId: () => isForbiddenZeroModuleId,
+	isTamaguiModuleId: () => isTamaguiModuleId,
+	offsetToLineColumn: () => offsetToLineColumn,
+	owningPackageOf: () => owningPackageOf,
+	owningPackageOfDir: () => owningPackageOfDir,
+	sortZeroViolations: () => sortZeroViolations,
+	writeZeroGraphReceipt: () => writeZeroGraphReceipt,
+	writeZeroViolationReport: () => writeZeroViolationReport
+});
+module.exports = __toCommonJS(graph_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+const ALLOWED_ZERO_MODULE = /animated-number/;
+const owningPackageCache = /* @__PURE__ */ new Map();
+function owningPackageOf(id) {
+	const clean = id.split(/[?#]/, 1)[0];
+	if (!clean || clean.startsWith("\0") || !import_node_path.default.isAbsolute(clean)) return null;
+	return owningPackageOfDir(import_node_path.default.dirname(clean));
+}
+function owningPackageOfDir(from) {
+	if (!from || !import_node_path.default.isAbsolute(from)) return null;
+	let dir = from;
+	const visited = [];
+	while (true) {
+		const cached = owningPackageCache.get(dir);
+		if (cached !== void 0) {
+			for (const seen of visited) owningPackageCache.set(seen, cached);
+			return cached;
+		}
+		visited.push(dir);
+		const manifest = import_node_path.default.join(dir, "package.json");
+		if ((0, import_node_fs.existsSync)(manifest)) {
+			let owner = null;
+			try {
+				owner = {
+					name: JSON.parse((0, import_node_fs.readFileSync)(manifest, "utf8")).name ?? null,
+					manifest
+				};
+			} catch {
+				owner = {
+					name: null,
+					manifest
+				};
+			}
+			for (const seen of visited) owningPackageCache.set(seen, owner);
+			return owner;
+		}
+		const parent = import_node_path.default.dirname(dir);
+		if (parent === dir) {
+			for (const seen of visited) owningPackageCache.set(seen, null);
+			return null;
+		}
+		dir = parent;
+	}
+}
+function isTamaguiModuleId(id, ownManifest) {
+	const owner = owningPackageOf(id);
+	if (!owner?.name) return false;
+	if (ownManifest && owner.manifest === ownManifest) return false;
+	return owner.name === "tamagui" || owner.name.startsWith("@tamagui/");
+}
+function isForbiddenZeroModuleId(id, ownManifest) {
+	if (!isTamaguiModuleId(id, ownManifest)) return false;
+	return !ALLOWED_ZERO_MODULE.test(id);
+}
+function shortestChain(target, entries, importersOf) {
+	const entrySet = new Set(entries);
+	const seen = /* @__PURE__ */ new Set([target]);
+	const queue = [[target]];
+	let longest = [target];
+	while (queue.length) {
+		const chain = queue.shift();
+		const head = chain[0];
+		if (entrySet.has(head)) return chain;
+		if (chain.length > longest.length) longest = chain;
+		for (const importer of importersOf.get(head) ?? []) {
+			if (seen.has(importer)) continue;
+			seen.add(importer);
+			queue.push([importer, ...chain]);
+		}
+	}
+	return longest;
+}
+function checkZeroGraph(input) {
+	const importersOf = new Map(input.importerEdges);
+	for (const module2 of input.modules) {
+		if (!importersOf.has(module2.id)) importersOf.set(module2.id, module2.importers ?? []);
+	}
+	const ownManifest = input.root ? owningPackageOfDir(input.root)?.manifest ?? null : null;
+	const tamaguiModules = input.modules.map((module2) => module2.id).filter((id) => isTamaguiModuleId(id, ownManifest)).sort();
+	const forbidden = tamaguiModules.filter((id) => isForbiddenZeroModuleId(id, ownManifest)).map((id) => ({
+		id,
+		chain: shortestChain(id, input.entries, importersOf),
+		owner: owningPackageOf(id)?.name ?? ""
+	}));
+	return {
+		tamaguiModules,
+		forbidden
+	};
+}
+function formatZeroGraphFailure(receipt) {
+	const lines = [`[tamagui zero-runtime] ${receipt.integration} zero entry graph contains ${receipt.forbidden.length} forbidden Tamagui module(s)`, ""];
+	for (const entry of receipt.forbidden) {
+		lines.push(entry.owner ? `${entry.id} (package ${entry.owner})` : entry.id);
+		lines.push(entry.chain.length > 1 ? `  ${entry.chain.join("\n    -> ")}` : `  (this bundler exposed no importer edges for that module)`);
+	}
+	lines.push("");
+	lines.push(import_compiler_core.ZERO_FAILURE_FOOTER);
+	return lines.join("\n");
+}
+function writeZeroGraphReceipt(outDir, name, receipt) {
+	(0, import_node_fs.mkdirSync)(outDir, { recursive: true });
+	const file = import_node_path.default.join(outDir, `${name}.graph.json`);
+	(0, import_node_fs.writeFileSync)(file, `${JSON.stringify(receipt, null, 2)}
+`);
+	return file;
+}
+function sortZeroViolations(sites) {
+	return [...sites].sort((left, right) => (left.file < right.file ? -1 : left.file > right.file ? 1 : 0) || left.line - right.line || left.column - right.column || left.rule - right.rule || (left.message < right.message ? -1 : left.message > right.message ? 1 : 0));
+}
+function formatZeroViolations(sites) {
+	const sorted = sortZeroViolations(sites);
+	const lines = [`[tamagui zero-runtime] build failed with ${sorted.length} violations`, ""];
+	for (const site of sorted) {
+		lines.push(`Rule ${site.rule} ${site.code}`);
+		lines.push(`${site.file}:${site.line}:${site.column}${site.component ? ` ${site.component}` : ""}`);
+		lines.push(`  ${site.message}`);
+		lines.push("");
+	}
+	lines.push(import_compiler_core.ZERO_FAILURE_FOOTER);
+	return lines.join("\n");
+}
+function writeZeroViolationReport(outDir, name, report) {
+	(0, import_node_fs.mkdirSync)(outDir, { recursive: true });
+	const file = import_node_path.default.join(outDir, `${name}.violations.json`);
+	(0, import_node_fs.writeFileSync)(file, `${JSON.stringify({
+		integration: report.integration,
+		mode: report.mode,
+		count: report.violations.length,
+		violations: sortZeroViolations(report.violations)
+	}, null, 2)}
+`);
+	return file;
+}
+function erasedExportEscape(input) {
+	for (const [moduleId, names] of input.erasedExports) {
+		if (names.length === 0) continue;
+		if (!input.importersOf.has(moduleId)) {
+			return `[tamagui zero-runtime] ${input.integration} erased the exported definition(s) ${names.join(", ")} from ${moduleId}, and then could not find that module in its own graph, so nothing proved the erasure was safe.
+
+${import_compiler_core.ZERO_FAILURE_FOOTER}`;
+		}
+		const untransformed = (input.importersOf.get(moduleId) ?? []).filter((importer) => !input.transformed.has(importer));
+		if (untransformed.length === 0) continue;
+		return `[tamagui zero-runtime] ${input.integration} erased the exported definition(s) ${names.join(", ")} from ${moduleId}, but ${untransformed.length} importer(s) in this entry graph were never zero-transformed and may still reference them:
+  ${untransformed.join("\n  ")}
+
+${import_compiler_core.ZERO_FAILURE_FOOTER}`;
+	}
+	return null;
+}
+function offsetToLineColumn(source, offset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let index = 0; index < offset && index < source.length; index++) {
+		if (source.charCodeAt(index) === 10) {
+			line++;
+			lineStart = index + 1;
+		}
+	}
+	return {
+		line,
+		column: offset - lineStart + 1
+	};
+}

package/dist/cjs/zero/identity.cjs

@@ -0,0 +1,61 @@
+
+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 identity_exports = {};
+__export(identity_exports, {
+	ZERO_COMPILER_VERSION: () => ZERO_COMPILER_VERSION,
+	canonicalizeBridgeManifest: () => canonicalizeBridgeManifest,
+	hashBridgeManifest: () => hashBridgeManifest,
+	hashZeroIdentity: () => hashZeroIdentity
+});
+module.exports = __toCommonJS(identity_exports);
+var import_compiler_core = require("@tamagui/compiler-core");
+var import_node_crypto = require("node:crypto");
+const ZERO_COMPILER_VERSION = `zero-1/plan-${import_compiler_core.LOWERED_MODULE_PLAN_VERSION}`;
+function hashZeroIdentity(identity) {
+	const canonical = {
+		runtimeLiteral: identity.runtimeLiteral,
+		target: identity.target,
+		configGeneration: identity.configGeneration,
+		cssHash: identity.cssHash,
+		compilerVersion: identity.compilerVersion,
+		islandEntries: [...identity.islandEntries].sort(),
+		bridgeManifestHash: identity.bridgeManifestHash,
+		islandOutputHashes: Object.fromEntries(Object.entries(identity.islandOutputHashes).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0))
+	};
+	return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 24);
+}
+function canonicalizeBridgeManifest(manifest) {
+	if (Array.isArray(manifest)) {
+		return manifest.map((entry) => canonicalizeBridgeManifest(entry));
+	}
+	if (manifest && typeof manifest === "object") {
+		const sorted = {};
+		for (const key of Object.keys(manifest).sort()) {
+			sorted[key] = canonicalizeBridgeManifest(manifest[key]);
+		}
+		return sorted;
+	}
+	return manifest;
+}
+function hashBridgeManifest(manifest) {
+	return (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(canonicalizeBridgeManifest(manifest))).digest("hex").slice(0, 16);
+}

package/dist/cjs/zero/index.cjs

@@ -0,0 +1,26 @@
+
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var zero_exports = {};
+module.exports = __toCommonJS(zero_exports);
+__reExport(zero_exports, require("./artifact.cjs"), module.exports);
+__reExport(zero_exports, require("./graph.cjs"), module.exports);
+__reExport(zero_exports, require("./identity.cjs"), module.exports);
+__reExport(zero_exports, require("./islands.cjs"), module.exports);
+__reExport(zero_exports, require("./options.cjs"), module.exports);
+__reExport(zero_exports, require("./ownership.cjs"), module.exports);
+__reExport(zero_exports, require("./theme.cjs"), module.exports);
+__reExport(zero_exports, require("./transform.cjs"), module.exports);