@zntc/web 0.1.0

package/dist/index.js

@@ -0,0 +1,1124 @@
+import { Buffer as Buffer$1 } from "node:buffer";
+import { createHash } from "node:crypto";
+var createHash$1 = createHash;
+import { watch as fsWatch, readdirSync, existsSync, mkdirSync, readFileSync, writeFileSync, cpSync, mkdtempSync, rmSync, symlinkSync } from "node:fs";
+var readFileSync$1 = readFileSync;
+var writeFileSync$1 = writeFileSync;
+var readFileSync$2 = readFileSync;
+var writeFileSync$2 = writeFileSync;
+var readFileSync$3 = readFileSync;
+var writeFileSync$3 = writeFileSync;
+var readFileSync$4 = readFileSync;
+var writeFileSync$4 = writeFileSync;
+var existsSync$1 = existsSync;
+var mkdirSync$1 = mkdirSync;
+var writeFileSync$5 = writeFileSync;
+import { resolve as resolvePath, join, basename, dirname, relative, sep, extname } from "node:path";
+var resolve = resolvePath;
+var join$1 = join;
+var resolve$1 = resolvePath;
+var basename$1 = basename;
+var join$2 = join;
+var join$3 = join;
+var basename$2 = basename;
+var dirname$1 = dirname;
+var basename$3 = basename;
+var relative$1 = relative;
+var sep$1 = sep;
+var dirname$2 = dirname;
+var join$4 = join;
+var relative$2 = relative;
+var resolve$2 = resolvePath;
+var sep$2 = sep;
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { loadEnv, prepareAppDevSync } from "@zntc/core";
+//#region protocol.ts
+const HMR_MSG = Object.freeze({ Connected: "connected", CssUpdate: "css-update", ClearError: "clear-error", Error: "error", FullReload: "full-reload" }),APP_DEV_HMR_CLIENT_PATH = "/__zntc_app_dev_hmr__",APP_DEV_HMR_WS_PATH = "/__hmr",HMR_WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+function normalizeHmrErrors(errors) {
+	if (!Array.isArray(errors) || errors.length === 0) {
+		return [{ file: "", message: "Unknown build error" }];
+	}
+	return errors.map((error) => {
+		const e = (error ?? {}),file = typeof e.location?.file == "string" ? e.location.file : "",message = String(e.text ?? e.message ?? error);
+		return { file, message };
+	});
+}
+const HMR_RN_MSG = Object.freeze({ UpdateStart: "hmr:update-start", Update: "hmr:update", UpdateDone: "hmr:update-done", Reload: "hmr:reload", Error: "hmr:error", Log: "log" });
+//#endregion
+//#region ws-frame.ts
+const TEXT_FRAME_FIN_OPCODE = 0x81,PAYLOAD_LEN_SHORT_MAX = 125,PAYLOAD_LEN_EXTENDED_16 = 126,PAYLOAD_LEN_EXTENDED_64 = 127,PAYLOAD_LEN_16BIT_MAX = 65535;
+function buildTextFrame(text) {
+	const payload = Buffer$1.from(text);
+	return Buffer$1.concat([buildTextHeader(payload.length), payload]);
+}
+function buildTextHeader(payloadLength) {
+	if (payloadLength <= PAYLOAD_LEN_SHORT_MAX) {
+		return Buffer$1.from([TEXT_FRAME_FIN_OPCODE, payloadLength]);
+	}
+	if (payloadLength <= PAYLOAD_LEN_16BIT_MAX) {
+		const header = Buffer$1.allocUnsafe(4);
+		header[0] = TEXT_FRAME_FIN_OPCODE;
+		header[1] = PAYLOAD_LEN_EXTENDED_16;
+		header.writeUInt16BE(payloadLength, 2);
+		return header;
+	}
+	const header = Buffer$1.allocUnsafe(10);
+	header[0] = TEXT_FRAME_FIN_OPCODE;
+	header[1] = PAYLOAD_LEN_EXTENDED_64;
+	header.writeBigUInt64BE(BigInt(payloadLength), 2);
+	return header;
+}
+function writeTextFrame(socket,text) {
+	if (socket.destroyed)return;
+	socket.write(buildTextFrame(text));
+}
+function computeAcceptKey(secWebSocketKey) {
+	return createHash("sha1").update(`${secWebSocketKey}${HMR_WS_GUID}`).digest("base64");
+}
+function buildHandshakeResponse(secWebSocketKey) {
+	return ["HTTP/1.1 101 Switching Protocols", "Upgrade: websocket", "Connection: Upgrade", `Sec-WebSocket-Accept: ${computeAcceptKey(secWebSocketKey)}`, "", ""].join("\r\n");
+}
+function parseTextFrame(buffer) {
+	if (buffer.length < 2)return null;
+	const byte0 = buffer[0],byte1 = buffer[1];
+	;
+	;
+	;
+	if (!((byte0 & 0x80) !== 0) || (byte0 & 0x0f) !== 0x1 || !((byte1 & 0x80) !== 0))return null;
+	let payloadLen = byte1 & 0x7f,offset = 2;
+	if (payloadLen === PAYLOAD_LEN_EXTENDED_16) {
+		if (buffer.length < 4)return null;
+		payloadLen = buffer.readUInt16BE(2);
+		offset = 4;
+	} else if (payloadLen === PAYLOAD_LEN_EXTENDED_64) {
+		if (buffer.length < 10)return null;
+		const big = buffer.readBigUInt64BE(2);
+		if (big > BigInt(Number.MAX_SAFE_INTEGER))return null;
+		payloadLen = Number(big);
+		offset = 10;
+	}
+	if (buffer.length < offset + 4 + payloadLen)return null;
+	const maskKey = buffer.subarray(offset, offset + 4),payload = Buffer$1.allocUnsafe(payloadLen);
+	for (let i = 0; i < payloadLen; i++) {
+		payload[i] = buffer[offset + 4 + i] ^ maskKey[i % 4];
+	}
+	return { text: payload.toString("utf-8"), consumed: offset + 4 + payloadLen };
+}
+//#endregion
+//#region watcher.ts
+const DEFAULT_DEBOUNCE_MS = 30;
+function createWatcher(options) {
+	const debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS,recursive = options.recursive ?? true,watch = options.watch ?? fsWatch,watchers = [],dirty = new Set();
+	let timer = null,closed = false;
+	function flush() {
+		timer = null;
+		if (closed || dirty.size === 0)return;
+		const snapshot = new Set(dirty);
+		dirty.clear();
+		options.onDirty(snapshot);
+	}
+	function scheduleFlush() {
+		if (timer || closed)return;
+		timer = setTimeout(flush, debounceMs);
+	}
+	function safeClose(watcher) {
+		try {
+			watcher.close();
+		} catch {
+		}
+	}
+	for (const path of options.paths) {
+		const abs = resolvePath(path);
+		try {
+			const watcher = watch(abs, { recursive }, (_eventType, filename) => {
+				if (closed)return;
+				if (typeof filename == "string" && filename.length > 0) {
+					dirty.add(resolvePath(abs, filename));
+				} else {
+					dirty.add(abs);
+				}
+				scheduleFlush();
+			});
+			watcher.on("error", (err) => {
+				if (closed)return;
+				options.onError?.(err, abs);
+				safeClose(watcher);
+			});
+			watchers.push(watcher);
+		} catch (err) {
+			options.onError?.(err, abs);
+		}
+	}
+	return { close() {
+		if (closed)return;
+		closed = true;
+		if (timer) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		for (const watcher of watchers)safeClose(watcher);
+	}, get dirtyPaths() {
+		return dirty;
+	} };
+}
+//#endregion
+//#region hmr-channel.ts
+function extractErrorText(error) {
+	const e = (error ?? {});
+	return ((typeof e.stack == "string" && e.stack) || (typeof e.message == "string" && e.message) || String(error));
+}
+function createHmrChannel() {
+	const nodeSockets = new Set(),bunClients = new Set(),incomingHandlers = [],connectedText = JSON.stringify({ type: HMR_MSG.Connected });
+	let currentError = null,currentErrorText = null;
+	function broadcastText(text) {
+		for (const socket of nodeSockets)writeTextFrame(socket, text);
+		for (const ws of bunClients)ws.send(text);
+	}
+	function greetNode(socket) {
+		writeTextFrame(socket, connectedText);
+		if (currentErrorText)writeTextFrame(socket, currentErrorText);
+	}
+	function greetBun(ws) {
+		ws.send(connectedText);
+		if (currentErrorText)ws.send(currentErrorText);
+	}
+	return { accept(req,socket) {
+		const key = req.headers["sec-websocket-key"];
+		if (typeof key != "string") {
+			socket.destroy();
+			return;
+		}
+		socket.write(buildHandshakeResponse(key));
+		nodeSockets.add(socket);
+		let recvBuffer = Buffer.alloc(0);
+		socket.on("data", (chunk) => {
+			if (incomingHandlers.length === 0)return;
+			recvBuffer = (recvBuffer.length === 0 ? chunk : Buffer.concat([recvBuffer, chunk]));
+			while (recvBuffer.length > 0) {
+				const parsed = parseTextFrame(recvBuffer);
+				if (!parsed)break;
+				recvBuffer = recvBuffer.subarray(parsed.consumed);
+				for (const handler of incomingHandlers) {
+					try {
+						handler(parsed.text, socket);
+					} catch {
+					}
+				}
+			}
+		});
+		socket.on("close", () => nodeSockets.delete(socket));
+		socket.on("error", () => nodeSockets.delete(socket));
+		greetNode(socket);
+	}, addBunClient(ws) {
+		bunClients.add(ws);
+		greetBun(ws);
+	}, removeBunClient(ws) {
+		bunClients.delete(ws);
+	}, onIncoming(handler) {
+		incomingHandlers.push(handler);
+	}, broadcast(message) {
+		broadcastText(JSON.stringify(message));
+	}, reportError(errors) {
+		currentError = { type: HMR_MSG.Error, errors: normalizeHmrErrors(errors), timestamp: Date.now() };
+		currentErrorText = JSON.stringify(currentError);
+		broadcastText(currentErrorText);
+	}, reportThrownError(error) {
+		this.reportError([{ text: extractErrorText(error) }]);
+	}, clearError() {
+		currentError = null;
+		currentErrorText = null;
+	}, get clientCount() {
+		return nodeSockets.size + bunClients.size;
+	} };
+}
+//#endregion
+//#region url.ts
+function joinUrl(base,rel) {
+	if (!base)return rel;
+	return `${base}${rel}`;
+}
+//#endregion
+//#region loader.ts
+function requireFromAppRoot(root,fallbackRequire,specifier) {
+	const requireFromRoot = createRequire(join(root, "package.json"));
+	return requireFromAppOrFallback(requireFromRoot, fallbackRequire, specifier);
+}
+function requireFromAppOrFallback(requireFromApp,fallbackRequire,specifier) {
+	try {
+		return requireFromApp(specifier);
+	} catch (err) {
+		const code = err?.code;
+		if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND")throw err;
+		return fallbackRequire(specifier);
+	}
+}
+const RETURN_TRUE = () => true;
+function readEntriesOrEmpty(dir) {
+	try {
+		return readdirSync(dir, { withFileTypes: true });
+	} catch (err) {
+		if (err.code === "ENOENT")return [];
+		throw err;
+	}
+}
+function walkFiles(dir,skipResolved,predicate,out) {
+	for (const entry of readEntriesOrEmpty(dir)) {
+		if (entry.name === "node_modules" || entry.name === ".git")continue;
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (skipResolved && resolve(path) === skipResolved)continue;
+			walkFiles(path, skipResolved, predicate, out);
+		} else if (entry.isFile() && predicate(path)) {
+			out.push(path);
+		}
+	}
+}
+function collectAppFiles(dir,options={}) {
+	const skipResolved = options.skipDir ? resolve(options.skipDir) : null,predicate = options.predicate ?? RETURN_TRUE,files = [];
+	walkFiles(dir, skipResolved, predicate, files);
+	return files;
+}
+//#endregion
+//#region postcss.ts
+const POSTCSS_CONFIG_NAMES = ["postcss.config.mjs", "postcss.config.js", "postcss.config.cjs", "postcss.config.json", ".postcssrc", ".postcssrc.json", ".postcssrc.js", ".postcssrc.cjs", ".postcssrc.mjs"],isCssFile = (path) => path.endsWith(".css");
+function isPostcssConfigFile(path) {
+	return POSTCSS_CONFIG_NAMES.includes(basename(path));
+}
+function findPostcssConfig(root) {
+	for (const name of POSTCSS_CONFIG_NAMES) {
+		const path = join$1(root, name);
+		if (existsSync(path))return path;
+	}
+	return null;
+}
+function collectPostcssMessages(messages,deps,dirDeps) {
+	if (!messages)return;
+	for (const message of messages) {
+		if (message.type === "dependency" && typeof message.file == "string") {
+			deps.add(resolve$1(message.file));
+		}
+		if (message.type === "dir-dependency") {
+			const dir = (typeof message.dir == "string" && message.dir) || (typeof message.directory == "string" && message.directory);
+			if (dir)dirDeps.add(resolve$1(dir));
+		}
+		if (message.type === "context-dependency" && typeof message.file == "string") {
+			deps.add(resolve$1(message.file));
+		}
+	}
+}
+function logPostcssProcessed(logLevel,count,configFile) {
+	if (logLevel === "silent")return;
+	console.error(`[postcss] processed ${count} CSS file(s) using ${basename(configFile ?? "postcss config")}`);
+}
+async function loadPostcssConfig(root,configEnv,fallbackRequire) {
+	const postcssrc = requireFromAppRoot(root, fallbackRequire, "postcss-load-config"),postcssModule = requireFromAppRoot(root, fallbackRequire, "postcss"),postcss = (postcssModule.default ?? postcssModule),config = await postcssrc({ cwd: root, env: configEnv.mode }, root).catch((err) => {
+		if (err?.message?.includes("No PostCSS Config found"))return null;
+		throw err;
+	});
+	if (!config)return null;
+	const plugins = config.plugins ?? [];
+	if (plugins.length === 0)return null;
+	return { postcss, plugins, options: config.options ?? {}, configFile: config.file ?? null };
+}
+async function runPostcssIfConfigured(root,cssDir,skipDir,configEnv,logLevel,fallbackRequire) {
+	const loaded = await loadPostcssConfig(root, configEnv, fallbackRequire);
+	if (!loaded)return;
+	const cssFiles = collectAppFiles(cssDir, { skipDir, predicate: isCssFile });
+	await Promise.all(cssFiles.map(async (file) => {
+		const input = readFileSync(file, "utf8"),result = await loaded.postcss(loaded.plugins).process(input, { ...loaded.options, from: file, to: file });
+		writeFileSync(file, result.css);
+		if (result.map)writeFileSync(`${file}.map`, result.map.toString());
+	}));
+	logPostcssProcessed(logLevel, cssFiles.length, loaded.configFile);
+}
+async function runPostcssForAppDev(options) {
+	const { root:root, outdir:outdir, configEnv:configEnv, logLevel:logLevel, base:base, changedPath:changedPath=null, fallbackRequire:fallbackRequire } = options,deps = new Set(),dirDeps = new Set();
+	let primaryHref = null;
+	const configPath = findPostcssConfig(root);
+	if (!configPath) {
+		const first = collectAppFiles(root, { skipDir: outdir, predicate: isCssFile })[0];
+		if (first)primaryHref = joinUrl(base, relative(root, first));
+		return { deps, dirDeps, primaryHref, processed: 0 };
+	}
+	const loaded = await loadPostcssConfig(root, configEnv, fallbackRequire);
+	if (!loaded)return { deps, dirDeps, primaryHref, processed: 0 };
+	deps.add(resolve$1(loaded.configFile ?? configPath));
+	mkdirSync(outdir, { recursive: true });
+	const allCssFiles = collectAppFiles(root, { skipDir: outdir, predicate: isCssFile }),targets = changedPath && changedPath.endsWith(".css") && allCssFiles.includes(changedPath) ? [changedPath] : allCssFiles;
+	await Promise.all(targets.map(async (file) => {
+		const outputRel = relative(root, file),outputPath = join$1(outdir, outputRel);
+		mkdirSync(dirname(outputPath), { recursive: true });
+		const input = readFileSync(file, "utf8"),result = await loaded.postcss(loaded.plugins).process(input, { ...loaded.options, from: file, to: outputPath });
+		writeFileSync(outputPath, result.css);
+		if (result.map)writeFileSync(`${outputPath}.map`, result.map.toString());
+		deps.add(resolve$1(file));
+		collectPostcssMessages(result.messages, deps, dirDeps);
+	}));
+	if (allCssFiles.length > 0)primaryHref = joinUrl(base, relative(root, allCssFiles[0]));
+	logPostcssProcessed(logLevel, targets.length, loaded.configFile);
+	return { deps, dirDeps, primaryHref, processed: targets.length };
+}
+//#endregion
+//#region inject.ts
+function injectIntoDevHtml(outdir,build) {
+	const htmlPath = join$2(outdir, "index.html");
+	let html;
+	try {
+		html = readFileSync$1(htmlPath, "utf8");
+	} catch (err) {
+		if (err?.code === "ENOENT")return;
+		throw err;
+	}
+	const tag = build(html);
+	if (!tag)return;
+	const next = html.includes("</head>") ? html.replace("</head>", `${tag}\n</head>`) : html.replace("<script", `${tag}\n<script`);
+	writeFileSync$1(htmlPath, next);
+}
+function injectAppDevHmrClient(outdir) {
+	injectIntoDevHtml(outdir, (html) => {
+		if (html.includes(APP_DEV_HMR_CLIENT_PATH))return null;
+		return `<script type="module" src="${APP_DEV_HMR_CLIENT_PATH}"></script>`;
+	});
+}
+function injectAppDevBundleCssLinks(outdir,base,bundleResult) {
+	injectIntoDevHtml(outdir, (html) => {
+		const cssHrefs = [];
+		for (const file of bundleResult?.outputFiles ?? []) {
+			if (!file?.path || !isCssFile(file.path))continue;
+			const href = joinUrl(base, basename$1(file.path));
+			if (!html.includes(`href="${href}"`) && !html.includes(`href='${href}'`))cssHrefs.push(href);
+		}
+		if (cssHrefs.length === 0)return null;
+		return cssHrefs.map((href) => `<link rel="stylesheet" href="${href}">`).join("\n");
+	});
+}
+function injectAppDevPipelineCssLinks(outdir,base,cssRelPaths) {
+	if (cssRelPaths.length === 0)return;
+	injectIntoDevHtml(outdir, (html) => {
+		const tags = [];
+		for (const rel of cssRelPaths) {
+			const href = joinUrl(base, rel.replaceAll(sep, "/"));
+			if (html.includes(`href="${href}"`) || html.includes(`href='${href}'`))continue;
+			tags.push(`<link rel="stylesheet" href="${href}">`);
+		}
+		return tags.length === 0 ? null : tags.join("\n");
+	});
+}
+//#endregion
+//#region html-env.ts
+const DEFAULT_HTML_ENV_PREFIX = "ZNTC_";
+const TOKEN_RE = /<%=\s*([A-Za-z_][A-Za-z0-9_]*)\s*%>/g,HTML_ESCAPE = { "&": "&amp;", "<": "&lt;", ">": "&gt;", "\"": "&quot;" };
+function escapeHtml(value) {
+	return value.replace(/[&<>"]/g, (c) => HTML_ESCAPE[c]);
+}
+function transformHtmlEnvTokens(html,env,prefix=DEFAULT_HTML_ENV_PREFIX) {
+	const warnings = [],next = html.replace(TOKEN_RE, (match, key) => {
+		if (!key.startsWith(prefix)) {
+			warnings.push(`token "${match}" uses key "${key}" without allowed prefix "${prefix}" — kept as-is`);
+			return match;
+		}
+		const value = env[key];
+		if (value === undefined) {
+			warnings.push(`"${key}" not found in environment — replaced with empty string`);
+			return "";
+		}
+		return escapeHtml(value);
+	});
+	return { html: next, changed: next !== html, warnings };
+}
+function applyHtmlEnvTokens(outdir,env,prefix=DEFAULT_HTML_ENV_PREFIX) {
+	const htmlPath = join$3(outdir, "index.html");
+	let html;
+	try {
+		html = readFileSync$2(htmlPath, "utf8");
+	} catch (err) {
+		if (err?.code === "ENOENT")return { warnings: [] };
+		throw err;
+	}
+	const result = transformHtmlEnvTokens(html, env, prefix);
+	if (result.changed)writeFileSync$2(htmlPath, result.html);
+	return { warnings: result.warnings };
+}
+//#endregion
+//#region css-parser.ts
+function skipCssString(css,start,quote) {
+	let i = start + 1;
+	while (i < css.length) {
+		if (css[i] === "\\" && i + 1 < css.length) {
+			i += 2;
+			continue;
+		}
+		if (css[i] === quote)return i + 1;
+		i += 1;
+	}
+	return css.length;
+}
+function skipCssUrl(css,start) {
+	let i = start;
+	while (i < css.length) {
+		if ((css[i] === "\"" || css[i] === "'") && css[i - 1] !== "\\") {
+			i = skipCssString(css, i, css[i]);
+			continue;
+		}
+		if (css[i] === ")")return i + 1;
+		i += 1;
+	}
+	return css.length;
+}
+function startsWithCssIdent(css,offset,value) {
+	return css.slice(offset, offset + value.length).toLowerCase() === value;
+}
+function isCssIdentStart(ch) {
+	return ch === "_" || (ch >= "A" && ch <= "Z") || (ch >= "a" && ch <= "z");
+}
+function isCssIdent(ch) {
+	return isCssIdentStart(ch) || ch === "-" || (ch >= "0" && ch <= "9");
+}
+//#endregion
+//#region sass.ts
+const CSS_PREPROCESSOR_EXTENSIONS = new Set([".scss", ".sass"]);
+const MODULE_PREPROCESSOR_RE = /\.module\.(?:scss|sass)$/;
+function isCssPreprocessorFile(path) {
+	return CSS_PREPROCESSOR_EXTENSIONS.has(extname(path));
+}
+function isCssModulePreprocessorFile(path) {
+	return MODULE_PREPROCESSOR_RE.test(path);
+}
+function cssPreprocessorOutputPath(file) {
+	return file.replace(/\.(?:scss|sass)$/, ".css");
+}
+function cssPreprocessorProxyPath(file) {
+	return `${cssPreprocessorOutputPath(file)}.js`;
+}
+function loadSassCompiler(root,fallbackRequire) {
+	return requireFromAppRoot(root, fallbackRequire, "sass");
+}
+function compileSassFile(sass,file,loadRoot) {
+	return sass.compile(file, { style: "expanded", loadPaths: [dirname$1(file), loadRoot], sourceMap: false });
+}
+const STYLE_REFERENCE_RE = /\.(?:html|mjs|cjs|js|jsx|ts|tsx)$/;
+function isStyleReferenceSource(path) {
+	return STYLE_REFERENCE_RE.test(path);
+}
+function rewriteSassReferences(sourceFiles) {
+	;
+	for (const source of sourceFiles) {
+		const input = readFileSync$3(source, "utf8");
+		if (!input.includes(".scss") && !input.includes(".sass"))continue;
+		const toExt = /\.html?$/i.test(source) ? ".css" : ".css.js",output = input.replace(/(["'])([^"']+\.(?:scss|sass))([?#][^"']*)?\1/g, (_match, quote, spec, suffix = "") => `${quote}${spec.replace(/\.(?:scss|sass)$/, toExt)}${suffix}${quote}`);
+		if (output !== input)writeFileSync$3(source, output);
+	}
+}
+function buildCssPreprocessorProxy(cssPath) {
+	const cssImport = `./${basename$2(cssPath)}`;
+	return `import ${JSON.stringify(cssImport)};\n`;
+}
+function transformCssPreprocessors(root,files,sourceFiles,logLevel,fallbackRequire,options={}) {
+	if (files.length === 0)return [];
+	const { dirtyOnly:dirtyOnly=null, dirtySources:dirtySources=null } = options,targets = dirtyOnly ? files.filter((f) => dirtyOnly.has(f)) : files;
+	if (targets.length === 0)return files.map(cssPreprocessorOutputPath);
+	let sass;
+	try {
+		sass = loadSassCompiler(root, fallbackRequire);
+	} catch (err) {
+		const code = err?.code,message = code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND" ? "Sass/SCSS support requires the optional `sass` package. Install it with `bun add -d sass` or `npm install -D sass`." : `Failed to load sass: ${err?.message ?? err}`;
+		throw new Error(message);
+	}
+	for (const file of targets) {
+		const result = compileSassFile(sass, file, root),cssPath = cssPreprocessorOutputPath(file);
+		writeFileSync$3(cssPath, result.css);
+		writeFileSync$3(cssPreprocessorProxyPath(file), buildCssPreprocessorProxy(cssPath));
+	}
+	rewriteSassReferences(dirtySources ?? sourceFiles);
+	if (logLevel !== "silent") {
+		console.error(`[sass] processed ${targets.length} Sass/SCSS file(s)`);
+	}
+	return files.map(cssPreprocessorOutputPath);
+}
+//#endregion
+//#region css-modules.ts
+function isCssModuleFile(path) {
+	return basename$3(path).endsWith(".module.css");
+}
+function cssModuleGeneratedCssPath(file) {
+	return file.replace(/\.module\.css$/, ".module.zntc.css");
+}
+function cssModuleProxyPath(file) {
+	return `${file}.js`;
+}
+const SAFE_LOCAL_RE = /[^a-zA-Z0-9_]/g;
+function cssModuleLocalName(root,file,local) {
+	const rel = relative$1(root, file).replaceAll(sep$1, "/"),fileName = basename$3(file, ".module.css").replace(SAFE_LOCAL_RE, "_");
+	return cssModuleLocalNameWithCachedFile(rel, fileName, local);
+}
+function cssModuleLocalNameWithCachedFile(rel,fileName,local) {
+	const safeLocal = local.replace(SAFE_LOCAL_RE, "_"),hash = createHash$1("sha1").update(`${rel}:${local}`).digest("base64url").slice(0, 8);
+	return `${fileName}_${safeLocal}__${hash}`;
+}
+function scanCssModuleClassTokens(css) {
+	const tokens = [];
+	let i = 0;
+	while (i < css.length) {
+		const ch = css[i],next = css[i + 1] ?? "";
+		if ((ch === "\"" || ch === "'") && css[i - 1] !== "\\") {
+			i = skipCssString(css, i, ch);
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			const end = css.indexOf("*/", i + 2);
+			i = end === -1 ? css.length : end + 2;
+			continue;
+		}
+		if (startsWithCssIdent(css, i, "url(")) {
+			i = skipCssUrl(css, i + 4);
+			continue;
+		}
+		if (ch === "." && isCssIdentStart(next)) {
+			let end = i + 2;
+			while (end < css.length && isCssIdent(css[end]))end += 1;
+			tokens.push({ start: i, end, local: css.slice(i + 1, end) });
+			i = end;
+			continue;
+		}
+		i += 1;
+	}
+	return tokens;
+}
+function collectCssModuleClasses(css) {
+	return [...new Set(scanCssModuleClassTokens(css).map((token) => token.local))];
+}
+function rewriteCssModuleClasses(css,mapping) {
+	return rewriteCssModuleClassesWithTokens(css, scanCssModuleClassTokens(css), mapping);
+}
+const VALID_EXPORT_NAME_RE = /^[$A-Z_a-z][$\w]*$/,CSS_MODULE_RESERVED_EXPORTS = new Set(["arguments", "await", "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "implements", "import", "in", "instanceof", "interface", "let", "new", "null", "package", "private", "protected", "public", "return", "static", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "yield"]);
+function isValidExportName(name) {
+	return VALID_EXPORT_NAME_RE.test(name) && !CSS_MODULE_RESERVED_EXPORTS.has(name);
+}
+function buildCssModuleProxy(generatedCssPath,mapping) {
+	const cssImport = `./${basename$3(generatedCssPath)}`,stylesJson = JSON.stringify(mapping),named = Object.keys(mapping).filter(isValidExportName).map((name) => `export const ${name} = ${JSON.stringify(mapping[name])};`).join("\n");
+	return [`import ${JSON.stringify(cssImport)};`, `const styles = ${stylesJson};`, "export default styles;", named, ""].filter(Boolean).join("\n");
+}
+function rewriteCssModuleReferences(sourceFiles) {
+	;
+	for (const source of sourceFiles) {
+		if (/\.html?$/i.test(source))continue;
+		const input = readFileSync$4(source, "utf8");
+		if (!input.includes(".module.css"))continue;
+		const output = input.replace(/(["'])([^"']+\.module\.css)([?#][^"']*)?\1/g, (_match, quote, spec, suffix = "") => `${quote}${spec}.js${suffix}${quote}`);
+		if (output !== input)writeFileSync$4(source, output);
+	}
+}
+function transformCssModules(root,moduleFiles,styleSources,logLevel,options={}) {
+	if (moduleFiles.length === 0)return [];
+	const { dirtyOnly:dirtyOnly=null, dirtySources:dirtySources=null } = options,targets = dirtyOnly ? moduleFiles.filter((f) => dirtyOnly.has(f)) : moduleFiles;
+	if (targets.length === 0)return moduleFiles.map(cssModuleGeneratedCssPath);
+	for (const file of targets) {
+		const css = readFileSync$4(file, "utf8"),tokens = scanCssModuleClassTokens(css),rel = relative$1(root, file).replaceAll(sep$1, "/"),fileName = basename$3(file, ".module.css").replace(SAFE_LOCAL_RE, "_"),mapping = {};
+		for (const token of tokens) {
+			if (!mapping[token.local]) {
+				mapping[token.local] = cssModuleLocalNameWithCachedFile(rel, fileName, token.local);
+			}
+		}
+		const rewrittenCss = rewriteCssModuleClassesWithTokens(css, tokens, mapping),generatedCssPath = cssModuleGeneratedCssPath(file);
+		writeFileSync$4(generatedCssPath, rewrittenCss);
+		writeFileSync$4(cssModuleProxyPath(file), buildCssModuleProxy(generatedCssPath, mapping));
+	}
+	rewriteCssModuleReferences(dirtySources ?? styleSources);
+	if (logLevel !== "silent") {
+		console.error(`[css-modules] processed ${targets.length} CSS module file(s)`);
+	}
+	return moduleFiles.map(cssModuleGeneratedCssPath);
+}
+function rewriteCssModuleClassesWithTokens(css,tokens,mapping) {
+	let out = "",offset = 0;
+	for (const token of tokens) {
+		const scoped = mapping[token.local];
+		if (!scoped)continue;
+		out += css.slice(offset, token.start);
+		out += `.${scoped}`;
+		offset = token.end;
+	}
+	out += css.slice(offset);
+	return out;
+}
+//#endregion
+//#region dev-controller.ts
+const postcssTempRoots = new Set();
+let postcssCleanupRegistered = false;
+function normalizeBase(base) {
+	if (!base)return "/";
+	let normalized = base.startsWith("/") ? base : `/${base}`;
+	if (!normalized.endsWith("/"))normalized = `${normalized}/`;
+	return normalized;
+}
+function mirrorFile(srcAbs,dstAbs) {
+	mkdirSync$1(dirname$2(dstAbs), { recursive: true });
+	cpSync(srcAbs, dstAbs);
+}
+function mirrorPipelineCssToOutdir(pipelineRoot,outdir,absPaths) {
+	const rels = [];
+	for (const abs of absPaths) {
+		const rel = relative$2(pipelineRoot, abs);
+		mirrorFile(abs, join$4(outdir, rel));
+		rels.push(rel);
+	}
+	return rels;
+}
+function generatedPeerPaths(srcPath) {
+	if (isCssPreprocessorFile(srcPath)) {
+		return [cssPreprocessorOutputPath(srcPath), cssPreprocessorProxyPath(srcPath)];
+	}
+	if (isCssModuleFile(srcPath)) {
+		return [cssModuleGeneratedCssPath(srcPath), cssModuleProxyPath(srcPath)];
+	}
+	return [];
+}
+function syncDirtyFilesIntoTempRoot(root,tempRoot,dirtyPaths) {
+	for (const abs of dirtyPaths) {
+		const rel = relative$2(root, abs);
+		if (!rel || rel.startsWith(".."))continue;
+		const dst = join$4(tempRoot, rel);
+		if (existsSync$1(abs)) {
+			mirrorFile(abs, dst);
+		} else if (existsSync$1(dst)) {
+			rmSync(dst, { force: true });
+			for (const peer of generatedPeerPaths(dst)) {
+				if (existsSync$1(peer))rmSync(peer, { force: true });
+			}
+		}
+	}
+}
+function registerPostcssTempRoot(tempRoot) {
+	postcssTempRoots.add(tempRoot);
+	if (postcssCleanupRegistered)return;
+	postcssCleanupRegistered = true;
+	const cleanupAll = () => {
+		for (const root of postcssTempRoots)rmSync(root, { recursive: true, force: true });
+		postcssTempRoots.clear();
+	};
+	process.once("exit", cleanupAll);
+	process.once("SIGINT", () => {
+		cleanupAll();
+		process.exit(130);
+	});
+	process.once("SIGTERM", () => {
+		cleanupAll();
+		process.exit(143);
+	});
+}
+function cleanupPostcssTempRoot(tempRoot) {
+	postcssTempRoots.delete(tempRoot);
+	rmSync(tempRoot, { recursive: true, force: true });
+}
+function copyAppRootForPostcss(root,outdir,phase,cliNodeModules) {
+	const tempRoot = mkdtempSync(join$4(tmpdir(), `zntc-postcss-${phase}-`));
+	registerPostcssTempRoot(tempRoot);
+	const skip = new Set([resolve$2(outdir), resolve$2(tempRoot), resolve$2(join$4(root, "node_modules")), resolve$2(join$4(root, ".git")), resolve$2(join$4(root, "dist")), resolve$2(join$4(root, ".zntc-dev"))]);
+	cpSync(root, tempRoot, { recursive: true, dereference: false, filter(source) {
+		const abs = resolve$2(source);
+		if (abs === resolve$2(root))return true;
+		for (const ignored of skip) {
+			if (abs === ignored || abs.startsWith(`${ignored}${sep$2}`))return false;
+		}
+		return true;
+	} });
+	const appNodeModules = join$4(root, "node_modules"),nodeModulesTarget = existsSync$1(appNodeModules) ? appNodeModules : cliNodeModules;
+	if (existsSync$1(nodeModulesTarget)) {
+		symlinkSync(nodeModulesTarget, join$4(tempRoot, "node_modules"), "dir");
+	}
+	return tempRoot;
+}
+async function prepareAppCssPipelineRoot(root,outdir,configEnv,logLevel,phase,deps,options={}) {
+	const { existingTempRoot:existingTempRoot=null, dirtyPaths:dirtyPaths=null, cache:cache=null } = options,{ fallbackRequire:fallbackRequire, cliNodeModules:cliNodeModules } = deps,configPath = findPostcssConfig(root),stylePipelineFiles = cache?.stylePipelineFiles ?? collectAppFiles(root, { skipDir: outdir, predicate: (path) => isCssPreprocessorFile(path) || isCssModuleFile(path) }),preprocessorFiles = stylePipelineFiles.filter(isCssPreprocessorFile),moduleFiles = stylePipelineFiles.filter(isCssModuleFile),needsSource = preprocessorFiles.length > 0 || moduleFiles.length > 0;
+	if (!configPath && !needsSource)return null;
+	const tempRoot = existingTempRoot ?? copyAppRootForPostcss(root, outdir, phase, cliNodeModules),isIncremental = existingTempRoot && dirtyPaths;
+	if (isIncremental && dirtyPaths) {
+		syncDirtyFilesIntoTempRoot(root, tempRoot, dirtyPaths);
+	}
+	const toTemp = (path) => join$4(tempRoot, relative$2(root, path)),styleSourceFiles = !needsSource ? [] : (cache?.styleSourceFiles ?? collectAppFiles(tempRoot, { predicate: isStyleReferenceSource }));
+	let dirtySassSet = null,dirtyModuleSet = null,dirtySourceList = null;
+	if (isIncremental && dirtyPaths) {
+		const dirtyTempPaths = dirtyPaths.map(toTemp);
+		dirtySassSet = new Set(dirtyTempPaths.filter((p) => isCssPreprocessorFile(p)));
+		dirtyModuleSet = new Set(dirtyTempPaths.filter((p) => isCssModuleFile(p)));
+		for (const sassDirty of dirtySassSet) {
+			const cssOut = cssPreprocessorOutputPath(sassDirty);
+			if (isCssModuleFile(cssOut))dirtyModuleSet.add(cssOut);
+		}
+		dirtySourceList = dirtyTempPaths.filter((p) => isStyleReferenceSource(p) && existsSync$1(p));
+	}
+	const sassOutputs = transformCssPreprocessors(tempRoot, preprocessorFiles.map(toTemp), styleSourceFiles, logLevel, fallbackRequire, isIncremental ? { dirtyOnly: dirtySassSet, dirtySources: dirtySourceList } : undefined),postcssRelevant = !isIncremental || (dirtyPaths !== null && dirtyPaths.some((p) => isCssFile(p) || isCssPreprocessorFile(p) || isPostcssConfigFile(p)));
+	if (postcssRelevant) {
+		await runPostcssIfConfigured(tempRoot, tempRoot, null, configEnv, logLevel, fallbackRequire);
+	}
+	const generatedModuleFiles = preprocessorFiles.map(cssPreprocessorOutputPath).filter(isCssModuleFile),moduleOutputs = transformCssModules(tempRoot, [...moduleFiles, ...generatedModuleFiles].map(toTemp), styleSourceFiles, logLevel, isIncremental ? { dirtyOnly: dirtyModuleSet, dirtySources: dirtySourceList } : undefined),moduleInputCssPaths = new Set(generatedModuleFiles.map((p) => join$4(tempRoot, relative$2(root, p)))),generatedCssAbsPaths = [...sassOutputs.filter((p) => !moduleInputCssPaths.has(p)), ...moduleOutputs];
+	return { tempRoot, generatedCssAbsPaths, cache: { stylePipelineFiles, styleSourceFiles } };
+}
+function createAppDevController(opts,root,configEnv,deps) {
+	const { fallbackRequire:fallbackRequire } = deps,outdir = resolve$2(opts.outdir || join$4(root, ".zntc-dev")),base = normalizeBase(opts.base ?? opts.publicPath ?? "/");
+	let cssDeps = new Set(),cssDirDeps = new Set(),primaryHref = null,pipelineRoot = null,pipelineCache = null,hasPipelineCss = false,htmlEnvCache = null;
+	const warnedHtmlEnv = new Set();
+	return { root, outdir, base, async prepare(dirtyPaths=null) {
+		const reuseRoot = pipelineRoot && dirtyPaths != null;
+		if (pipelineRoot && !reuseRoot) {
+			cleanupPostcssTempRoot(pipelineRoot);
+			pipelineRoot = null;
+			pipelineCache = null;
+		}
+		if (reuseRoot && dirtyPaths && dirtyPaths.some((p) => isCssPreprocessorFile(p) || isCssModuleFile(p))) {
+			pipelineCache = null;
+		}
+		const pipeline = await prepareAppCssPipelineRoot(root, outdir, configEnv, opts.logLevel, "dev", deps, reuseRoot ? { existingTempRoot: pipelineRoot, dirtyPaths, cache: pipelineCache } : undefined);
+		pipelineRoot = pipeline?.tempRoot ?? null;
+		pipelineCache = pipeline?.cache ?? null;
+		hasPipelineCss = (pipeline?.generatedCssAbsPaths.length ?? 0) > 0;
+		const prepareRoot = pipelineRoot ?? root,envDir = opts.envDir ? resolve$2(opts.envDir) : prepareRoot,prepared = prepareAppDevSync({ root: prepareRoot, outdir, entryHtml: opts.entryHtml ?? "index.html", publicDir: opts.publicDir === undefined ? "public" : opts.publicDir, base, mode: configEnv.mode, envDir, envPrefixes: opts.envPrefixes ? Array.from(opts.envPrefixes) : undefined }),htmlEnv = htmlEnvCache && htmlEnvCache.mode === configEnv.mode && htmlEnvCache.dir === envDir ? htmlEnvCache.env : (htmlEnvCache = { mode: configEnv.mode, dir: envDir, env: loadEnv(configEnv.mode, envDir, ["ZNTC_"]) }).env,{ warnings:htmlWarnings } = applyHtmlEnvTokens(outdir, htmlEnv);
+		if (opts.logLevel !== "silent") {
+			for (const w of htmlWarnings) {
+				if (warnedHtmlEnv.has(w))continue;
+				warnedHtmlEnv.add(w);
+				console.error(`[html-env] ${w}`);
+			}
+		}
+		injectAppDevHmrClient(outdir);
+		if (pipeline && pipeline.generatedCssAbsPaths.length > 0 && pipelineRoot) {
+			const sassOrModuleDirty = !reuseRoot || (dirtyPaths !== null && dirtyPaths.some((p) => isCssPreprocessorFile(p) || isCssModuleFile(p))),rels = sassOrModuleDirty ? mirrorPipelineCssToOutdir(pipelineRoot, outdir, pipeline.generatedCssAbsPaths) : pipeline.generatedCssAbsPaths.map((p) => relative$2(pipelineRoot ?? root, p));
+			injectAppDevPipelineCssLinks(outdir, base, rels);
+		}
+		return prepared;
+	}, async afterBundle({ changedPath:changedPath=null }={}) {
+		const result = await runPostcssForAppDev({ root, outdir, configEnv, logLevel: opts.logLevel, base, changedPath, fallbackRequire });
+		cssDeps = result.deps;
+		cssDirDeps = result.dirDeps;
+		primaryHref = result.primaryHref;
+		return result;
+	}, injectBundleCssLinks(bundleResult) {
+		if (hasPipelineCss)return;
+		injectAppDevBundleCssLinks(outdir, base, bundleResult);
+	}, isPostcssConfig(absPath) {
+		return isPostcssConfigFile(absPath);
+	}, isCssOnlyChange(absPath) {
+		if (isCssModuleFile(absPath) || isCssModulePreprocessorFile(absPath))return false;
+		if (isCssFile(absPath) || isCssPreprocessorFile(absPath))return true;
+		if (cssDeps.has(absPath))return true;
+		for (const dir of cssDirDeps) {
+			if (absPath === dir || absPath.startsWith(`${dir}${sep$2}`))return true;
+		}
+		return false;
+	}, isSassOnlyChange(absPath) {
+		return isCssPreprocessorFile(absPath) && !isCssModulePreprocessorFile(absPath);
+	}, async rebuildScssIncremental(absPath) {
+		if (!pipelineRoot)return null;
+		if (findPostcssConfig(root))return null;
+		const srcTemp = join$4(pipelineRoot, relative$2(root, absPath));
+		mirrorFile(absPath, srcTemp);
+		const sass = loadSassCompiler(root, fallbackRequire),result = compileSassFile(sass, srcTemp, pipelineRoot),cssTempPath = cssPreprocessorOutputPath(srcTemp);
+		writeFileSync$5(cssTempPath, result.css);
+		const cssRel = relative$2(pipelineRoot, cssTempPath);
+		mirrorFile(cssTempPath, join$4(outdir, cssRel));
+		return joinUrl(base, cssRel.replaceAll(sep$2, "/"));
+	}, hrefFor(absPath) {
+		if (absPath.endsWith(".css"))return joinUrl(base, relative$2(root, absPath));
+		return primaryHref ?? joinUrl(base, "style.css");
+	} };
+}
+//#endregion
+//#region dev-overlay-client.mjs
+const APP_DEV_HMR_CLIENT = `
+const socketProtocol = location.protocol === "https:" ? "wss:" : "ws:";
+let overlay = null;
+let closeOverlayOnEsc = null;
+function hideOverlay() {
+  if (closeOverlayOnEsc) document.removeEventListener("keydown", closeOverlayOnEsc);
+  closeOverlayOnEsc = null;
+  if (overlay && overlay.parentNode) overlay.parentNode.removeChild(overlay);
+  overlay = null;
+}
+function normalizeErrors(errors) {
+  if (!Array.isArray(errors) || errors.length === 0) {
+    return [{ file: "", message: "Unknown build error" }];
+  }
+  return errors.map((error) => {
+    if (typeof error === "string") return { file: "", message: error };
+    return {
+      file: error && typeof error.file === "string" ? error.file : "",
+      message: error && typeof error.message === "string" ? error.message : String(error),
+    };
+  });
+}
+function normalizeRuntimeError(error, file) {
+  if (error && typeof error.stack === "string" && error.stack) {
+    return { file: file || "", message: error.stack };
+  }
+  if (error && typeof error.message === "string" && error.message) {
+    const name = typeof error.name === "string" && error.name ? error.name : "Error";
+    return { file: file || "", message: name + ": " + error.message };
+  }
+  return { file: file || "", message: String(error || "Unknown runtime error") };
+}
+const sourceMapCache = new Map();
+const sourceMapVlqChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function displaySourceName(source) {
+  if (!source) return "";
+  const clean = String(source).split("?")[0].split("#")[0];
+  const slash = Math.max(clean.lastIndexOf("/"), clean.lastIndexOf("\\\\"));
+  return slash >= 0 ? clean.slice(slash + 1) : clean;
+}
+function decodeSourceMapVlq(segment) {
+  const values = [];
+  let result = 0;
+  let shift = 0;
+  for (const ch of segment) {
+    let digit = sourceMapVlqChars.indexOf(ch);
+    if (digit < 0) return values;
+    const continuation = digit & 32;
+    digit &= 31;
+    result += digit << shift;
+    if (continuation) {
+      shift += 5;
+      continue;
+    }
+    const negative = result & 1;
+    const value = result >> 1;
+    values.push(negative ? -value : value);
+    result = 0;
+    shift = 0;
+  }
+  return values;
+}
+function parseSourceMapMappings(map) {
+  if (map.__zntcParsedMappings) return map.__zntcParsedMappings;
+  let source = 0;
+  let originalLine = 0;
+  let originalColumn = 0;
+  let name = 0;
+  const parsed = [];
+  for (const line of String(map.mappings || "").split(";")) {
+    let generatedColumn = 0;
+    const segments = [];
+    for (const segment of line.split(",")) {
+      if (!segment) continue;
+      const values = decodeSourceMapVlq(segment);
+      if (values.length === 0) continue;
+      generatedColumn += values[0];
+      if (values.length >= 4) {
+        source += values[1];
+        originalLine += values[2];
+        originalColumn += values[3];
+        if (values.length >= 5) name += values[4];
+        segments.push({ generatedColumn, source, originalLine, originalColumn });
+      }
+    }
+    parsed.push(segments);
+  }
+  Object.defineProperty(map, "__zntcParsedMappings", { value: parsed });
+  return parsed;
+}
+function findOriginalPosition(map, line, column) {
+  const segments = parseSourceMapMappings(map)[line - 1];
+  if (!segments || segments.length === 0) return null;
+  let lo = 0;
+  let hi = segments.length - 1;
+  let best = null;
+  while (lo <= hi) {
+    const mid = (lo + hi) >> 1;
+    const segment = segments[mid];
+    if (segment.generatedColumn <= column) {
+      best = segment;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  best = best || segments[0];
+  const source = map.sources && map.sources[best.source];
+  if (!source) return null;
+  const columnOffset = Math.max(0, column - best.generatedColumn);
+  return {
+    source: displaySourceName(source),
+    line: best.originalLine + 1,
+    column: best.originalColumn + columnOffset,
+  };
+}
+async function loadSourceMapForGeneratedUrl(url) {
+  const generatedUrl = new URL(url, location.href).href;
+  if (sourceMapCache.has(generatedUrl)) return sourceMapCache.get(generatedUrl);
+  const safeJson = async (response) => {
+    try { return await response.json(); } catch (_) { return null; }
+  };
+  const promise = (async () => {
+    const direct = await fetch(generatedUrl + ".map", { cache: "no-store" }).catch(() => null);
+    if (direct && direct.ok) return safeJson(direct);
+    const jsResponse = await fetch(generatedUrl, { cache: "no-store" }).catch(() => null);
+    if (!jsResponse || !jsResponse.ok) return null;
+    const code = await jsResponse.text();
+    const match =
+      code.match(/\\/\\/[#@]\\s*sourceMappingURL=([^\\n\\r]+)/) ||
+      code.match(/\\/\\*[#@]\\s*sourceMappingURL=([^*]+)\\*\\//);
+    if (!match) return null;
+    const ref = match[1].trim();
+    if (ref.startsWith("data:")) {
+      const comma = ref.indexOf(",");
+      if (comma < 0) return null;
+      const meta = ref.slice(0, comma);
+      const data = ref.slice(comma + 1);
+      try {
+        const json = meta.includes(";base64") ? atob(data) : decodeURIComponent(data);
+        return JSON.parse(json);
+      } catch (_) {
+        return null;
+      }
+    }
+    const mapResponse = await fetch(new URL(ref, generatedUrl).href, { cache: "no-store" }).catch(() => null);
+    return mapResponse && mapResponse.ok ? safeJson(mapResponse) : null;
+  })();
+  sourceMapCache.set(generatedUrl, promise);
+  return promise;
+}
+async function mapGeneratedLocation(url, line, column) {
+  const map = await loadSourceMapForGeneratedUrl(url);
+  return map ? findOriginalPosition(map, line, column) : null;
+}
+async function mapLocationText(text) {
+  if (!text) return text;
+  const match = String(text).match(/(https?:\\/\\/[^\\s)]+):(\\d+):(\\d+)/);
+  if (!match) return text;
+  const mapped = await mapGeneratedLocation(match[1], Number(match[2]), Number(match[3]));
+  if (!mapped) return text;
+  return String(text).replace(match[0], mapped.source + ":" + mapped.line + ":" + mapped.column);
+}
+async function mapStackTrace(stack) {
+  if (typeof stack !== "string") return stack;
+  const lines = await Promise.all(stack.split("\\n").map(mapLocationText));
+  return lines.join("\\n");
+}
+async function normalizeRuntimeErrorWithSourceMap(error, file) {
+  const item = normalizeRuntimeError(error, file);
+  item.file = await mapLocationText(item.file);
+  item.message = await mapStackTrace(item.message);
+  return item;
+}
+async function showRuntimeOverlay(error, file) {
+  let item;
+  try {
+    item = await normalizeRuntimeErrorWithSourceMap(error, file);
+  } catch (_) {
+    item = normalizeRuntimeError(error, file);
+  }
+  showOverlay([item], "Runtime Error");
+}
+function showOverlay(errors, titleText = "Build Error") {
+  hideOverlay();
+  const items = normalizeErrors(errors);
+  overlay = document.createElement("div");
+  overlay.id = "zntc-error-overlay";
+  const root = overlay.attachShadow({ mode: "open" });
+  const style = document.createElement("style");
+  style.textContent = ":host{position:fixed;inset:0;z-index:2147483647;display:block;--font:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;--red:#fb7185;--text:#f8fafc;--blue:#93c5fd;--window:#181818;}" +
+    ".backdrop{position:fixed;inset:0;overflow:auto;padding:32px;box-sizing:border-box;background:rgba(0,0,0,.66);font:14px/1.5 var(--font);color:var(--text);}" +
+    ".window{max-width:980px;margin:0 auto;background:var(--window);border-top:8px solid var(--red);border-radius:6px 6px 8px 8px;box-shadow:0 19px 38px rgba(0,0,0,.30),0 15px 12px rgba(0,0,0,.22);overflow:hidden;}" +
+    ".header{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:18px 20px;border-bottom:1px solid rgba(255,255,255,.12);}" +
+    ".title{font-size:18px;font-weight:700;color:#fecdd3;}" +
+    ".close{width:30px;height:30px;border:1px solid rgba(255,255,255,.25);border-radius:4px;background:#111827;color:var(--text);cursor:pointer;font:18px/1 var(--font);}" +
+    ".card{padding:18px 20px;border-top:1px solid rgba(255,255,255,.08);}" +
+    ".file{margin-bottom:10px;color:var(--blue);word-break:break-all;}" +
+    ".message{margin:0;white-space:pre-wrap;color:#fff;word-break:break-word;font:14px/1.5 var(--font);}";
+  const backdrop = document.createElement("div");
+  backdrop.className = "backdrop";
+  const panel = document.createElement("div");
+  panel.className = "window";
+  panel.onclick = (event) => event.stopPropagation();
+  const header = document.createElement("div");
+  header.className = "header";
+  const title = document.createElement("div");
+  title.className = "title";
+  title.textContent = titleText;
+  const close = document.createElement("button");
+  close.type = "button";
+  close.textContent = "x";
+  close.className = "close";
+  close.setAttribute("aria-label", "Close error overlay");
+  close.onclick = hideOverlay;
+  header.appendChild(title);
+  header.appendChild(close);
+  panel.appendChild(header);
+  for (const item of items) {
+    const card = document.createElement("div");
+    card.className = "card";
+    if (item.file) {
+      const file = document.createElement("div");
+      file.className = "file";
+      file.textContent = item.file;
+      card.appendChild(file);
+    }
+    const message = document.createElement("pre");
+    message.className = "message";
+    message.textContent = item.message;
+    card.appendChild(message);
+    panel.appendChild(card);
+  }
+  backdrop.appendChild(panel);
+  root.appendChild(style);
+  root.appendChild(backdrop);
+  closeOverlayOnEsc = (event) => {
+    if (event.key === "Escape" || event.code === "Escape") hideOverlay();
+  };
+  document.addEventListener("keydown", closeOverlayOnEsc);
+  (document.body || document.documentElement).appendChild(overlay);
+}
+globalThis.__zntc_show_error_overlay = showOverlay;
+globalThis.__zntc_clear_error_overlay = hideOverlay;
+if (!globalThis.__zntc_runtime_listeners_attached) {
+  globalThis.__zntc_runtime_listeners_attached = true;
+  window.addEventListener("error", (event) => {
+    const file = event.filename ? event.filename + ":" + event.lineno + ":" + event.colno : "";
+    showRuntimeOverlay(event.error || event.message, file);
+  });
+  window.addEventListener("unhandledrejection", (event) => {
+    showRuntimeOverlay(event.reason, "");
+  });
+}
+const socket = new WebSocket(socketProtocol + "//" + location.host + "${APP_DEV_HMR_WS_PATH}");
+socket.addEventListener("message", (event) => {
+  const msg = JSON.parse(event.data);
+  if (msg.type === "${HMR_MSG.Error}") {
+    showOverlay(msg.errors);
+    return;
+  }
+  if (msg.type === "${HMR_MSG.ClearError}") {
+    hideOverlay();
+    return;
+  }
+  if (msg.type === "${HMR_MSG.FullReload}") {
+    hideOverlay();
+    location.reload();
+    return;
+  }
+  if (msg.type !== "${HMR_MSG.CssUpdate}") return;
+  hideOverlay();
+  const stamp = msg.timestamp || Date.now();
+  const links = Array.from(document.querySelectorAll('link[rel="stylesheet"]'));
+  let updated = false;
+  for (const link of links) {
+    const href = link.getAttribute("href");
+    if (!href) continue;
+    const current = new URL(href, location.href);
+    const target = new URL(msg.href || current.pathname, location.href);
+    if (msg.href && current.pathname !== target.pathname) continue;
+    const next = new URL(current.href);
+    next.searchParams.set("t", String(stamp));
+    const replacement = link.cloneNode();
+    replacement.href = next.href;
+    replacement.onload = () => link.remove();
+    replacement.onerror = () => location.reload();
+    link.after(replacement);
+    updated = true;
+  }
+  if (!updated) location.reload();
+});
+`;
+//#endregion
+//#region index.ts
+export { APP_DEV_HMR_CLIENT_PATH, APP_DEV_HMR_WS_PATH, createHmrChannel, createWatcher, HMR_MSG, injectAppDevBundleCssLinks, injectAppDevHmrClient, injectAppDevPipelineCssLinks, injectIntoDevHtml, DEFAULT_HTML_ENV_PREFIX, applyHtmlEnvTokens, transformHtmlEnvTokens, joinUrl, isCssIdent, isCssIdentStart, skipCssString, skipCssUrl, startsWithCssIdent, collectAppFiles, requireFromAppOrFallback, collectPostcssMessages, findPostcssConfig, isCssFile, isPostcssConfigFile, loadPostcssConfig, logPostcssProcessed, POSTCSS_CONFIG_NAMES, runPostcssForAppDev, runPostcssIfConfigured, buildCssPreprocessorProxy, CSS_PREPROCESSOR_EXTENSIONS, compileSassFile, cssPreprocessorOutputPath, cssPreprocessorProxyPath, isCssModulePreprocessorFile, isCssPreprocessorFile, isStyleReferenceSource, loadSassCompiler, rewriteSassReferences, transformCssPreprocessors, buildCssModuleProxy, collectCssModuleClasses, cssModuleGeneratedCssPath, cssModuleLocalName, cssModuleProxyPath, isCssModuleFile, isValidExportName, rewriteCssModuleClasses, rewriteCssModuleReferences, scanCssModuleClassTokens, transformCssModules, cleanupPostcssTempRoot, createAppDevController, prepareAppCssPipelineRoot, APP_DEV_HMR_CLIENT };
+//#endregion