@terrazzo/cli 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/index.js

@@ -1,9 +1,17 @@
-import { createRequire } from "node:module";
+import { builtinModules, createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { build, defineConfig as defineConfig$1, parse } from "@terrazzo/parser";
-import fs, { createReadStream, createWriteStream } from "node:fs";
-import path from "node:path";
+import fs, { createReadStream, createWriteStream, existsSync, promises } from "node:fs";
+import path, { dirname, resolve } from "node:path";
 import pc from "picocolors";
+import { createServer, version } from "vite";
+import process$1 from "node:process";
+import { Buffer as Buffer$1 } from "node:buffer";
+import { isatty } from "node:tty";
+import { formatWithOptions, inspect } from "node:util";
+import vm from "node:vm";
+import assert from "node:assert";
+import { performance as performance$1 } from "node:perf_hooks";
 import chokidar from "chokidar";
 import yamlToMomoa from "yaml-to-momoa";
 import { exec } from "node:child_process";
@@ -17,15 +25,1716 @@ import { Readable, Writable } from "node:stream";
 import { serve } from "@hono/node-server";
 import mime from "mime";
 import * as momoa from "@humanwhocodes/momoa";
-import { getObjMember, getObjMembers, traverseAsync } from "@terrazzo/json-schema-tools";
+import { getObjMember, getObjMembers, traverse } from "@terrazzo/json-schema-tools";
 
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const normalize = function(path$1) {
+	if (path$1.length === 0) return ".";
+	path$1 = normalizeWindowsPath(path$1);
+	const isUNCPath = path$1.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path$1);
+	const trailingSeparator = path$1[path$1.length - 1] === "/";
+	path$1 = normalizeString(path$1, !isPathAbsolute);
+	if (path$1.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path$1 += "/";
+	if (_DRIVE_LETTER_RE.test(path$1)) path$1 += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path$1}`;
+		return `//${path$1}`;
+	}
+	return isPathAbsolute && !isAbsolute(path$1) ? `/${path$1}` : path$1;
+};
+const join = function(...segments) {
+	let path$1 = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path$1.length > 0) {
+			const pathTrailing = path$1[path$1.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path$1 += seg.slice(1);
+			else path$1 += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path$1 += seg;
+	}
+	return normalize(path$1);
+};
+function cwd$1() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve$1 = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path$1 = index >= 0 ? arguments_[index] : cwd$1();
+		if (!path$1 || path$1.length === 0) continue;
+		resolvedPath = `${path$1}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path$1);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path$1, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path$1.length; ++index) {
+		if (index < path$1.length) char = path$1[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path$1.slice(lastSlash + 1, index)}`;
+				else res = path$1.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const relative = function(from, to) {
+	const _from = resolve$1(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve$1(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname$1 = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/vite-node@5.2.0_@types+node@24.10.1_jiti@2.6.1_sass-embedded@1.85.1_yaml@2.8.1/node_modules/vite-node/dist/utils-ExLpYVUV.mjs
+const isWindows = process$1.platform === "win32";
+const drive = isWindows ? process$1.cwd()[0] : null;
+const driveOpposite = drive ? drive === drive.toUpperCase() ? drive.toLowerCase() : drive.toUpperCase() : null;
+const driveRegexp = drive ? /* @__PURE__ */ new RegExp(`(?:^|/@fs/)${drive}(\:[\\/])`) : null;
+const driveOppositeRegext = driveOpposite ? /* @__PURE__ */ new RegExp(`(?:^|/@fs/)${driveOpposite}(\:[\\/])`) : null;
+function slash(str) {
+	return str.replace(/\\/g, "/");
+}
+const bareImportRE = /^(?![a-z]:)[\w@](?!.*:\/\/)/i;
+function isBareImport(id) {
+	return bareImportRE.test(id);
+}
+function normalizeRequestId(id, base) {
+	if (base && id.startsWith(withTrailingSlash(base))) id = `/${id.slice(base.length)}`;
+	if (driveRegexp && !driveRegexp?.test(id) && driveOppositeRegext?.test(id)) id = id.replace(driveOppositeRegext, `${drive}$1`);
+	if (id.startsWith("file://")) {
+		const { file, postfix } = splitFileAndPostfix(id);
+		return fileURLToPath(file) + postfix;
+	}
+	return id.replace(/^\/@id\/__x00__/, "\0").replace(/^\/@id\//, "").replace(/^__vite-browser-external:/, "").replace(/\?v=\w+/, "?").replace(/&v=\w+/, "").replace(/\?t=\w+/, "?").replace(/&t=\w+/, "").replace(/\?import/, "?").replace(/&import/, "").replace(/\?&/, "?").replace(/\?+$/, "");
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function splitFileAndPostfix(path$1) {
+	const file = cleanUrl(path$1);
+	return {
+		file,
+		postfix: path$1.slice(file.length)
+	};
+}
+const internalRequestRegexp = /* @__PURE__ */ new RegExp(`^/?(?:${["@vite/client", "@vite/env"].join("|")})$`);
+function isInternalRequest(id) {
+	return internalRequestRegexp.test(id);
+}
+const prefixedBuiltins = new Set([
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters"
+]);
+const builtins = new Set([
+	...builtinModules,
+	"assert/strict",
+	"diagnostics_channel",
+	"dns/promises",
+	"fs/promises",
+	"path/posix",
+	"path/win32",
+	"readline/promises",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"timers/promises",
+	"util/types",
+	"wasi"
+]);
+function normalizeModuleId(id) {
+	if (prefixedBuiltins.has(id)) return id;
+	if (id.startsWith("file://")) return fileURLToPath(id);
+	return id.replace(/\\/g, "/").replace(/^\/@fs\//, isWindows ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
+}
+function isPrimitive(v) {
+	return v !== Object(v);
+}
+function toFilePath(id, root) {
+	let { absolute, exists } = (() => {
+		if (id.startsWith("/@fs/")) return {
+			absolute: id.slice(4),
+			exists: true
+		};
+		if (!id.startsWith(withTrailingSlash(root)) && id.startsWith("/")) {
+			const resolved = resolve$1(root, id.slice(1));
+			if (existsSync(cleanUrl(resolved))) return {
+				absolute: resolved,
+				exists: true
+			};
+		} else if (id.startsWith(withTrailingSlash(root)) && existsSync(cleanUrl(id))) return {
+			absolute: id,
+			exists: true
+		};
+		return {
+			absolute: id,
+			exists: false
+		};
+	})();
+	if (absolute.startsWith("//")) absolute = absolute.slice(1);
+	return {
+		path: isWindows && absolute.startsWith("/") ? slash(fileURLToPath(pathToFileURL(absolute.slice(1)).href)) : absolute,
+		exists
+	};
+}
+const NODE_BUILTIN_NAMESPACE = "node:";
+function isNodeBuiltin(id) {
+	if (prefixedBuiltins.has(id)) return true;
+	return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
+}
+/**
+* Convert `Arrayable<T>` to `Array<T>`
+*
+* @category Array
+*/
+function toArray(array) {
+	if (array === null || array === void 0) array = [];
+	if (Array.isArray(array)) return array;
+	return [array];
+}
+function getCachedData(cache, basedir, originalBasedir) {
+	const pkgData = cache.get(getFnpdCacheKey(basedir));
+	if (pkgData) {
+		traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+			cache.set(getFnpdCacheKey(dir), pkgData);
+		});
+		return pkgData;
+	}
+}
+function setCacheData(cache, data, basedir, originalBasedir) {
+	cache.set(getFnpdCacheKey(basedir), data);
+	traverseBetweenDirs(originalBasedir, basedir, (dir) => {
+		cache.set(getFnpdCacheKey(dir), data);
+	});
+}
+function getFnpdCacheKey(basedir) {
+	return `fnpd_${basedir}`;
+}
+/**
+* Traverse between `longerDir` (inclusive) and `shorterDir` (exclusive) and call `cb` for each dir.
+* @param longerDir Longer dir path, e.g. `/User/foo/bar/baz`
+* @param shorterDir Shorter dir path, e.g. `/User/foo`
+*/
+function traverseBetweenDirs(longerDir, shorterDir, cb) {
+	while (longerDir !== shorterDir) {
+		cb(longerDir);
+		longerDir = dirname$1(longerDir);
+	}
+}
+function withTrailingSlash(path$1) {
+	if (path$1[path$1.length - 1] !== "/") return `${path$1}/`;
+	return path$1;
+}
+function createImportMetaEnvProxy() {
+	const booleanKeys = [
+		"DEV",
+		"PROD",
+		"SSR"
+	];
+	return new Proxy(process$1.env, {
+		get(_, key) {
+			if (typeof key !== "string") return;
+			if (booleanKeys.includes(key)) return !!process$1.env[key];
+			return process$1.env[key];
+		},
+		set(_, key, value) {
+			if (typeof key !== "string") return true;
+			if (booleanKeys.includes(key)) process$1.env[key] = value ? "1" : "";
+			else process$1.env[key] = value;
+			return true;
+		}
+	});
+}
+const packageCache = /* @__PURE__ */ new Map();
+async function findNearestPackageData(basedir) {
+	const originalBasedir = basedir;
+	while (basedir) {
+		const cached = getCachedData(packageCache, basedir, originalBasedir);
+		if (cached) return cached;
+		const pkgPath = join(basedir, "package.json");
+		if ((await promises.stat(pkgPath).catch(() => {}))?.isFile()) {
+			const pkgData = JSON.parse(await promises.readFile(pkgPath, "utf8"));
+			if (packageCache) setCacheData(packageCache, pkgData, basedir, originalBasedir);
+			return pkgData;
+		}
+		const nextBasedir = dirname$1(basedir);
+		if (nextBasedir === basedir) break;
+		basedir = nextBasedir;
+	}
+	return {};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/vite-node@5.2.0_@types+node@24.10.1_jiti@2.6.1_sass-embedded@1.85.1_yaml@2.8.1/node_modules/vite-node/dist/source-map-DQLD3K8K.mjs
+var comma = ",".charCodeAt(0);
+";".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+	const c = chars.charCodeAt(i);
+	intToChar[i] = c;
+	charToInt[c] = i;
+}
+const fileContentsCache = {};
+const reSourceMap = /^data:application\/json[^,]+base64,/;
+let retrieveFileHandlers = [];
+let retrieveMapHandlers = [];
+function handlerExec(list) {
+	return function(arg) {
+		for (let i = 0; i < list.length; i++) {
+			const ret = list[i](arg);
+			if (ret) return ret;
+		}
+		return null;
+	};
+}
+let retrieveFile = handlerExec(retrieveFileHandlers);
+retrieveFileHandlers.push((path$1) => {
+	path$1 = path$1.trim();
+	if (path$1.startsWith("file:")) path$1 = path$1.replace(/file:\/\/\/(\w:)?/, (protocol, drive$1) => {
+		return drive$1 ? "" : "/";
+	});
+	if (path$1 in fileContentsCache) return fileContentsCache[path$1];
+	let contents = "";
+	try {
+		if (fs.existsSync(path$1)) contents = fs.readFileSync(path$1, "utf8");
+	} catch {}
+	return fileContentsCache[path$1] = contents;
+});
+function supportRelativeURL(file, url) {
+	if (!file) return url;
+	const dir = path.dirname(file);
+	const match = /^\w+:\/\/[^/]*/.exec(dir);
+	let protocol = match ? match[0] : "";
+	const startPath = dir.slice(protocol.length);
+	if (protocol && /^\/\w:/.test(startPath)) {
+		protocol += "/";
+		return protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
+	}
+	return protocol + path.resolve(dir.slice(protocol.length), url);
+}
+function retrieveSourceMapURL(source) {
+	const fileData = retrieveFile(source);
+	if (!fileData) return null;
+	const re = /\/\/[@#]\s*sourceMappingURL=([^\s'"]+)\s*$|\/\*[@#]\s*sourceMappingURL=[^\s*'"]+\s*\*\/\s*$/gm;
+	let lastMatch, match;
+	while (match = re.exec(fileData)) lastMatch = match;
+	if (!lastMatch) return null;
+	return lastMatch[1];
+}
+let retrieveSourceMap = handlerExec(retrieveMapHandlers);
+retrieveMapHandlers.push((source) => {
+	let sourceMappingURL = retrieveSourceMapURL(source);
+	if (!sourceMappingURL) return null;
+	let sourceMapData;
+	if (reSourceMap.test(sourceMappingURL)) {
+		const rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
+		sourceMapData = Buffer$1.from(rawData, "base64").toString();
+		sourceMappingURL = source;
+	} else {
+		sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
+		sourceMapData = retrieveFile(sourceMappingURL);
+	}
+	if (!sourceMapData) return null;
+	return {
+		url: sourceMappingURL,
+		map: sourceMapData
+	};
+});
+retrieveFileHandlers.slice(0);
+retrieveMapHandlers.slice(0);
+let SOURCEMAPPING_URL = "sourceMa";
+SOURCEMAPPING_URL += "ppingURL";
+const VITE_NODE_SOURCEMAPPING_SOURCE = "//# sourceMappingSource=vite-node";
+const VITE_NODE_SOURCEMAPPING_URL = `${SOURCEMAPPING_URL}=data:application/json;charset=utf-8`;
+function withInlineSourcemap(result, options) {
+	const map = result.map;
+	let code = result.code;
+	if (!map || code.includes(VITE_NODE_SOURCEMAPPING_SOURCE)) return result;
+	if ("sources" in map) map.sources = map.sources?.map((source) => {
+		if (!source) return source;
+		if (isAbsolute(source)) {
+			const actualPath = !source.startsWith(withTrailingSlash(options.root)) && source.startsWith("/") ? resolve$1(options.root, source.slice(1)) : source;
+			return relative(dirname$1(options.filepath), actualPath);
+		}
+		return source;
+	});
+	const OTHER_SOURCE_MAP_REGEXP = new RegExp(`//# ${SOURCEMAPPING_URL}=data:application/json[^,]+base64,([A-Za-z0-9+/=]+)$`, "gm");
+	while (OTHER_SOURCE_MAP_REGEXP.test(code)) code = code.replace(OTHER_SOURCE_MAP_REGEXP, "");
+	if (!options.noFirstLineMapping && map.mappings.startsWith(";")) map.mappings = `AAAA,CAAA${map.mappings}`;
+	const sourceMap = Buffer$1.from(JSON.stringify(map), "utf-8").toString("base64");
+	result.code = `${code.trimEnd()}\n\n${VITE_NODE_SOURCEMAPPING_SOURCE}\n//# ${VITE_NODE_SOURCEMAPPING_URL};base64,${sourceMap}\n`;
+	return result;
+}
+function extractSourceMap(code) {
+	const regexp = new RegExp(`//# ${VITE_NODE_SOURCEMAPPING_URL};base64,(.+)`, "gm");
+	let lastMatch, match;
+	while (match = regexp.exec(code)) lastMatch = match;
+	if (lastMatch) return JSON.parse(Buffer$1.from(lastMatch[1], "base64").toString("utf-8"));
+	return null;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/obug@2.1.0/node_modules/obug/dist/core.js
+function coerce(value) {
+	if (value instanceof Error) return value.stack || value.message;
+	return value;
+}
+function selectColor(colors$1, namespace) {
+	let hash = 0;
+	for (let i = 0; i < namespace.length; i++) {
+		hash = (hash << 5) - hash + namespace.charCodeAt(i);
+		hash |= 0;
+	}
+	return colors$1[Math.abs(hash) % colors$1.length];
+}
+function matchesTemplate(search, template) {
+	let searchIndex = 0;
+	let templateIndex = 0;
+	let starIndex = -1;
+	let matchIndex = 0;
+	while (searchIndex < search.length) if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) if (template[templateIndex] === "*") {
+		starIndex = templateIndex;
+		matchIndex = searchIndex;
+		templateIndex++;
+	} else {
+		searchIndex++;
+		templateIndex++;
+	}
+	else if (starIndex !== -1) {
+		templateIndex = starIndex + 1;
+		matchIndex++;
+		searchIndex = matchIndex;
+	} else return false;
+	while (templateIndex < template.length && template[templateIndex] === "*") templateIndex++;
+	return templateIndex === template.length;
+}
+function humanize(value) {
+	if (value >= 1e3) return `${(value / 1e3).toFixed(1)}s`;
+	return `${value}ms`;
+}
+let globalNamespaces = "";
+function createDebug$1(namespace, options) {
+	let prevTime;
+	let enableOverride;
+	let namespacesCache;
+	let enabledCache;
+	const debug = (...args) => {
+		if (!debug.enabled) return;
+		const curr = Date.now();
+		const diff = curr - (prevTime || curr);
+		prevTime = curr;
+		args[0] = coerce(args[0]);
+		if (typeof args[0] !== "string") args.unshift("%O");
+		let index = 0;
+		args[0] = args[0].replace(/%([a-z%])/gi, (match, format) => {
+			if (match === "%%") return "%";
+			index++;
+			const formatter = options.formatters[format];
+			if (typeof formatter === "function") {
+				const value = args[index];
+				match = formatter.call(debug, value);
+				args.splice(index, 1);
+				index--;
+			}
+			return match;
+		});
+		options.formatArgs.call(debug, diff, args);
+		debug.log(...args);
+	};
+	debug.extend = function(namespace$1, delimiter = ":") {
+		return createDebug$1(this.namespace + delimiter + namespace$1, {
+			useColors: this.useColors,
+			color: this.color,
+			formatArgs: this.formatArgs,
+			formatters: this.formatters,
+			inspectOpts: this.inspectOpts,
+			log: this.log,
+			humanize: this.humanize
+		});
+	};
+	Object.assign(debug, options);
+	debug.namespace = namespace;
+	Object.defineProperty(debug, "enabled", {
+		enumerable: true,
+		configurable: false,
+		get: () => {
+			if (enableOverride != null) return enableOverride;
+			if (namespacesCache !== globalNamespaces) {
+				namespacesCache = globalNamespaces;
+				enabledCache = enabled(namespace);
+			}
+			return enabledCache;
+		},
+		set: (v) => {
+			enableOverride = v;
+		}
+	});
+	return debug;
+}
+let names = [];
+let skips = [];
+function enable(namespaces$1) {
+	globalNamespaces = namespaces$1;
+	names = [];
+	skips = [];
+	const split = globalNamespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+	for (const ns of split) if (ns[0] === "-") skips.push(ns.slice(1));
+	else names.push(ns);
+}
+function enabled(name) {
+	for (const skip of skips) if (matchesTemplate(name, skip)) return false;
+	for (const ns of names) if (matchesTemplate(name, ns)) return true;
+	return false;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/obug@2.1.0/node_modules/obug/dist/node.js
+const colors = process.stderr.getColorDepth && process.stderr.getColorDepth() > 2 ? [
+	20,
+	21,
+	26,
+	27,
+	32,
+	33,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	56,
+	57,
+	62,
+	63,
+	68,
+	69,
+	74,
+	75,
+	76,
+	77,
+	78,
+	79,
+	80,
+	81,
+	92,
+	93,
+	98,
+	99,
+	112,
+	113,
+	128,
+	129,
+	134,
+	135,
+	148,
+	149,
+	160,
+	161,
+	162,
+	163,
+	164,
+	165,
+	166,
+	167,
+	168,
+	169,
+	170,
+	171,
+	172,
+	173,
+	178,
+	179,
+	184,
+	185,
+	196,
+	197,
+	198,
+	199,
+	200,
+	201,
+	202,
+	203,
+	204,
+	205,
+	206,
+	207,
+	208,
+	209,
+	214,
+	215,
+	220,
+	221
+] : [
+	6,
+	2,
+	3,
+	4,
+	5,
+	1
+];
+const inspectOpts = Object.keys(process.env).filter((key) => /^debug_/i.test(key)).reduce((obj, key) => {
+	const prop = key.slice(6).toLowerCase().replace(/_([a-z])/g, (_, k) => k.toUpperCase());
+	let value = process.env[key];
+	if (value === "null") value = null;
+	else if (/^yes|on|true|enabled$/i.test(value)) value = true;
+	else if (/^no|off|false|disabled$/i.test(value)) value = false;
+	else value = Number(value);
+	obj[prop] = value;
+	return obj;
+}, {});
+function useColors() {
+	return "colors" in inspectOpts ? Boolean(inspectOpts.colors) : isatty(process.stderr.fd);
+}
+function getDate() {
+	if (inspectOpts.hideDate) return "";
+	return `${(/* @__PURE__ */ new Date()).toISOString()} `;
+}
+function formatArgs(diff, args) {
+	const { namespace: name, useColors: useColors$1 } = this;
+	if (useColors$1) {
+		const c = this.color;
+		const colorCode = `\u001B[3${c < 8 ? c : `8;5;${c}`}`;
+		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
+		args[0] = prefix + args[0].split("\n").join(`\n${prefix}`);
+		args.push(`${colorCode}m+${this.humanize(diff)}\u001B[0m`);
+	} else args[0] = `${getDate()}${name} ${args[0]}`;
+}
+function log(...args) {
+	process.stderr.write(`${formatWithOptions(this.inspectOpts, ...args)}\n`);
+}
+const defaultOptions = {
+	useColors: useColors(),
+	formatArgs,
+	formatters: {
+		o(v) {
+			this.inspectOpts.colors = this.useColors;
+			return inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+		},
+		O(v) {
+			this.inspectOpts.colors = this.useColors;
+			return inspect(v, this.inspectOpts);
+		}
+	},
+	inspectOpts,
+	log,
+	humanize
+};
+function createDebug(namespace, options) {
+	var _ref;
+	const color = (_ref = options && options.color) !== null && _ref !== void 0 ? _ref : selectColor(colors, namespace);
+	return createDebug$1(namespace, Object.assign(defaultOptions, { color }, options));
+}
+enable(process.env.DEBUG || "");
+
+//#endregion
+//#region ../../node_modules/.pnpm/vite-node@5.2.0_@types+node@24.10.1_jiti@2.6.1_sass-embedded@1.85.1_yaml@2.8.1/node_modules/vite-node/dist/client-CyS7w_FB.mjs
+const { setTimeout: setTimeout$1, clearTimeout: clearTimeout$1 } = globalThis;
+const debugExecute = createDebug("vite-node:client:execute");
+const debugNative = createDebug("vite-node:client:native");
+const clientStub = {
+	injectQuery: (id) => id,
+	createHotContext: () => {
+		return {
+			accept: () => {},
+			prune: () => {},
+			dispose: () => {},
+			decline: () => {},
+			invalidate: () => {},
+			on: () => {},
+			send: () => {}
+		};
+	},
+	updateStyle: () => {},
+	removeStyle: () => {}
+};
+const env = createImportMetaEnvProxy();
+const DEFAULT_REQUEST_STUBS = {
+	"/@vite/client": clientStub,
+	"@vite/client": clientStub
+};
+var ModuleCacheMap = class extends Map {
+	normalizePath(fsPath) {
+		return normalizeModuleId(fsPath);
+	}
+	/**
+	* Assign partial data to the map
+	*/
+	update(fsPath, mod) {
+		fsPath = this.normalizePath(fsPath);
+		if (!super.has(fsPath)) this.setByModuleId(fsPath, mod);
+		else Object.assign(super.get(fsPath), mod);
+		return this;
+	}
+	setByModuleId(modulePath, mod) {
+		return super.set(modulePath, mod);
+	}
+	set(fsPath, mod) {
+		return this.setByModuleId(this.normalizePath(fsPath), mod);
+	}
+	getByModuleId(modulePath) {
+		if (!super.has(modulePath)) this.setByModuleId(modulePath, {});
+		const mod = super.get(modulePath);
+		if (!mod.imports) Object.assign(mod, {
+			imports: /* @__PURE__ */ new Set(),
+			importers: /* @__PURE__ */ new Set()
+		});
+		return mod;
+	}
+	get(fsPath) {
+		return this.getByModuleId(this.normalizePath(fsPath));
+	}
+	deleteByModuleId(modulePath) {
+		return super.delete(modulePath);
+	}
+	delete(fsPath) {
+		return this.deleteByModuleId(this.normalizePath(fsPath));
+	}
+	invalidateModule(mod) {
+		delete mod.evaluated;
+		delete mod.resolving;
+		delete mod.promise;
+		delete mod.exports;
+		mod.importers?.clear();
+		mod.imports?.clear();
+		return true;
+	}
+	/**
+	* Invalidate modules that dependent on the given modules, up to the main entry
+	*/
+	invalidateDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+		for (const _id of ids) {
+			const id = this.normalizePath(_id);
+			if (invalidated.has(id)) continue;
+			invalidated.add(id);
+			const mod = super.get(id);
+			if (mod?.importers) this.invalidateDepTree(mod.importers, invalidated);
+			super.delete(id);
+		}
+		return invalidated;
+	}
+	/**
+	* Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+	*/
+	invalidateSubDepTree(ids, invalidated = /* @__PURE__ */ new Set()) {
+		for (const _id of ids) {
+			const id = this.normalizePath(_id);
+			if (invalidated.has(id)) continue;
+			invalidated.add(id);
+			const subIds = Array.from(super.entries()).filter(([, mod]) => mod.importers?.has(id)).map(([key]) => key);
+			if (subIds.length) this.invalidateSubDepTree(subIds, invalidated);
+			super.delete(id);
+		}
+		return invalidated;
+	}
+	/**
+	* Return parsed source map based on inlined source map of the module
+	*/
+	getSourceMap(id) {
+		const cache = this.get(id);
+		if (cache.map) return cache.map;
+		const map = cache.code && extractSourceMap(cache.code);
+		if (map) {
+			cache.map = map;
+			return map;
+		}
+		return null;
+	}
+};
+var ViteNodeRunner = class {
+	root;
+	debug;
+	/**
+	* Holds the cache of modules
+	* Keys of the map are filepaths, or plain package names
+	*/
+	moduleCache;
+	/**
+	* Tracks the stack of modules being executed for the purpose of calculating import self-time.
+	*
+	* Note that while in most cases, imports are a linear stack of modules,
+	* this is occasionally not the case, for example when you have parallel top-level dynamic imports like so:
+	*
+	* ```ts
+	* await Promise.all([
+	*  import('./module1'),
+	*  import('./module2'),
+	* ]);
+	* ```
+	*
+	* In this case, the self time will be reported incorrectly for one of the modules (could go negative).
+	* As top-level awaits with dynamic imports like this are uncommon, we don't handle this case specifically.
+	*/
+	executionStack = [];
+	performanceNow = performance.now.bind(performance);
+	constructor(options) {
+		this.options = options;
+		this.root = options.root ?? process$1.cwd();
+		this.moduleCache = options.moduleCache ?? new ModuleCacheMap();
+		this.debug = options.debug ?? (typeof process$1 !== "undefined" ? !!process$1.env.VITE_NODE_DEBUG_RUNNER : false);
+	}
+	async executeFile(file) {
+		const url = `/@fs/${slash(resolve(file))}`;
+		return await this.cachedRequest(url, url, []);
+	}
+	async executeId(rawId) {
+		const [id, url] = await this.resolveUrl(rawId);
+		return await this.cachedRequest(id, url, []);
+	}
+	/** @internal */
+	async cachedRequest(id, fsPath, callstack) {
+		const importee = callstack[callstack.length - 1];
+		const mod = this.moduleCache.get(fsPath);
+		const { imports, importers } = mod;
+		if (importee) importers.add(importee);
+		const getStack = () => `stack:\n${[...callstack, fsPath].reverse().map((p) => `  - ${p}`).join("\n")}`;
+		if (callstack.includes(fsPath) || Array.from(imports.values()).some((i) => importers.has(i))) {
+			if (mod.exports) return mod.exports;
+		}
+		let debugTimer;
+		if (this.debug) debugTimer = setTimeout$1(() => console.warn(`[vite-node] module ${fsPath} takes over 2s to load.\n${getStack()}`), 2e3);
+		try {
+			if (mod.promise) return await mod.promise;
+			const promise = this.directRequest(id, fsPath, callstack);
+			Object.assign(mod, {
+				promise,
+				evaluated: false
+			});
+			return await promise;
+		} finally {
+			mod.evaluated = true;
+			if (debugTimer) clearTimeout$1(debugTimer);
+		}
+	}
+	shouldResolveId(id, _importee) {
+		return !isInternalRequest(id) && !isNodeBuiltin(id) && !id.startsWith("data:");
+	}
+	async _resolveUrl(id, importer) {
+		const dep = normalizeRequestId(id, this.options.base);
+		if (!this.shouldResolveId(dep)) return [dep, dep];
+		const { path: path$1, exists } = toFilePath(dep, this.root);
+		if (!this.options.resolveId || exists) return [dep, path$1];
+		const resolved = await this.options.resolveId(dep, importer);
+		if (resolved?.meta?.["vite:alias"]?.noResolved) {
+			const error = /* @__PURE__ */ new Error(`Cannot find module '${id}'${importer ? ` imported from '${importer}'` : ""}.
+
+- If you rely on tsconfig.json's "paths" to resolve modules, please install "vite-tsconfig-paths" plugin to handle module resolution.
+- Make sure you don't have relative aliases in your Vitest config. Use absolute paths instead. Read more: https://vitest.dev/guide/common-errors`);
+			Object.defineProperty(error, "code", {
+				value: "ERR_MODULE_NOT_FOUND",
+				enumerable: true
+			});
+			Object.defineProperty(error, Symbol.for("vitest.error.not_found.data"), {
+				value: {
+					id: dep,
+					importer
+				},
+				enumerable: false
+			});
+			throw error;
+		}
+		const resolvedId = resolved ? normalizeRequestId(resolved.id, this.options.base) : dep;
+		return [resolvedId, resolvedId];
+	}
+	async resolveUrl(id, importee) {
+		const resolveKey = `resolve:${id}`;
+		this.moduleCache.setByModuleId(resolveKey, { resolving: true });
+		try {
+			return await this._resolveUrl(id, importee);
+		} finally {
+			this.moduleCache.deleteByModuleId(resolveKey);
+		}
+	}
+	/** @internal */
+	async dependencyRequest(id, fsPath, callstack) {
+		return await this.cachedRequest(id, fsPath, callstack);
+	}
+	async _fetchModule(id, importer) {
+		try {
+			return await this.options.fetchModule(id);
+		} catch (cause) {
+			if (typeof cause === "object" && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url")) {
+				const error = new Error(`Cannot find ${isBareImport(id) ? "package" : "module"} '${id}'${importer ? ` imported from '${importer}'` : ""}`, { cause });
+				error.code = "ERR_MODULE_NOT_FOUND";
+				throw error;
+			}
+			throw cause;
+		}
+	}
+	/** @internal */
+	async directRequest(id, fsPath, _callstack) {
+		const moduleId = normalizeModuleId(fsPath);
+		const callstack = [..._callstack, moduleId];
+		const mod = this.moduleCache.getByModuleId(moduleId);
+		const request = async (dep) => {
+			const [id$1, depFsPath] = await this.resolveUrl(String(dep), fsPath);
+			this.moduleCache.getByModuleId(depFsPath).importers.add(moduleId);
+			mod.imports.add(depFsPath);
+			return this.dependencyRequest(id$1, depFsPath, callstack);
+		};
+		const requestStubs = this.options.requestStubs || DEFAULT_REQUEST_STUBS;
+		if (id in requestStubs) return requestStubs[id];
+		let { code: transformed, externalize } = await this._fetchModule(id, callstack[callstack.length - 2]);
+		if (externalize) {
+			debugNative(externalize);
+			const exports$1 = await this.interopedImport(externalize);
+			mod.exports = exports$1;
+			return exports$1;
+		}
+		if (transformed == null) throw new Error(`[vite-node] Failed to load "${id}" imported from ${callstack[callstack.length - 2]}`);
+		const { Object: Object$1, Reflect: Reflect$1, Symbol: Symbol$1 } = this.getContextPrimitives();
+		const modulePath = cleanUrl(moduleId);
+		const href = pathToFileURL(modulePath).href;
+		const __filename = fileURLToPath(href);
+		const __dirname = dirname(__filename);
+		const meta = {
+			url: href,
+			env,
+			filename: __filename,
+			dirname: __dirname
+		};
+		const exports = Object$1.create(null);
+		Object$1.defineProperty(exports, Symbol$1.toStringTag, {
+			value: "Module",
+			enumerable: false,
+			configurable: false
+		});
+		const SYMBOL_NOT_DEFINED = Symbol$1("not defined");
+		let moduleExports = SYMBOL_NOT_DEFINED;
+		const cjsExports = new Proxy(exports, {
+			get: (target, p, receiver) => {
+				if (Reflect$1.has(target, p)) return Reflect$1.get(target, p, receiver);
+				return Reflect$1.get(Object$1.prototype, p, receiver);
+			},
+			getPrototypeOf: () => Object$1.prototype,
+			set: (_, p, value) => {
+				if (p === "default" && this.shouldInterop(modulePath, { default: value }) && cjsExports !== value) {
+					exportAll(cjsExports, value);
+					exports.default = value;
+					return true;
+				}
+				if (!Reflect$1.has(exports, "default")) exports.default = {};
+				if (moduleExports !== SYMBOL_NOT_DEFINED && isPrimitive(moduleExports)) {
+					defineExport(exports, p, () => void 0);
+					return true;
+				}
+				if (!isPrimitive(exports.default)) exports.default[p] = value;
+				if (p !== "default") defineExport(exports, p, () => value);
+				return true;
+			}
+		});
+		Object$1.assign(mod, {
+			code: transformed,
+			exports
+		});
+		const moduleProxy = {
+			set exports(value) {
+				exportAll(cjsExports, value);
+				exports.default = value;
+				moduleExports = value;
+			},
+			get exports() {
+				return cjsExports;
+			}
+		};
+		let hotContext;
+		if (this.options.createHotContext) Object$1.defineProperty(meta, "hot", {
+			enumerable: true,
+			get: () => {
+				hotContext ||= this.options.createHotContext?.(this, moduleId);
+				return hotContext;
+			},
+			set: (value) => {
+				hotContext = value;
+			}
+		});
+		const context = this.prepareContext({
+			__vite_ssr_import__: request,
+			__vite_ssr_dynamic_import__: request,
+			__vite_ssr_exports__: exports,
+			__vite_ssr_exportAll__: (obj) => exportAll(exports, obj),
+			__vite_ssr_exportName__: (name, getter) => Object$1.defineProperty(exports, name, {
+				enumerable: true,
+				configurable: true,
+				get: getter
+			}),
+			__vite_ssr_import_meta__: meta,
+			require: createRequire(href),
+			exports: cjsExports,
+			module: moduleProxy,
+			__filename,
+			__dirname
+		});
+		debugExecute(__filename);
+		if (transformed[0] === "#") transformed = transformed.replace(/^#!.*/, (s) => " ".repeat(s.length));
+		await this.runModule(context, transformed);
+		return exports;
+	}
+	getContextPrimitives() {
+		return {
+			Object,
+			Reflect,
+			Symbol
+		};
+	}
+	async runModule(context, transformed) {
+		const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
+		const code = `${codeDefinition}${transformed}\n}}`;
+		const options = {
+			filename: context.__filename,
+			lineOffset: 0,
+			columnOffset: -codeDefinition.length
+		};
+		const finishModuleExecutionInfo = this.startCalculateModuleExecutionInfo(options.filename, codeDefinition.length);
+		try {
+			await vm.runInThisContext(code, options)(...Object.values(context));
+		} finally {
+			this.options.moduleExecutionInfo?.set(options.filename, finishModuleExecutionInfo());
+		}
+	}
+	/**
+	* Starts calculating the module execution info such as the total duration and self time spent on executing the module.
+	* Returns a function to call once the module has finished executing.
+	*/
+	startCalculateModuleExecutionInfo(filename, startOffset) {
+		const startTime = this.performanceNow();
+		this.executionStack.push({
+			filename,
+			startTime,
+			subImportTime: 0
+		});
+		return () => {
+			const duration = this.performanceNow() - startTime;
+			const currentExecution = this.executionStack.pop();
+			if (currentExecution == null) throw new Error("Execution stack is empty, this should never happen");
+			const selfTime = duration - currentExecution.subImportTime;
+			if (this.executionStack.length > 0) this.executionStack.at(-1).subImportTime += duration;
+			return {
+				startOffset,
+				duration,
+				selfTime
+			};
+		};
+	}
+	prepareContext(context) {
+		return context;
+	}
+	/**
+	* Define if a module should be interop-ed
+	* This function mostly for the ability to override by subclass
+	*/
+	shouldInterop(path$1, mod) {
+		if (this.options.interopDefault === false) return false;
+		return !path$1.endsWith(".mjs") && "default" in mod;
+	}
+	importExternalModule(path$1) {
+		return import(
+			/* @vite-ignore */
+			path$1
+);
+	}
+	/**
+	* Import a module and interop it
+	*/
+	async interopedImport(path$1) {
+		const importedModule = await this.importExternalModule(path$1);
+		if (!this.shouldInterop(path$1, importedModule)) return importedModule;
+		const { mod, defaultExport } = interopModule(importedModule);
+		return new Proxy(mod, {
+			get(mod$1, prop) {
+				if (prop === "default") return defaultExport;
+				return mod$1[prop] ?? defaultExport?.[prop];
+			},
+			has(mod$1, prop) {
+				if (prop === "default") return defaultExport !== void 0;
+				return prop in mod$1 || defaultExport && prop in defaultExport;
+			},
+			getOwnPropertyDescriptor(mod$1, prop) {
+				const descriptor = Reflect.getOwnPropertyDescriptor(mod$1, prop);
+				if (descriptor) return descriptor;
+				if (prop === "default" && defaultExport !== void 0) return {
+					value: defaultExport,
+					enumerable: true,
+					configurable: true
+				};
+			}
+		});
+	}
+};
+function interopModule(mod) {
+	if (isPrimitive(mod)) return {
+		mod: { default: mod },
+		defaultExport: mod
+	};
+	let defaultExport = "default" in mod ? mod.default : mod;
+	if (!isPrimitive(defaultExport) && "__esModule" in defaultExport) {
+		mod = defaultExport;
+		if ("default" in defaultExport) defaultExport = defaultExport.default;
+	}
+	return {
+		mod,
+		defaultExport
+	};
+}
+function defineExport(exports, key, value) {
+	Object.defineProperty(exports, key, {
+		enumerable: true,
+		configurable: true,
+		get: value
+	});
+}
+function exportAll(exports, sourceModule) {
+	if (exports === sourceModule) return;
+	if (isPrimitive(sourceModule) || Array.isArray(sourceModule) || sourceModule instanceof Promise) return;
+	for (const key in sourceModule) if (key !== "default" && !(key in exports)) try {
+		defineExport(exports, key, () => sourceModule[key]);
+	} catch {}
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/vite-node@5.2.0_@types+node@24.10.1_jiti@2.6.1_sass-embedded@1.85.1_yaml@2.8.1/node_modules/vite-node/dist/dist-B2ebky9O.mjs
+var d = {
+	reset: [0, 0],
+	bold: [
+		1,
+		22,
+		"\x1B[22m\x1B[1m"
+	],
+	dim: [
+		2,
+		22,
+		"\x1B[22m\x1B[2m"
+	],
+	italic: [3, 23],
+	underline: [4, 24],
+	inverse: [7, 27],
+	hidden: [8, 28],
+	strikethrough: [9, 29],
+	black: [30, 39],
+	red: [31, 39],
+	green: [32, 39],
+	yellow: [33, 39],
+	blue: [34, 39],
+	magenta: [35, 39],
+	cyan: [36, 39],
+	white: [37, 39],
+	gray: [90, 39],
+	bgBlack: [40, 49],
+	bgRed: [41, 49],
+	bgGreen: [42, 49],
+	bgYellow: [43, 49],
+	bgBlue: [44, 49],
+	bgMagenta: [45, 49],
+	bgCyan: [46, 49],
+	bgWhite: [47, 49],
+	blackBright: [90, 39],
+	redBright: [91, 39],
+	greenBright: [92, 39],
+	yellowBright: [93, 39],
+	blueBright: [94, 39],
+	magentaBright: [95, 39],
+	cyanBright: [96, 39],
+	whiteBright: [97, 39],
+	bgBlackBright: [100, 49],
+	bgRedBright: [101, 49],
+	bgGreenBright: [102, 49],
+	bgYellowBright: [103, 49],
+	bgBlueBright: [104, 49],
+	bgMagentaBright: [105, 49],
+	bgCyanBright: [106, 49],
+	bgWhiteBright: [107, 49]
+};
+function g(e) {
+	return String(e);
+}
+g.open = "";
+g.close = "";
+function h() {
+	let e = typeof process != "undefined" ? process : void 0, n = (e == null ? void 0 : e.env) || {}, a = n.FORCE_TTY !== "false", i = (e == null ? void 0 : e.argv) || [];
+	return !("NO_COLOR" in n || i.includes("--no-color")) && ("FORCE_COLOR" in n || i.includes("--color") || (e == null ? void 0 : e.platform) === "win32" || a && n.TERM !== "dumb" || "CI" in n) || typeof window != "undefined" && !!window.chrome;
+}
+function f() {
+	let e = h(), n = (r, t, u, o) => {
+		let l = "", s = 0;
+		do
+			l += r.substring(s, o) + u, s = o + t.length, o = r.indexOf(t, s);
+		while (~o);
+		return l + r.substring(s);
+	}, a = (r, t, u = r) => {
+		let o = (l) => {
+			let s = String(l), b = s.indexOf(t, r.length);
+			return ~b ? r + n(s, t, u, b) + t : r + s + t;
+		};
+		return o.open = r, o.close = t, o;
+	}, i = { isColorSupported: e }, c = (r) => `\x1B[${r}m`;
+	for (let r in d) {
+		let t = d[r];
+		i[r] = e ? a(c(t[0]), c(t[1]), t[2]) : g;
+	}
+	return i;
+}
+var C = f();
+
+//#endregion
+//#region ../../node_modules/.pnpm/vite-node@5.2.0_@types+node@24.10.1_jiti@2.6.1_sass-embedded@1.85.1_yaml@2.8.1/node_modules/vite-node/dist/constants-DRkacFwN.mjs
+const KNOWN_ASSET_TYPES = [
+	"apng",
+	"bmp",
+	"png",
+	"jpe?g",
+	"jfif",
+	"pjpeg",
+	"pjp",
+	"gif",
+	"svg",
+	"ico",
+	"webp",
+	"avif",
+	"mp4",
+	"webm",
+	"ogg",
+	"mp3",
+	"wav",
+	"flac",
+	"aac",
+	"woff2?",
+	"eot",
+	"ttf",
+	"otf",
+	"webmanifest",
+	"pdf",
+	"txt"
+];
+const KNOWN_ASSET_RE = /* @__PURE__ */ new RegExp(`\\.(${KNOWN_ASSET_TYPES.join("|")})$`);
+
+//#endregion
+//#region ../../node_modules/.pnpm/es-module-lexer@1.7.0/node_modules/es-module-lexer/dist/lexer.js
+var ImportType;
+(function(A$1) {
+	A$1[A$1.Static = 1] = "Static", A$1[A$1.Dynamic = 2] = "Dynamic", A$1[A$1.ImportMeta = 3] = "ImportMeta", A$1[A$1.StaticSourcePhase = 4] = "StaticSourcePhase", A$1[A$1.DynamicSourcePhase = 5] = "DynamicSourcePhase", A$1[A$1.StaticDeferPhase = 6] = "StaticDeferPhase", A$1[A$1.DynamicDeferPhase = 7] = "DynamicDeferPhase";
+})(ImportType || (ImportType = {}));
+const A = 1 === new Uint8Array(new Uint16Array([1]).buffer)[0];
+function parse$1(E$1, g$1 = "@") {
+	if (!C$1) return init.then((() => parse$1(E$1)));
+	const I = E$1.length + 1, w = (C$1.__heap_base.value || C$1.__heap_base) + 4 * I - C$1.memory.buffer.byteLength;
+	w > 0 && C$1.memory.grow(Math.ceil(w / 65536));
+	const K = C$1.sa(I - 1);
+	if ((A ? B : Q)(E$1, new Uint16Array(C$1.memory.buffer, K, I)), !C$1.parse()) throw Object.assign(/* @__PURE__ */ new Error(`Parse error ${g$1}:${E$1.slice(0, C$1.e()).split("\n").length}:${C$1.e() - E$1.lastIndexOf("\n", C$1.e() - 1)}`), { idx: C$1.e() });
+	const o = [], D = [];
+	for (; C$1.ri();) {
+		const A$1 = C$1.is(), Q$1 = C$1.ie(), B$1 = C$1.it(), g$2 = C$1.ai(), I$1 = C$1.id(), w$1 = C$1.ss(), K$1 = C$1.se();
+		let D$1;
+		C$1.ip() && (D$1 = k(E$1.slice(-1 === I$1 ? A$1 - 1 : A$1, -1 === I$1 ? Q$1 + 1 : Q$1))), o.push({
+			n: D$1,
+			t: B$1,
+			s: A$1,
+			e: Q$1,
+			ss: w$1,
+			se: K$1,
+			d: I$1,
+			a: g$2
+		});
+	}
+	for (; C$1.re();) {
+		const A$1 = C$1.es(), Q$1 = C$1.ee(), B$1 = C$1.els(), g$2 = C$1.ele(), I$1 = E$1.slice(A$1, Q$1), w$1 = I$1[0], K$1 = B$1 < 0 ? void 0 : E$1.slice(B$1, g$2), o$1 = K$1 ? K$1[0] : "";
+		D.push({
+			s: A$1,
+			e: Q$1,
+			ls: B$1,
+			le: g$2,
+			n: "\"" === w$1 || "'" === w$1 ? k(I$1) : I$1,
+			ln: "\"" === o$1 || "'" === o$1 ? k(K$1) : K$1
+		});
+	}
+	function k(A$1) {
+		try {
+			return (0, eval)(A$1);
+		} catch (A$2) {}
+	}
+	return [
+		o,
+		D,
+		!!C$1.f(),
+		!!C$1.ms()
+	];
+}
+function Q(A$1, Q$1) {
+	const B$1 = A$1.length;
+	let C$2 = 0;
+	for (; C$2 < B$1;) {
+		const B$2 = A$1.charCodeAt(C$2);
+		Q$1[C$2++] = (255 & B$2) << 8 | B$2 >>> 8;
+	}
+}
+function B(A$1, Q$1) {
+	const B$1 = A$1.length;
+	let C$2 = 0;
+	for (; C$2 < B$1;) Q$1[C$2] = A$1.charCodeAt(C$2++);
+}
+let C$1;
+const E = () => {
+	return A$1 = "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", "undefined" != typeof Buffer ? Buffer.from(A$1, "base64") : Uint8Array.from(atob(A$1), ((A$2) => A$2.charCodeAt(0)));
+	var A$1;
+};
+const init = WebAssembly.compile(E()).then(WebAssembly.instantiate).then((({ exports: A$1 }) => {
+	C$1 = A$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/vite-node@5.2.0_@types+node@24.10.1_jiti@2.6.1_sass-embedded@1.85.1_yaml@2.8.1/node_modules/vite-node/dist/server-BWywEVuB.mjs
+function hashCode(s) {
+	return s.split("").reduce((a, b) => {
+		a = (a << 5) - a + b.charCodeAt(0);
+		return a & a;
+	}, 0);
+}
+var Debugger = class {
+	dumpDir;
+	initPromise;
+	externalizeMap = /* @__PURE__ */ new Map();
+	constructor(root, options) {
+		this.options = options;
+		if (options.dumpModules) this.dumpDir = resolve$1(root, options.dumpModules === true ? ".vite-node/dump" : options.dumpModules);
+		if (this.dumpDir) if (options.loadDumppedModules) console.info(C.gray(`[vite-node] [debug] load modules from ${this.dumpDir}`));
+		else console.info(C.gray(`[vite-node] [debug] dump modules to ${this.dumpDir}`));
+		this.initPromise = this.clearDump();
+	}
+	async clearDump() {
+		if (!this.dumpDir) return;
+		if (!this.options.loadDumppedModules && existsSync(this.dumpDir)) await promises.rm(this.dumpDir, {
+			recursive: true,
+			force: true
+		});
+		await promises.mkdir(this.dumpDir, { recursive: true });
+	}
+	encodeId(id) {
+		return `${id.replace(/[^\w@\-]/g, "_").replace(/_+/g, "_")}-${hashCode(id)}.js`;
+	}
+	async recordExternalize(id, path$1) {
+		if (!this.dumpDir) return;
+		this.externalizeMap.set(id, path$1);
+		await this.writeInfo();
+	}
+	async dumpFile(id, result) {
+		if (!result || !this.dumpDir) return;
+		await this.initPromise;
+		const name = this.encodeId(id);
+		return await promises.writeFile(join(this.dumpDir, name), `// ${id.replace(/\0/g, "\\0")}\n${result.code}`, "utf-8");
+	}
+	async loadDump(id) {
+		if (!this.dumpDir) return null;
+		await this.initPromise;
+		const name = this.encodeId(id);
+		const path$1 = join(this.dumpDir, name);
+		if (!existsSync(path$1)) return null;
+		return {
+			code: (await promises.readFile(path$1, "utf-8")).replace(/^\/\/.*\n/, ""),
+			map: void 0
+		};
+	}
+	async writeInfo() {
+		if (!this.dumpDir) return;
+		const info = JSON.stringify({
+			time: (/* @__PURE__ */ new Date()).toLocaleString(),
+			externalize: Object.fromEntries(this.externalizeMap.entries())
+		}, null, 2);
+		return promises.writeFile(join(this.dumpDir, "info.json"), info, "utf-8");
+	}
+};
+const BUILTIN_EXTENSIONS = new Set([
+	".mjs",
+	".cjs",
+	".node",
+	".wasm"
+]);
+const ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/;
+const ESM_FOLDER_RE = /\/(es|esm)\/(.*\.js)$/;
+const defaultInline = [
+	/virtual:/,
+	/\.[mc]?ts$/,
+	/[?&](init|raw|url|inline)\b/,
+	KNOWN_ASSET_RE
+];
+const depsExternal = [/\/node_modules\/.*\.cjs\.js$/, /\/node_modules\/.*\.mjs$/];
+function guessCJSversion(id) {
+	if (id.match(ESM_EXT_RE)) {
+		for (const i of [
+			id.replace(ESM_EXT_RE, ".mjs"),
+			id.replace(ESM_EXT_RE, ".umd.js"),
+			id.replace(ESM_EXT_RE, ".cjs.js"),
+			id.replace(ESM_EXT_RE, ".js")
+		]) if (existsSync(i)) return i;
+	}
+	if (id.match(ESM_FOLDER_RE)) {
+		for (const i of [
+			id.replace(ESM_FOLDER_RE, "/umd/$1"),
+			id.replace(ESM_FOLDER_RE, "/cjs/$1"),
+			id.replace(ESM_FOLDER_RE, "/lib/$1"),
+			id.replace(ESM_FOLDER_RE, "/$1")
+		]) if (existsSync(i)) return i;
+	}
+}
+async function isValidNodeImport(id) {
+	const extension = extname(id);
+	if (BUILTIN_EXTENSIONS.has(extension)) return true;
+	if (extension !== ".js") return false;
+	id = id.replace("file:///", "");
+	if ((await findNearestPackageData(dirname$1(id))).type === "module") return true;
+	if (/\.(?:\w+-)?esm?(?:-\w+)?\.js$|\/esm?\//.test(id)) return false;
+	try {
+		await init;
+		const code = await promises.readFile(id, "utf8");
+		const [, , , hasModuleSyntax] = parse$1(code);
+		return !hasModuleSyntax;
+	} catch {
+		return false;
+	}
+}
+const _defaultExternalizeCache = /* @__PURE__ */ new Map();
+async function shouldExternalize(id, options, cache = _defaultExternalizeCache) {
+	if (!cache.has(id)) cache.set(id, _shouldExternalize(id, options));
+	return cache.get(id);
+}
+async function _shouldExternalize(id, options) {
+	if (isNodeBuiltin(id)) return id;
+	if (id.startsWith("data:") || /^(?:https?:)?\/\//.test(id)) return id;
+	id = patchWindowsImportPath(id);
+	const moduleDirectories = options?.moduleDirectories || ["/node_modules/"];
+	if (matchExternalizePattern(id, moduleDirectories, options?.inline)) return false;
+	if (options?.inlineFiles && options?.inlineFiles.includes(id)) return false;
+	if (matchExternalizePattern(id, moduleDirectories, options?.external)) return id;
+	if (options?.cacheDir && id.includes(options.cacheDir)) return id;
+	const isLibraryModule = moduleDirectories.some((dir) => id.includes(dir));
+	id = isLibraryModule && options?.fallbackCJS ? guessCJSversion(id) || id : id;
+	if (matchExternalizePattern(id, moduleDirectories, defaultInline)) return false;
+	if (matchExternalizePattern(id, moduleDirectories, depsExternal)) return id;
+	if (isLibraryModule && await isValidNodeImport(id)) return id;
+	return false;
+}
+function matchExternalizePattern(id, moduleDirectories, patterns) {
+	if (patterns == null) return false;
+	if (patterns === true) return true;
+	for (const ex of patterns) if (typeof ex === "string") {
+		if (moduleDirectories.some((dir) => id.includes(join(dir, ex)))) return true;
+	} else if (ex.test(id)) return true;
+	return false;
+}
+function patchWindowsImportPath(path$1) {
+	if (path$1.match(/^\w:\\/)) return `file:///${slash(path$1)}`;
+	else if (path$1.match(/^\w:\//)) return `file:///${path$1}`;
+	else return path$1;
+}
+const debugRequest = createDebug("vite-node:server:request");
+var ViteNodeServer = class {
+	fetchPromiseMap = {
+		ssr: /* @__PURE__ */ new Map(),
+		web: /* @__PURE__ */ new Map()
+	};
+	transformPromiseMap = {
+		ssr: /* @__PURE__ */ new Map(),
+		web: /* @__PURE__ */ new Map()
+	};
+	durations = {
+		ssr: /* @__PURE__ */ new Map(),
+		web: /* @__PURE__ */ new Map()
+	};
+	existingOptimizedDeps = /* @__PURE__ */ new Set();
+	fetchCaches = {
+		ssr: /* @__PURE__ */ new Map(),
+		web: /* @__PURE__ */ new Map()
+	};
+	fetchCache = /* @__PURE__ */ new Map();
+	externalizeCache = /* @__PURE__ */ new Map();
+	debugger;
+	constructor(server, options = {}) {
+		this.server = server;
+		this.options = options;
+		const ssrOptions = server.config.ssr;
+		options.deps ??= {};
+		options.deps.cacheDir = relative(server.config.root, options.deps.cacheDir || server.config.cacheDir);
+		if (ssrOptions) {
+			if (ssrOptions.noExternal === true) options.deps.inline ??= true;
+			else if (options.deps.inline !== true) {
+				options.deps.inline ??= [];
+				const inline = options.deps.inline;
+				options.deps.inline.push(...toArray(ssrOptions.noExternal).filter((dep) => !inline.includes(dep)));
+			}
+		}
+		if (process$1.env.VITE_NODE_DEBUG_DUMP) options.debug = Object.assign({
+			dumpModules: !!process$1.env.VITE_NODE_DEBUG_DUMP,
+			loadDumppedModules: process$1.env.VITE_NODE_DEBUG_DUMP === "load"
+		}, options.debug ?? {});
+		if (options.debug) this.debugger = new Debugger(server.config.root, options.debug);
+		if (options.deps.inlineFiles) options.deps.inlineFiles = options.deps.inlineFiles.flatMap((file) => {
+			if (file.startsWith("file://")) return file;
+			const resolvedId = resolve$1(file);
+			return [resolvedId, pathToFileURL(resolvedId).href];
+		});
+		options.deps.moduleDirectories ??= [];
+		const customModuleDirectories = (process$1.env.VITE_NODE_DEPS_MODULE_DIRECTORIES || process$1.env.npm_config_VITE_NODE_DEPS_MODULE_DIRECTORIES)?.split(",");
+		if (customModuleDirectories) options.deps.moduleDirectories.push(...customModuleDirectories);
+		options.deps.moduleDirectories = options.deps.moduleDirectories.map((dir) => {
+			if (!dir.startsWith("/")) dir = `/${dir}`;
+			if (!dir.endsWith("/")) dir += "/";
+			return normalize(dir);
+		});
+		if (!options.deps.moduleDirectories.includes("/node_modules/")) options.deps.moduleDirectories.push("/node_modules/");
+	}
+	shouldExternalize(id) {
+		return shouldExternalize(id, this.options.deps, this.externalizeCache);
+	}
+	getTotalDuration() {
+		const ssrDurations = [...this.durations.ssr.values()].flat();
+		const webDurations = [...this.durations.web.values()].flat();
+		return [...ssrDurations, ...webDurations].reduce((a, b) => a + b, 0);
+	}
+	async ensureExists(id) {
+		if (this.existingOptimizedDeps.has(id)) return true;
+		if (existsSync(id)) {
+			this.existingOptimizedDeps.add(id);
+			return true;
+		}
+		return new Promise((resolve$1$1) => {
+			setTimeout(() => {
+				this.ensureExists(id).then(() => {
+					resolve$1$1(true);
+				});
+			});
+		});
+	}
+	async resolveId(id, importer, transformMode) {
+		if (importer && !importer.startsWith(withTrailingSlash(this.server.config.root))) importer = resolve$1(this.server.config.root, importer);
+		const mode = transformMode ?? (importer && this.getTransformMode(importer) || "ssr");
+		return this.server.pluginContainer.resolveId(id, importer, { ssr: mode === "ssr" });
+	}
+	getSourceMap(source) {
+		source = normalizeModuleId(source);
+		const fetchResult = this.fetchCache.get(source)?.result;
+		if (fetchResult?.map) return fetchResult.map;
+		return (this.server.moduleGraph.getModuleById(source)?.ssrTransformResult)?.map || null;
+	}
+	assertMode(mode) {
+		assert(mode === "web" || mode === "ssr", `"transformMode" can only be "web" or "ssr", received "${mode}".`);
+	}
+	async fetchModule(id, transformMode) {
+		const mode = transformMode || this.getTransformMode(id);
+		return this.fetchResult(id, mode).then((r) => {
+			return this.options.sourcemap !== true ? {
+				...r,
+				map: void 0
+			} : r;
+		});
+	}
+	async fetchResult(id, mode) {
+		const moduleId = normalizeModuleId(id);
+		this.assertMode(mode);
+		const promiseMap = this.fetchPromiseMap[mode];
+		if (!promiseMap.has(moduleId)) promiseMap.set(moduleId, this._fetchModule(moduleId, mode).finally(() => {
+			promiseMap.delete(moduleId);
+		}));
+		return promiseMap.get(moduleId);
+	}
+	async transformRequest(id, filepath = id, transformMode) {
+		const mode = transformMode || this.getTransformMode(id);
+		this.assertMode(mode);
+		const promiseMap = this.transformPromiseMap[mode];
+		if (!promiseMap.has(id)) promiseMap.set(id, this._transformRequest(id, filepath, mode).finally(() => {
+			promiseMap.delete(id);
+		}));
+		return promiseMap.get(id);
+	}
+	async transformModule(id, transformMode) {
+		if (transformMode !== "web") throw new Error("`transformModule` only supports `transformMode: \"web\"`.");
+		const normalizedId = normalizeModuleId(id);
+		return { code: (this.server.moduleGraph.getModuleById(normalizedId)?.transformResult || await this.server.transformRequest(normalizedId))?.code };
+	}
+	getTransformMode(id) {
+		const withoutQuery = id.split("?")[0];
+		if (this.options.transformMode?.web?.some((r) => withoutQuery.match(r))) return "web";
+		if (this.options.transformMode?.ssr?.some((r) => withoutQuery.match(r))) return "ssr";
+		if (withoutQuery.match(/\.([cm]?[jt]sx?|json)$/)) return "ssr";
+		return "web";
+	}
+	getChangedModule(id, file) {
+		const module = this.server.moduleGraph.getModuleById(id) || this.server.moduleGraph.getModuleById(file);
+		if (module) return module;
+		const _modules = this.server.moduleGraph.getModulesByFile(file);
+		if (!_modules || !_modules.size) return null;
+		let mod = [..._modules][0];
+		let latestMax = -1;
+		for (const m of _modules) {
+			const timestamp = Math.max(m.lastHMRTimestamp, m.lastInvalidationTimestamp);
+			if (timestamp > latestMax) {
+				latestMax = timestamp;
+				mod = m;
+			}
+		}
+		return mod;
+	}
+	async _fetchModule(id, transformMode) {
+		let result;
+		const cacheDir = this.options.deps?.cacheDir;
+		if (cacheDir && id.includes(cacheDir)) {
+			if (!id.startsWith(withTrailingSlash(this.server.config.root))) id = join(this.server.config.root, id);
+			const timeout = setTimeout(() => {
+				throw new Error(`ViteNodeServer: ${id} not found. This is a bug, please report it.`);
+			}, 5e3);
+			await this.ensureExists(id);
+			clearTimeout(timeout);
+		}
+		const { path: filePath } = toFilePath(id, this.server.config.root);
+		const moduleNode = this.getChangedModule(id, filePath);
+		const cache = this.fetchCaches[transformMode].get(filePath);
+		const timestamp = moduleNode ? Math.max(moduleNode.lastHMRTimestamp, moduleNode.lastInvalidationTimestamp) : 0;
+		if (cache && (timestamp === 0 || cache.timestamp >= timestamp)) return cache.result;
+		const time$1 = Date.now();
+		const externalize = await this.shouldExternalize(filePath);
+		let duration;
+		if (externalize) {
+			result = { externalize };
+			this.debugger?.recordExternalize(id, externalize);
+		} else {
+			const start = performance$1.now();
+			const r = await this._transformRequest(id, filePath, transformMode);
+			duration = performance$1.now() - start;
+			result = {
+				code: r?.code,
+				map: r?.map
+			};
+		}
+		const cacheEntry = {
+			duration,
+			timestamp: time$1,
+			result
+		};
+		const durations = this.durations[transformMode].get(filePath) || [];
+		this.durations[transformMode].set(filePath, [...durations, duration ?? 0]);
+		this.fetchCaches[transformMode].set(filePath, cacheEntry);
+		this.fetchCache.set(filePath, cacheEntry);
+		return result;
+	}
+	async processTransformResult(filepath, result) {
+		return withInlineSourcemap(result, {
+			filepath: this.server.moduleGraph.getModuleById(filepath)?.file || filepath,
+			root: this.server.config.root,
+			noFirstLineMapping: Number(version.split(".")[0]) >= 6
+		});
+	}
+	async _transformRequest(id, filepath, transformMode) {
+		debugRequest(id);
+		let result = null;
+		if (this.options.debug?.loadDumppedModules) {
+			result = await this.debugger?.loadDump(id) ?? null;
+			if (result) return result;
+		}
+		if (transformMode === "web") {
+			result = await this.server.transformRequest(id);
+			if (result) result = await this.server.ssrTransform(result.code, result.map, id);
+		} else result = await this.server.transformRequest(id, { ssr: true });
+		if ((this.options.sourcemap ?? "inline") === "inline" && result) result = await this.processTransformResult(filepath, result);
+		if (this.options.debug?.dumpModules) await this.debugger?.dumpFile(id, result);
+		return result;
+	}
+};
+
+//#endregion
 //#region src/shared.ts
 const cwd = new URL(`${pathToFileURL(process.cwd())}/`);
-const DEFAULT_CONFIG_PATH = new URL("./terrazzo.config.mjs", cwd);
+const DEFAULT_CONFIG_PATH = new URL("./terrazzo.config.ts", cwd);
 const DEFAULT_TOKENS_PATH = new URL("./tokens.json", cwd);
 const GREEN_CHECK = pc.green("✔");
 /** Load config */
 async function loadConfig({ cmd, flags, logger }) {
+	/**
+	* Vite server for loading .ts config files
+	* TODO: remove me when Node 24 is the oldest-supported Node version
+	*/
+	let viteServer;
 	try {
 		let config = {
 			tokens: [DEFAULT_TOKENS_PATH],
@@ -50,11 +1759,26 @@ async function loadConfig({ cmd, flags, logger }) {
 				process.exit(1);
 			}
 			configPath = resolveConfig(flags.config);
+			if (!configPath) logger.error({
+				group: "config",
+				message: `Could not locate ${flags.config}`
+			});
 		}
 		const resolvedConfigPath = resolveConfig(configPath);
 		if (resolvedConfigPath) try {
-			const mod = await import(resolvedConfigPath);
-			if (!mod.default) throw new Error(`No default export found in ${path.relative(cwd.href, resolvedConfigPath)}. See https://terrazzo.dev/docs/cli for instructions.`);
+			viteServer = await createServer({ mode: "development" });
+			const viteNodeServer = new ViteNodeServer(viteServer);
+			const mod = await new ViteNodeRunner({
+				root: viteServer.config.root,
+				base: viteServer.config.base,
+				fetchModule(...args) {
+					return viteNodeServer.fetchModule(...args);
+				},
+				resolveId(...args) {
+					return viteNodeServer.resolveId(...args);
+				}
+			}).executeFile(resolvedConfigPath);
+			if (!mod.default) throw new Error(`No default export found in ${resolvedConfigPath}. See https://terrazzo.dev/docs for instructions.`);
 			config = defineConfig$1(mod.default, {
 				cwd,
 				logger
@@ -69,12 +1793,14 @@ async function loadConfig({ cmd, flags, logger }) {
 			group: "config",
 			message: "No config file found. Create one with `npx terrazzo init`."
 		});
+		if (viteServer) await viteServer?.close();
 		return {
 			config,
 			configPath: resolvedConfigPath
 		};
 	} catch (err) {
 		printError(err.message);
+		if (viteServer) await viteServer.close();
 		process.exit(1);
 	}
 }
@@ -185,16 +1911,18 @@ function printSuccess(message, startTime) {
 }
 /** Resolve config */
 function resolveConfig(filename) {
-	if (filename) {
-		const configPath = new URL(filename, cwd);
-		if (fs.existsSync(configPath)) return configPath.href;
-		return;
-	}
-	return [
+	if (filename && fs.existsSync(new URL(filename, cwd))) return filename;
+	for (const ext of [
+		".ts",
 		".js",
+		".mts",
+		".cts",
 		".mjs",
 		".cjs"
-	].map((ext) => new URL(`./terrazzo.config${ext}`, cwd)).find((configPath) => fs.existsSync(configPath))?.href;
+	]) {
+		const maybeFilename = `terrazzo.config${ext}`;
+		if (fs.existsSync(maybeFilename)) return maybeFilename;
+	}
 }
 /** Resolve tokens.json path (for lint command) */
 function resolveTokenPath(filename, { logger }) {
@@ -223,7 +1951,7 @@ async function buildCmd({ config, configPath, flags, logger }) {
 		const startTime = performance.now();
 		if (!Array.isArray(config.plugins) || !config.plugins.length) logger.error({
 			group: "config",
-			message: `No plugins defined! Add some in ${configPath || "terrazzo.config.js"}`
+			message: `No plugins defined! Add some in ${configPath || "terrazzo.config.ts"}`
 		});
 		let rawSchemas = await loadTokens(config.tokens, { logger });
 		if (!rawSchemas) {
@@ -319,8 +2047,7 @@ function writeFiles(result, { config, logger }) {
 async function checkCmd({ config, logger, positionals }) {
 	try {
 		const startTime = performance.now();
-		const tokenPaths = positionals.slice(1).length ? positionals.slice(1).map((tokenPath) => resolveTokenPath(tokenPath, { logger })) : config.tokens;
-		const sources = await loadTokens(tokenPaths, { logger });
+		const sources = await loadTokens(positionals.slice(1).length ? positionals.slice(1).map((tokenPath) => resolveTokenPath(tokenPath, { logger })) : config.tokens, { logger });
 		if (!sources?.length) {
 			logger.error({
 				group: "config",
@@ -357,7 +2084,7 @@ function helpCmd() {
 
   [options]
     --help          Show this message
-    --config, -c    Path to config (default: ./terrazzo.config.js)
+    --config, -c    Path to config (default: ./terrazzo.config.ts)
     --quiet         Suppress warnings
 `);
 }
@@ -484,14 +2211,14 @@ async function initCmd({ logger }) {
 			const pluginCount = `${newPlugins.length} ${pluralize(newPlugins.length, "plugin", "plugins")}`;
 			const s = spinner();
 			s.start(`Installing ${pluginCount}`);
-			await new Promise((resolve, reject) => {
+			await new Promise((resolve$2, reject) => {
 				const subprocess = exec([
 					packageManager,
 					INSTALL_COMMAND[packageManager],
 					newPlugins.join(" ")
 				].join(" "), { cwd });
 				subprocess.on("error", reject);
-				subprocess.on("exit", resolve);
+				subprocess.on("exit", resolve$2);
 			});
 			s.message("Updating config");
 			if (configPath) {
@@ -568,8 +2295,10 @@ export default defineConfig({
   ],
   outDir: './dist/',
   lint: {
-    /** @see https://terrazzo.app/docs/cli/lint */
-    enabled: true,
+    /** @see https://terrazzo.app/docs/linting */
+    build: {
+      enabled: true,
+    },
     rules: {
       'core/valid-color': 'error',
       'core/valid-dimension': 'error',
@@ -588,7 +2317,6 @@ export default defineConfig({
       'core/valid-gradient': 'error',
       'core/valid-typography': 'error',
       'core/consistent-naming': 'warn',
-      'no-type-on-alias': 'warn',
     },
   },
 });`);
@@ -644,8 +2372,8 @@ async function labCmd({ config, logger }) {
 	/**
 	* The cli entrypoint is going to manually exit the process after labCmd returns.
 	*/
-	await new Promise((resolve, reject) => {
-		server.on("close", resolve);
+	await new Promise((resolve$2, reject) => {
+		server.on("close", resolve$2);
 		server.on("error", reject);
 	});
 }
@@ -685,7 +2413,7 @@ async function normalizeCmd(filename, { logger, output }) {
 			} } }, { cwd }),
 			logger
 		});
-		await traverseAsync(document, { async enter(node, _parent, nodePath) {
+		traverse(document, { enter(node, _parent, nodePath) {
 			const token = tokens[nodePath.join(".")];
 			if (!token || token.aliasOf || node.type !== "Member" || node.value.type !== "Object") return;
 			const $valueI = node.value.members.findIndex(findMember("$value"));
@@ -767,8 +2495,8 @@ function normalizeTypography(node) {
 //#endregion
 //#region src/version.ts
 function versionCmd() {
-	const { version } = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-	console.log(version);
+	const { version: version$1 } = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+	console.log(version$1);
 }
 
 //#endregion