@markless/bundler 0.2.1 → 0.3.0

package/dist/rolldown-CpG_S-ZJ.js

@@ -1,2554 +0,0 @@
-import { MarklessCompileError, createCompileErrorPayload } from "./dev-error.js";
-import { C as planModulePreloads, _ as normalizeExecutionLogMode, a as payloadModule, b as MARKLESS_BUNDLE_GRAPH, c as scopedSymbolExportName, d as MARKLESS_EXECUTION_LOG_MODULE_ID, f as MARKLESS_EXECUTION_SIZES, g as injectExecutionLogModuleHook, h as executionLogVirtualModuleSource, i as encodedSymbolSource, l as symbolVirtualModuleId, m as executionLogActivationInjection, n as emitResumeModule, o as resumeVirtualModuleId, p as createExecutionSizesAsset, r as emitSourceModule, s as rewriteSymbolModuleExport, t as MARKLESS_VIRTUAL_PREFIX, u as symbolVirtualModuleSourceFile, v as requalifyExecutionLogModuleHook, x as outputDefaults, y as MARKLESS_BUILD_PREFIX } from "./source-module-C8W2THUI.js";
-import { joinURL, parsePath, withLeadingSlash, withQuery, withoutLeadingSlash } from "ufo";
-import { dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
-import { defDGraph } from "@thi.ng/dgraph";
-import { collectTsrxModuleDiagnostics, compileTsrxModule, emitSymbolResolverModule, parseJavaScriptModule } from "@markless/compiler";
-import { createStorageSeedMetadataFromGraphNodeId } from "@markless/serializer";
-import { createInlineResumerDebugRegistrationSource, createInlineResumerSource } from "@markless/web/inline/resumer";
-//#region src/build/bundle-graph.ts
-const SLOW_BUNDLE_TOTAL = 300 * 1024 / 8 * .5;
-const SMALL_BUNDLE_TOTAL = 1e3;
-function convertManifestToBundleGraph(manifest, bundleGraphAdders) {
-	const graph = bundleGraphRecords(manifest, bundleGraphAdders);
-	const dag = defDGraph(bundleGraphEdges(graph));
-	const reduced = dag.copy();
-	for (const name of dag.nodes()) for (const dep of dag.immediateDependencies(name)) for (const transitive of dag.transitiveDependencies(dep)) reduced.removeEdge(name, transitive);
-	const nodes = Object.keys(graph).sort().map((name) => {
-		const bundle = graph[name];
-		const dynamicImports = (bundle?.dynamicImports ?? []).map((dep) => [dep, dynamicImportMarker(bundle, graph[dep])]).sort((a, b) => a[1] - b[1] || a[0].localeCompare(b[0]));
-		const deps = [...reduced.immediateDependencies(name)].sort();
-		let lastMarker;
-		for (const [dep, marker] of dynamicImports) {
-			if (marker !== lastMarker) {
-				deps.push(marker);
-				lastMarker = marker;
-			}
-			deps.push(dep);
-		}
-		return [name, deps];
-	});
-	const indexes = /* @__PURE__ */ new Map();
-	let index = 0;
-	for (const [name, deps] of nodes) {
-		indexes.set(name, index);
-		index += 1 + deps.length;
-	}
-	return nodes.flatMap(([name, deps]) => [name, ...deps.map((dep) => {
-		if (typeof dep === "number") return dep;
-		return indexes.get(dep);
-	})]);
-}
-function createPreloadGraphAdder(addEntries) {
-	return (manifest) => addEntries({
-		manifest,
-		hasBundle: (bundleName) => !!manifest.bundles[bundleName],
-		bundlesForOrigins: (origins) => bundlesForOrigins(manifest, origins)
-	});
-}
-function bundlesForOrigins(manifest, origins) {
-	const normalizedOrigins = new Set(origins.map(normalizeManifestOrigin));
-	const bundles = [];
-	for (const [bundleName, bundle] of Object.entries(manifest.bundles)) if (bundle.origins?.some((origin) => normalizedOrigins.has(normalizeManifestOrigin(origin)))) bundles.push(bundleName);
-	return bundles.sort();
-}
-function bundleGraphRecords(manifest, bundleGraphAdders) {
-	const graph = { ...manifest.bundles };
-	const runtimeBundles = runtimeBundleNamesByModuleId(manifest);
-	for (const module of manifest.modules) {
-		const runtimeModuleIdsBySymbolId = new Map((module.runtimeDemandMap?.symbols ?? []).map((symbol) => [symbol.symbolId, symbol.runtimeModuleIds]));
-		for (const symbol of module.symbols) {
-			if (!symbol.fileName) continue;
-			const imports = [...manifest.bundles[symbol.fileName]?.imports ?? [], ...module.resolver.fileName ? [module.resolver.fileName] : []];
-			const runtimeDemandBundles = (runtimeModuleIdsBySymbolId.get(symbol.symbolId) ?? []).flatMap((id) => runtimeBundles.get(id) ?? []);
-			const symbolBundle = {
-				size: 0,
-				total: 0,
-				dynamicImports: [...new Set([symbol.fileName, ...runtimeDemandBundles])]
-			};
-			if (imports.length > 0) symbolBundle.imports = imports;
-			graph[symbol.symbolId] = symbolBundle;
-		}
-	}
-	for (const [bundleName, bundle] of Object.entries(graph)) for (const symbolId of bundle.symbols ?? []) {
-		if (symbolId === bundleName) continue;
-		graph[symbolId] = appendDynamicImport(graph[symbolId] ?? {
-			size: 0,
-			total: 0
-		}, bundleName);
-	}
-	if (bundleGraphAdders) {
-		const combined = {
-			...manifest,
-			bundles: graph
-		};
-		for (const add of bundleGraphAdders) Object.assign(graph, add(combined));
-	}
-	for (const bundleName of Object.keys(graph)) {
-		const bundle = graph[bundleName];
-		if (!bundle) continue;
-		graph[bundleName] = {
-			...bundle,
-			imports: bundle.imports?.filter((dep) => graph[dep]) ?? [],
-			dynamicImports: bundle.dynamicImports?.filter((dep) => graph[dep]) ?? []
-		};
-	}
-	const used = /* @__PURE__ */ new Set();
-	for (const bundle of Object.values(graph)) {
-		for (const dep of bundle.imports ?? []) used.add(dep);
-		for (const dep of bundle.dynamicImports ?? []) used.add(dep);
-	}
-	for (const [bundleName, bundle] of Object.entries(graph)) if (!used.has(bundleName) && !bundle.imports?.length && !bundle.dynamicImports?.length) delete graph[bundleName];
-	return graph;
-}
-function appendDynamicImport(bundle, dependency) {
-	if (bundle.dynamicImports?.includes(dependency)) return bundle;
-	return {
-		...bundle,
-		dynamicImports: [...bundle.dynamicImports ?? [], dependency]
-	};
-}
-function runtimeBundleNamesByModuleId(manifest) {
-	const entries = /* @__PURE__ */ new Map();
-	for (const [bundleName, bundle] of Object.entries(manifest.bundles)) for (const origin of bundle.origins ?? []) {
-		const runtimeModuleId = runtimeModuleIdFromOrigin(origin);
-		if (!runtimeModuleId) continue;
-		entries.set(runtimeModuleId, [...entries.get(runtimeModuleId) ?? [], bundleName]);
-	}
-	for (const [id, names] of entries) entries.set(id, names.sort());
-	return entries;
-}
-function runtimeModuleIdFromOrigin(origin) {
-	const normalized = normalizeManifestOrigin(origin);
-	for (const [prefix, marker] of [["web", "packages/web/src/"], ["core", "packages/core/src/"]]) {
-		const index = normalized.lastIndexOf(marker);
-		if (index === -1 || !normalized.endsWith(".ts")) continue;
-		return `${prefix}/${normalized.slice(index + marker.length, -3)}`;
-	}
-}
-function dynamicImportMarker(bundle, dependency) {
-	let probability = .5;
-	if (hasRelatedOrigin(bundle, dependency)) probability += .25;
-	if ((dependency?.total ?? 0) > SLOW_BUNDLE_TOTAL) if (probability > .5) probability += .02;
-	else probability -= .02;
-	if ((dependency?.total ?? 0) < SMALL_BUNDLE_TOTAL) probability += .15;
-	probability = Math.min(probability, .99);
-	return -Math.round(probability * 10);
-}
-function hasRelatedOrigin(bundle, dependency) {
-	return !!bundle?.origins?.some((origin) => dependency?.origins?.some((depOrigin) => depOrigin.startsWith(origin)));
-}
-function* bundleGraphEdges(graph) {
-	for (const [bundleName, bundle] of Object.entries(graph)) {
-		yield [bundleName, null];
-		for (const dep of bundle.imports ?? []) yield [bundleName, dep];
-	}
-}
-function normalizeManifestOrigin(origin) {
-	return withoutLeadingSlash(normalize(origin));
-}
-//#endregion
-//#region src/build/dynamic-import-scan.ts
-function scanEmittedDynamicImports(code, chunkFileName) {
-	if (!code.includes("import(")) return [];
-	let ast;
-	try {
-		ast = parseJavaScriptModule(code);
-	} catch {
-		return [];
-	}
-	const specifiers = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		if (!node || typeof node !== "object") return;
-		if (node.type === "ImportExpression") {
-			const specifier = staticSpecifier(node.source ?? node.arguments);
-			if (specifier?.startsWith(".")) specifiers.add(join(dirname(chunkFileName), specifier));
-		}
-		for (const child of childNodes$1(node)) visit(child);
-	};
-	visit(ast);
-	return [...specifiers];
-}
-function staticSpecifier(source) {
-	const node = Array.isArray(source) ? source[0] : source;
-	if (!node || typeof node !== "object") return void 0;
-	const astNode = node;
-	if (astNode.type === "Literal" || astNode.type === "StringLiteral") return typeof astNode.value === "string" ? astNode.value : void 0;
-	if (astNode.type === "TemplateLiteral" && (astNode.expressions ?? []).length === 0) {
-		const quasi = astNode.quasis?.[0];
-		return quasi?.value?.cooked ?? quasi?.cooked;
-	}
-}
-function childNodes$1(node) {
-	const children = [];
-	for (const [key, value] of Object.entries(node)) {
-		if (key === "loc" || key === "span" || key === "range") continue;
-		if (Array.isArray(value)) {
-			for (const item of value) if (isAstNode$1(item)) children.push(item);
-			continue;
-		}
-		if (isAstNode$1(value)) children.push(value);
-	}
-	return children;
-}
-function isAstNode$1(value) {
-	return !!value && typeof value === "object" && "type" in value;
-}
-//#endregion
-//#region src/build/head-links.ts
-const STYLESHEET_ASSET_RE = /\.css$/;
-function collectHeadLinkInjections(bundle, options = {}) {
-	const publicPath = options.publicPath ?? ((fileName) => fileName);
-	const stylesheetFiles = stylesheetFilesFromViteMetadata(bundle);
-	if (stylesheetFiles.size === 0) {
-		for (const item of Object.values(bundle)) if (item.type === "asset" && STYLESHEET_ASSET_RE.test(item.fileName)) stylesheetFiles.add(item.fileName);
-	}
-	return [...stylesheetFiles].sort().map((fileName) => stylesheetInjection(publicPath(fileName)));
-}
-function stylesheetFilesFromViteMetadata(bundle) {
-	const stylesheetFiles = /* @__PURE__ */ new Set();
-	for (const item of Object.values(bundle)) {
-		if (item.type !== "chunk") continue;
-		for (const fileName of item.viteMetadata?.importedCss ?? []) stylesheetFiles.add(fileName);
-	}
-	return stylesheetFiles;
-}
-function collectModulePreloadInjections(preloadSource, options = {}) {
-	const buildMetadata = isBuildMetadata(preloadSource) ? preloadSource : void 0;
-	const bundleGraph = buildMetadata ? buildMetadata.bundleGraph : preloadSource;
-	const roots = [...buildMetadata ? symbolRootsFromBuildMetadata(buildMetadata) : (bundleGraph ?? []).filter((name) => typeof name === "string" && name.startsWith("symbol:")).map((name) => ({
-		name,
-		priority: "high"
-	})), ...(options.entryChunks ?? []).map((name) => ({
-		name,
-		priority: "auto",
-		edges: "dynamic-only"
-	}))];
-	return planModulePreloads({
-		base: options.publicPath ? options.publicPath(MARKLESS_BUILD_PREFIX) : joinURL("/", MARKLESS_BUILD_PREFIX),
-		bundleGraph,
-		roots
-	}).map(modulePreloadInjection);
-}
-function symbolRootsFromBuildMetadata(metadata) {
-	const roots = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const module of metadata.modules) for (const symbol of module.symbols) {
-		if (!symbol.fileName || seen.has(symbol.symbolId)) continue;
-		seen.add(symbol.symbolId);
-		roots.push({
-			name: symbol.symbolId,
-			priority: "high"
-		});
-	}
-	return roots;
-}
-function isBuildMetadata(value) {
-	return !!value && typeof value === "object" && !Array.isArray(value) && Array.isArray(value.modules);
-}
-function injectHeadLinks(bundle, injections) {
-	if (injections.length === 0) return;
-	const links = injections.map(headLinkTag).join("");
-	for (const output of Object.values(bundle)) {
-		if (!isHtmlAssetWithSource(output)) continue;
-		output.source = output.source.includes("</head>") ? output.source.replace("</head>", `${links}</head>`) : `${links}${output.source}`;
-	}
-}
-function headLinkTag(injection) {
-	const attributes = Object.entries(injection.attributes ?? {}).map(([name, value]) => `${name}="${value.replaceAll("\"", "&quot;")}"`);
-	const open = attributes.length > 0 ? `<${injection.tag} ${attributes.join(" ")}>` : `<${injection.tag}>`;
-	return injection.children === void 0 ? open : `${open}${injection.children}</${injection.tag}>`;
-}
-function isHtmlAssetWithSource(output) {
-	if (!output || typeof output !== "object") return false;
-	const asset = output;
-	return asset.type === "asset" && typeof asset.fileName === "string" && asset.fileName.endsWith(".html") && typeof asset.source === "string";
-}
-function modulePreloadInjection(preload) {
-	const attributes = {
-		rel: "modulepreload",
-		href: preload.href,
-		crossorigin: "anonymous"
-	};
-	if (preload.fetchPriority && preload.fetchPriority !== "auto") attributes.fetchpriority = preload.fetchPriority;
-	return {
-		tag: "link",
-		location: "head",
-		attributes
-	};
-}
-function stylesheetInjection(href) {
-	return {
-		tag: "link",
-		location: "head",
-		attributes: {
-			rel: "stylesheet",
-			href
-		}
-	};
-}
-//#endregion
-//#region src/build/build-metadata.ts
-function createBuildMetadata(bundle, transformManifests, root, options = {}) {
-	const canonPath = options.canonPath ?? ((fileName) => fileName);
-	const publicPath = options.publicPath ?? ((fileName) => fileName);
-	const modules = [...transformManifests].map(cloneTransformManifest);
-	const metadata = {
-		version: 1,
-		modules,
-		bundles: {},
-		assets: {},
-		injections: [...options.injections ?? [], ...collectHeadLinkInjections(bundle, { publicPath })]
-	};
-	for (const item of Object.values(bundle)) {
-		if (item.type === "asset") {
-			if (item.fileName.endsWith(".js.map")) continue;
-			metadata.assets[item.fileName] = assetInfo(item);
-			continue;
-		}
-		const bundleFileName = canonPath(item.fileName);
-		const origins = getOrigins(item, root);
-		const asyncBundle = {
-			size: item.code.length,
-			total: item.code.length
-		};
-		const imports = mapBundleNames(bundle, item.imports, canonPath);
-		if (imports.length > 0) asyncBundle.imports = imports;
-		const dynamicImports = [...new Set([...mapBundleNames(bundle, item.dynamicImports, canonPath), ...mapBundleNames(bundle, scanEmittedDynamicImports(item.code, item.fileName), canonPath)])];
-		if (dynamicImports.length > 0) asyncBundle.dynamicImports = dynamicImports;
-		if (origins.length > 0) asyncBundle.origins = origins;
-		finalizeVirtualModuleReferences(modules, item, bundleFileName);
-		const symbols = modules.flatMap((module) => module.symbols.filter((symbol) => symbol.fileName === bundleFileName).map((symbol) => symbol.symbolId));
-		if (symbols.length > 0) asyncBundle.symbols = symbols;
-		metadata.bundles[bundleFileName] = asyncBundle;
-	}
-	computeTotals(metadata.bundles);
-	sortBuildMetadata(metadata);
-	if (options.bundleGraphAsset) {
-		metadata.bundleGraph = convertManifestToBundleGraph(metadata, options.bundleGraphAdders);
-		metadata.bundleGraphAsset = options.bundleGraphAsset;
-		metadata.assets[options.bundleGraphAsset] = {
-			name: "bundle-graph.json",
-			size: JSON.stringify(metadata.bundleGraph).length
-		};
-	}
-	return metadata;
-}
-function cloneTransformManifest(manifest) {
-	return {
-		source: manifest.source,
-		payload: { ...manifest.payload },
-		resolver: { ...manifest.resolver },
-		symbols: manifest.symbols.map((symbol) => ({ ...symbol })),
-		runtimeDemandMap: manifest.runtimeDemandMap
-	};
-}
-function finalizeVirtualModuleReferences(modules, item, bundleFileName) {
-	const ids = new Set([item.facadeModuleId ?? void 0, ...item.moduleIds].filter((id) => !!id).map(normalizeVirtualModuleId));
-	for (const module of modules) {
-		for (const reference of [module.payload, module.resolver]) if (ids.has(normalizeVirtualModuleId(reference.virtualModuleId))) reference.fileName = bundleFileName;
-		for (const symbol of module.symbols) if (ids.has(normalizeVirtualModuleId(symbol.virtualModuleId))) symbol.fileName = bundleFileName;
-	}
-}
-function normalizeVirtualModuleId(id) {
-	if (id.startsWith("\0")) return id.slice(1);
-	return id;
-}
-function assetInfo(item) {
-	return {
-		name: item.names?.[0] ?? item.name,
-		size: item.source.length
-	};
-}
-function mapBundleNames(bundle, names, canonPath) {
-	return names.flatMap((name) => {
-		const item = bundle[name];
-		if (item) return [canonPath(item.fileName)];
-		return [canonPath(name)];
-	});
-}
-function getOrigins(item, root) {
-	return item.moduleIds.filter((id) => !id.startsWith("\0")).map((id) => {
-		if (root) return relative(root, id);
-		return id;
-	}).sort();
-}
-function computeTotals(bundles) {
-	const collect = (name, seen) => {
-		const bundle = bundles[name];
-		if (!bundle || seen.has(name)) return;
-		seen.add(name);
-		for (const dep of bundle.imports ?? []) collect(dep, seen);
-	};
-	for (const name of Object.keys(bundles)) {
-		const seen = /* @__PURE__ */ new Set();
-		collect(name, seen);
-		bundles[name].total = [...seen].reduce((sum, dep) => sum + (bundles[dep]?.size ?? 0), 0);
-	}
-}
-function sortBuildMetadata(metadata) {
-	metadata.modules = metadata.modules.sort((a, b) => a.source.localeCompare(b.source));
-	metadata.bundles = sortRecord(metadata.bundles);
-	metadata.assets = sortRecord(metadata.assets ?? {});
-	metadata.injections?.sort((a, b) => injectionKey(a).localeCompare(injectionKey(b)));
-	for (const bundle of Object.values(metadata.bundles)) {
-		bundle.imports?.sort();
-		bundle.dynamicImports?.sort();
-		bundle.origins?.sort();
-		bundle.symbols?.sort();
-	}
-	for (const module of metadata.modules) module.symbols.sort((a, b) => a.symbolId.localeCompare(b.symbolId));
-}
-function sortRecord(record) {
-	const next = {};
-	for (const key of Object.keys(record).sort()) {
-		const value = record[key];
-		if (value !== void 0) next[key] = value;
-	}
-	return next;
-}
-function injectionKey(injection) {
-	return `${injection.location}:${injection.tag}:${injection.attributes?.href ?? ""}`;
-}
-//#endregion
-//#region src/build/preload-cleanup.ts
-function stripEmptyVitePreloadWrappers(code) {
-	return stripImportedVitePreloadHelper(stripUnusedVitePreloadHelper(stripAsyncEmptyPreloadWrappers(stripDirectEmptyPreloadWrappers(code))));
-}
-const IMPORT_DECLARATION_CANDIDATE_RE = /\bimport\s*\{[\s\S]*?\}\s*from\s*["'][^"']+["'];?/g;
-function stripDirectEmptyPreloadWrappers(code) {
-	let next = "";
-	let cursor = 0;
-	let changed = false;
-	const wrapperRE = /\b[$A-Z_a-z][$\w]*\(\(\)\s*=>\s*/g;
-	for (let match = wrapperRE.exec(code); match; match = wrapperRE.exec(code)) {
-		const callStart = match.index;
-		const bodyStart = match.index + match[0].length;
-		if (!code.startsWith("import(", bodyStart)) continue;
-		const wrapper = findEmptyPreloadWrapper(code, callStart, bodyStart);
-		if (!wrapper) continue;
-		next += code.slice(cursor, callStart);
-		next += code.slice(bodyStart, wrapper.firstArgumentEnd);
-		cursor = wrapper.callEnd + 1;
-		wrapperRE.lastIndex = cursor;
-		changed = true;
-	}
-	if (!changed) return code;
-	return next + code.slice(cursor);
-}
-function stripAsyncEmptyPreloadWrappers(code) {
-	let next = "";
-	let cursor = 0;
-	let changed = false;
-	const wrapperRE = /\b[$A-Z_a-z][$\w]*\(\s*async\s*\(\)\s*=>\s*\{/g;
-	for (let match = wrapperRE.exec(code); match; match = wrapperRE.exec(code)) {
-		const callStart = match.index;
-		const callOpen = code.indexOf("(", callStart);
-		if (callOpen < 0) continue;
-		const firstArgumentEnd = findTopLevelComma(code, callOpen + 1);
-		if (firstArgumentEnd < 0) continue;
-		const wrapper = findEmptyPreloadWrapper(code, callStart, callOpen + 1);
-		if (!wrapper) continue;
-		const loader = code.slice(callOpen + 1, firstArgumentEnd);
-		next += code.slice(cursor, callStart);
-		next += `(${loader})()`;
-		cursor = wrapper.callEnd + 1;
-		wrapperRE.lastIndex = cursor;
-		changed = true;
-	}
-	if (!changed) return code;
-	return next + code.slice(cursor);
-}
-function findEmptyPreloadWrapper(code, callStart, bodyStart) {
-	const callOpen = code.indexOf("(", callStart);
-	if (callOpen < 0 || callOpen >= bodyStart) return void 0;
-	const firstArgumentEnd = findTopLevelComma(code, callOpen + 1);
-	if (firstArgumentEnd < 0) return void 0;
-	let cursor = skipSpaces(code, firstArgumentEnd + 1);
-	if (code[cursor] !== "[" || code[cursor + 1] !== "]") return void 0;
-	cursor = skipSpaces(code, cursor + 2);
-	if (code[cursor] === ")") return {
-		firstArgumentEnd,
-		callEnd: cursor
-	};
-	if (code[cursor] !== ",") return void 0;
-	cursor = skipSpaces(code, cursor + 1);
-	if (!code.startsWith("import.meta.url", cursor)) return void 0;
-	cursor = skipSpaces(code, cursor + 15);
-	if (code[cursor] !== ")") return void 0;
-	return {
-		firstArgumentEnd,
-		callEnd: cursor
-	};
-}
-function findTopLevelComma(code, start) {
-	let depth = 1;
-	let quote = null;
-	let escaped = false;
-	for (let index = start; index < code.length; index++) {
-		const char = code[index];
-		if (quote) {
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\") {
-				escaped = true;
-				continue;
-			}
-			if (char === quote) quote = null;
-			continue;
-		}
-		if (char === "\"" || char === "'" || char === "`") {
-			quote = char;
-			continue;
-		}
-		if (char === "(" || char === "[" || char === "{") {
-			depth++;
-			continue;
-		}
-		if (char === ")" || char === "]" || char === "}") {
-			depth--;
-			if (depth === 0) return -1;
-			continue;
-		}
-		if (char === "," && depth === 1) return index;
-	}
-	return -1;
-}
-function skipSpaces(code, start) {
-	let cursor = start;
-	while (/\s/.test(code[cursor] ?? "")) cursor++;
-	return cursor;
-}
-function stripImportedVitePreloadHelper(code) {
-	const helper = findImportedVitePreloadHelper(code);
-	if (!helper) return code;
-	const withoutImport = code.slice(0, helper.importStart) + code.slice(helper.importEnd);
-	if (hasCallableReference(withoutImport, helper.preloadFunction)) return code;
-	const initCall = `${escapeRegExp$1(helper.initFunction)}\\(\\)`;
-	return withoutImport.replace(new RegExp(String.raw`,${initCall},`, "g"), ",").replace(new RegExp(String.raw`\{${initCall},`, "g"), "{").replace(new RegExp(String.raw`,${initCall},`, "g"), ",").replace(new RegExp(String.raw`,${initCall}\}`, "g"), "}").replace(new RegExp(String.raw`\{${initCall}\}`, "g"), "{}");
-}
-function findImportedVitePreloadHelper(code) {
-	for (const match of code.matchAll(IMPORT_DECLARATION_CANDIDATE_RE)) {
-		const importStart = match.index ?? -1;
-		if (importStart < 0) continue;
-		const statement = match[0];
-		const declaration = asNodes(tryParseJavaScriptModule(statement)?.body).find((node) => node.type === "ImportDeclaration");
-		if (!declaration) continue;
-		let preloadFunction;
-		let initFunction;
-		for (const specifier of asNodes(declaration.specifiers)) {
-			if (specifier.type !== "ImportSpecifier") continue;
-			const imported = identifierName(specifier.imported);
-			const local = identifierName(specifier.local);
-			if (!imported || !local) continue;
-			if (imported === "__vitePreload") preloadFunction = local;
-			if (imported === "init_preload_helper") initFunction = local;
-		}
-		if (preloadFunction && initFunction) return {
-			importStart,
-			importEnd: importStart + statement.length,
-			preloadFunction,
-			initFunction
-		};
-	}
-}
-function stripUnusedVitePreloadHelper(code) {
-	const marker = code.indexOf("vite:preloadError");
-	if (marker < 0) return code;
-	const helper = findVitePreloadHelperModule(code, marker);
-	if (!helper) return code;
-	const statementEnd = code[helper.removeStart] === "," && code[helper.removeEnd - 1] === ";" ? ";" : "";
-	const outsideHelper = code.slice(0, helper.removeStart) + statementEnd + code.slice(helper.removeEnd);
-	if (hasCallableReference(outsideHelper, helper.preloadFunction)) return code;
-	let withoutHelper = outsideHelper;
-	const chain = findVitePreloadHelperInitChain(withoutHelper, helper.moduleVariable);
-	if (chain) withoutHelper = removeInitCall(withoutHelper.slice(0, chain.removeStart) + withoutHelper.slice(chain.removeEnd), chain.entryVariable);
-	return removeInitCall(withoutHelper, helper.moduleVariable);
-}
-function findVitePreloadHelperModule(code, marker) {
-	const initStart = code.lastIndexOf("=e((()=>{", marker);
-	if (initStart < 0) return void 0;
-	const moduleVariable = readIdentifierBefore(code, initStart);
-	if (!moduleVariable) return void 0;
-	const bodyStart = initStart + 9;
-	const bodyEnd = findModuleInitEnd(code, initStart);
-	if (bodyEnd < 0) return void 0;
-	const helperBody = code.slice(bodyStart, bodyEnd);
-	const preloadFunction = helperBody.match(/,([$A-Z_a-z][$\w]*)=function\([^)]*\)\{let\s+[$A-Z_a-z][$\w]*=Promise\.resolve\(\)/)?.[1];
-	if (!preloadFunction) return void 0;
-	const firstHelperVariable = helperBody.match(/^([$A-Z_a-z][$\w]*)=/)?.[1];
-	if (!firstHelperVariable) return void 0;
-	const removeStart = findHelperDeclarationStart(code, initStart, firstHelperVariable);
-	if (removeStart < 0) return void 0;
-	return {
-		moduleVariable,
-		preloadFunction,
-		removeStart,
-		removeEnd: bodyEnd + 4
-	};
-}
-function findVitePreloadHelperInitChain(code, moduleVariable) {
-	const match = new RegExp(`var\\s+([$A-Z_a-z][$\\w]*)=e\\(\\(\\(\\)=>\\{${escapeRegExp$1(moduleVariable)}\\(\\)\\}\\)\\),([$A-Z_a-z][$\\w]*)=e\\(\\(\\(\\)=>\\{\\1\\(\\)\\}\\)\\);`).exec(code);
-	if (!match) return void 0;
-	return {
-		entryVariable: match[2],
-		removeStart: match.index,
-		removeEnd: match.index + match[0].length
-	};
-}
-function removeInitCall(code, entryVariable) {
-	return code.replace(new RegExp(`,${escapeRegExp$1(entryVariable)}\\(\\)`), "").replace(new RegExp(`${escapeRegExp$1(entryVariable)}\\(\\),`), "").replace(new RegExp(`\\{${escapeRegExp$1(entryVariable)}\\(\\)\\}`), "{}");
-}
-function readIdentifierBefore(code, index) {
-	let end = index;
-	while (/\s/.test(code[end - 1] ?? "")) end--;
-	let start = end;
-	while (/[$\w]/.test(code[start - 1] ?? "")) start--;
-	const value = code.slice(start, end);
-	return /^[$A-Z_a-z][$\w]*$/.test(value) ? value : void 0;
-}
-function findModuleInitEnd(code, initStart) {
-	return code.indexOf("}));", initStart);
-}
-function findHelperDeclarationStart(code, initStart, firstHelperVariable) {
-	const commaStart = code.lastIndexOf(`,${firstHelperVariable},`, initStart);
-	if (commaStart >= 0) return commaStart;
-	const varStart = code.lastIndexOf(`var ${firstHelperVariable},`, initStart);
-	if (varStart >= 0) return varStart;
-	return -1;
-}
-function escapeRegExp$1(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function hasCallableReference(code, name) {
-	const ast = tryParseJavaScriptModule(code);
-	if (!ast) return true;
-	let found = false;
-	walkReferenceScopes(ast, [], (node, scopes) => {
-		if (node.type !== "CallExpression") return;
-		const callee = node.callee;
-		if (identifierName(callee) !== name) return;
-		if (isDeclaredInScope(name, scopes)) return;
-		found = true;
-	});
-	return found;
-}
-function walkReferenceScopes(node, scopes, visit) {
-	if (!node || typeof node !== "object") return;
-	if (node.type === "Program") {
-		const scope = collectScopeDeclarations(asNodes(node.body));
-		visit(node, [scope]);
-		for (const child of asNodes(node.body)) walkReferenceScopes(child, [scope], visit);
-		return;
-	}
-	if (isFunctionNode(node)) {
-		const scope = /* @__PURE__ */ new Set();
-		collectBindingNames(node.id, scope);
-		for (const parameter of asNodes(node.params)) collectBindingNames(parameter, scope);
-		const nextScopes = [...scopes, scope];
-		visit(node, nextScopes);
-		walkReferenceScopes(node.body, nextScopes, visit);
-		return;
-	}
-	if (node.type === "BlockStatement") {
-		const scope = collectScopeDeclarations(asNodes(node.body));
-		const nextScopes = [...scopes, scope];
-		visit(node, nextScopes);
-		for (const child of asNodes(node.body)) walkReferenceScopes(child, nextScopes, visit);
-		return;
-	}
-	visit(node, scopes);
-	for (const child of childNodes(node)) walkReferenceScopes(child, scopes, visit);
-}
-function collectScopeDeclarations(nodes) {
-	const declarations = /* @__PURE__ */ new Set();
-	for (const node of nodes) {
-		if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
-			collectBindingNames(node.id, declarations);
-			continue;
-		}
-		if (node.type === "ImportDeclaration") {
-			for (const specifier of asNodes(node.specifiers)) collectBindingNames(specifier.local, declarations);
-			continue;
-		}
-		if (node.type === "VariableDeclaration") for (const declaration of asNodes(node.declarations)) collectBindingNames(declaration.id, declarations);
-	}
-	return declarations;
-}
-function collectBindingNames(node, names) {
-	if (!node) return;
-	const name = identifierName(node);
-	if (name) {
-		names.add(name);
-		return;
-	}
-	for (const child of childNodes(node)) collectBindingNames(child, names);
-}
-function isDeclaredInScope(name, scopes) {
-	return scopes.some((scope) => scope.has(name));
-}
-function isFunctionNode(node) {
-	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
-}
-function tryParseJavaScriptModule(code) {
-	try {
-		return parseJavaScriptModule(code);
-	} catch {
-		return;
-	}
-}
-function childNodes(node) {
-	const children = [];
-	for (const [key, value] of Object.entries(node)) {
-		if (ignoredAstKeys.has(key)) continue;
-		if (Array.isArray(value)) {
-			for (const item of value) if (isAstNode(item)) children.push(item);
-			continue;
-		}
-		if (isAstNode(value)) children.push(value);
-	}
-	return children;
-}
-function asNodes(value) {
-	return Array.isArray(value) ? value.filter(isAstNode) : [];
-}
-function isAstNode(value) {
-	return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-function identifierName(node) {
-	return node?.type === "Identifier" && typeof node.name === "string" ? node.name : void 0;
-}
-const ignoredAstKeys = new Set([
-	"closingElement",
-	"id",
-	"leadingComments",
-	"loc",
-	"metadata",
-	"openingElement",
-	"parent",
-	"range",
-	"trailingComments"
-]);
-//#endregion
-//#region src/build/symbol-facade-cleanup.ts
-const TSRX_SOURCE_FILE$1 = /\.tsrx(?:[?#].*)?$/;
-const SYMBOL_INIT_EXPORT_PREFIX = "init__virtual_markless_symbol";
-const STRING_LITERAL_SOURCE = String.raw`(?:"[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*'|` + "`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`)";
-const FUNCTION_DECLARATION_RE = /\bfunction\s+([$A-Z_a-z][$\w]*)\s*\(\s*([$A-Z_a-z][$\w]*)\s*\)\s*\{/g;
-const LOCAL_DYNAMIC_IMPORT_HELPER_RE = /import\(\s*(["'`])([^"'`]+)\1\s*\)\.then\(\s*\(?\s*([$A-Z_a-z][$\w]*)\s*\)?\s*=>\s*([$A-Z_a-z][$\w]*)\(\s*\3\s*,\s*(["'`])([^"'`]*)\5\s*\)\s*\)/g;
-const LOCAL_DYNAMIC_IMPORT_RE = /import\(\s*(["'`])([^"'`]+)\1\s*\)(?:\.then\(\s*\(?\s*([$A-Z_a-z][$\w]*)\s*\)?\s*=>\s*\3\.([$A-Z_a-z][$\w]*)\s*\))?/g;
-function rewriteGeneratedSymbolFacadeImports(bundle) {
-	const chunks = collectChunks$1(bundle);
-	const rewrites = findSymbolFacadeRewrites(chunks);
-	const removedFacades = /* @__PURE__ */ new Set();
-	if (rewrites.size === 0) return removedFacades;
-	for (const chunk of chunks.values()) {
-		if (!isGeneratedAsyncChunk(chunk)) continue;
-		const result = rewriteDynamicImportSpecifiers(chunk, rewrites);
-		chunk.code = result.code;
-		chunk.dynamicImports = unique(chunk.dynamicImports.map((fileName) => result.rewrittenFacades.has(fileName) ? rewrites.get(fileName)?.target.fileName ?? fileName : fileName));
-	}
-	for (const rewrite of rewrites.values()) {
-		const facadeId = rewrite.facade.facadeModuleId;
-		if (facadeId && !rewrite.target.moduleIds.includes(facadeId)) rewrite.target.moduleIds = [...rewrite.target.moduleIds, facadeId];
-	}
-	for (const rewrite of rewrites.values()) {
-		deleteBundleChunk(bundle, rewrite.facade.fileName);
-		chunks.delete(rewrite.facade.fileName);
-		removedFacades.add(rewrite.facade.fileName);
-	}
-	return removedFacades;
-}
-function rewriteGeneratedSymbolInitExports(bundle) {
-	const chunks = collectChunks$1(bundle);
-	const rewrites = findSymbolInitExportRewrites(chunks);
-	if (rewrites.length === 0) return { renamed: 0 };
-	const replacements = /* @__PURE__ */ new Map();
-	for (const rewrite of rewrites) {
-		rewrite.chunk.exports = rewrite.collapsed ? [...rewrite.collapsed.exports] : rewrite.chunk.exports.map((name) => rewrite.names.get(name) ?? name);
-		if (rewrite.collapsed) rewrite.chunk.code = rewrite.collapsed.code;
-		for (const [from, to] of rewrite.names) replacements.set(from, to);
-	}
-	for (const chunk of chunks.values()) {
-		if (!isGeneratedAsyncChunk(chunk)) continue;
-		chunk.code = replaceIdentifierNames(chunk.code, replacements);
-	}
-	return { renamed: replacements.size };
-}
-function compactGeneratedDirectSymbolLoaders(bundle) {
-	let compacted = 0;
-	for (const chunk of collectChunks$1(bundle).values()) {
-		if (!isGeneratedAsyncChunk(chunk)) continue;
-		if (!chunk.code.includes("?import(")) continue;
-		const result = compactDirectSymbolLoadersInCode(chunk.code);
-		if (result.compacted === 0) continue;
-		chunk.code = result.code;
-		compacted += result.compacted;
-	}
-	return { compacted };
-}
-function collectChunks$1(bundle) {
-	const chunks = /* @__PURE__ */ new Map();
-	for (const output of Object.values(bundle)) if (isGeneratedChunk$1(output)) chunks.set(output.fileName, output);
-	return chunks;
-}
-function findSymbolFacadeRewrites(chunks) {
-	const rewrites = /* @__PURE__ */ new Map();
-	for (const chunk of chunks.values()) {
-		const rewrite = findSymbolFacadeRewrite(chunk, chunks);
-		if (rewrite) rewrites.set(chunk.fileName, rewrite);
-	}
-	return rewrites;
-}
-function findSymbolInitExportRewrites(chunks) {
-	const rewrites = [];
-	for (const chunk of chunks.values()) {
-		const rewrite = findSymbolInitExportRewrite(chunk);
-		if (rewrite) rewrites.push(rewrite);
-	}
-	return rewrites;
-}
-function findSymbolInitExportRewrite(chunk) {
-	if (!isGeneratedAsyncChunk(chunk)) return void 0;
-	const initExports = chunk.exports.filter(isGeneratedSymbolInitExport);
-	if (initExports.length === 0) return void 0;
-	const names = /* @__PURE__ */ new Map();
-	const used = new Set(chunk.exports.filter((name) => !isGeneratedSymbolInitExport(name)));
-	const collapsed = collapseGeneratedSymbolInitExports(chunk.code, initExports);
-	if (collapsed) {
-		for (const name of initExports) if (name !== SYMBOL_INIT_EXPORT_PREFIX) names.set(name, SYMBOL_INIT_EXPORT_PREFIX);
-		return {
-			chunk,
-			names,
-			collapsed
-		};
-	}
-	for (const name of initExports) {
-		const next = compactSymbolInitExportName(name, used);
-		used.add(next);
-		if (next !== name) names.set(name, next);
-	}
-	return names.size > 0 ? {
-		chunk,
-		names
-	} : void 0;
-}
-function findSymbolFacadeRewrite(chunk, chunks) {
-	if (!isGeneratedSymbolFacade(chunk)) return void 0;
-	if (chunk.imports.length !== 1 || chunk.dynamicImports.length > 0) return void 0;
-	const parsed = parseSymbolFacade(chunk.code);
-	if (!parsed) return void 0;
-	const target = chunks.get(chunk.imports[0]);
-	if (!target) return void 0;
-	const targetExports = new Set(target.exports);
-	if (!chunk.exports.every((name) => targetExports.has(name))) return void 0;
-	if (!parsed.initExports.every((name) => targetExports.has(name))) return void 0;
-	return {
-		facade: chunk,
-		target,
-		initExports: parsed.initExports
-	};
-}
-function isGeneratedSymbolFacade(chunk) {
-	return (chunk.facadeModuleId ? normalizeVirtualId$2(chunk.facadeModuleId) : "").startsWith(`${MARKLESS_VIRTUAL_PREFIX}symbol:`);
-}
-function isGeneratedSymbolInitExport(name) {
-	return name === SYMBOL_INIT_EXPORT_PREFIX || name.startsWith(`${SYMBOL_INIT_EXPORT_PREFIX}_`) || /^\$\d+$/.test(name.slice(29));
-}
-function compactSymbolInitExportName(name, used) {
-	const suffix = name.match(/\$(\d+)$/)?.[1];
-	let candidate = suffix ? `${SYMBOL_INIT_EXPORT_PREFIX}$${suffix}` : SYMBOL_INIT_EXPORT_PREFIX;
-	let nextSuffix = suffix ? Number(suffix) : 0;
-	while (used.has(candidate)) {
-		nextSuffix++;
-		candidate = `${SYMBOL_INIT_EXPORT_PREFIX}$${nextSuffix}`;
-	}
-	return candidate;
-}
-function collapseGeneratedSymbolInitExports(code, initExports) {
-	if (initExports.length < 2) return void 0;
-	const match = code.match(/export\s*\{\s*([^}]*)\s*\}\s*;?\s*$/);
-	if (!match || match.index === void 0) return void 0;
-	const specifiers = parseExportSpecifiers(match[1]);
-	if (!specifiers) return void 0;
-	if (specifiers.some((specifier) => !isIdentifier(specifier.local))) return void 0;
-	const initExportSet = new Set(initExports);
-	const initLocals = unique(specifiers.filter((specifier) => initExportSet.has(specifier.exported)).map((specifier) => specifier.local));
-	if (initLocals.length < 2) return void 0;
-	const nonInitSpecifiers = specifiers.filter((specifier) => !initExportSet.has(specifier.exported));
-	if (nonInitSpecifiers.some((specifier) => specifier.exported === SYMBOL_INIT_EXPORT_PREFIX)) return;
-	const initLocal = uniqueIdentifier("$i", code);
-	return {
-		code: `${code.slice(0, match.index)}function ${initLocal}(){${initLocals.map((local) => `${local}()`).join(";")}}export{${[`${initLocal} as ${SYMBOL_INIT_EXPORT_PREFIX}`, ...nonInitSpecifiers.map(formatExportSpecifier)].join(",")}};`,
-		exports: [SYMBOL_INIT_EXPORT_PREFIX, ...nonInitSpecifiers.map((specifier) => specifier.exported)]
-	};
-}
-function rewriteDynamicImportSpecifiers(chunk, rewrites) {
-	const rewrittenFacades = /* @__PURE__ */ new Set();
-	return {
-		code: chunk.code.replace(LOCAL_DYNAMIC_IMPORT_HELPER_RE, (match, quote, specifier, parameter, helperName, exportQuote, exportName) => {
-			if (!isLocalSpecifier(specifier)) return match;
-			const importedFileName = resolveChunkSpecifier$1(chunk.fileName, specifier);
-			const rewrite = rewrites.get(importedFileName);
-			if (!rewrite) return match;
-			if (!rewrite.target.exports.includes(exportName)) return match;
-			const nextSpecifier = relativeChunkSpecifier$1(chunk.fileName, rewrite.target.fileName);
-			rewrittenFacades.add(importedFileName);
-			return `import(${quote}${nextSpecifier}${quote}).then(${parameter}=>${helperName}(${parameter},${exportQuote}${exportName}${exportQuote}))`;
-		}).replace(LOCAL_DYNAMIC_IMPORT_RE, (match, quote, specifier, parameter, exportName) => {
-			if (!isLocalSpecifier(specifier)) return match;
-			const importedFileName = resolveChunkSpecifier$1(chunk.fileName, specifier);
-			const rewrite = rewrites.get(importedFileName);
-			if (!rewrite) return match;
-			if (rewrite.initExports.length > 0 && (!parameter || !exportName)) return match;
-			const nextSpecifier = relativeChunkSpecifier$1(chunk.fileName, rewrite.target.fileName);
-			rewrittenFacades.add(importedFileName);
-			const nextImport = `import(${quote}${nextSpecifier}${quote})`;
-			if (!parameter || !exportName || rewrite.initExports.length === 0) return nextImport;
-			return `${nextImport}.then(${parameter}=>(${[...rewrite.initExports.map((name) => `${parameter}.${name}()`), `${parameter}.${exportName}`].join(",")}))`;
-		}),
-		rewrittenFacades
-	};
-}
-function compactDirectSymbolLoadersInCode(code) {
-	let next = "";
-	let cursor = 0;
-	let compacted = 0;
-	for (let match = FUNCTION_DECLARATION_RE.exec(code); match; match = FUNCTION_DECLARATION_RE.exec(code)) {
-		const functionStart = match.index;
-		const bodyStart = FUNCTION_DECLARATION_RE.lastIndex;
-		const bodyEnd = findBlockEnd(code, bodyStart - 1);
-		if (bodyEnd < 0) continue;
-		const body = code.slice(bodyStart, bodyEnd);
-		const mapName = uniqueIdentifier("$s", `${code}${next}`);
-		const moduleCacheName = uniqueIdentifier("$m", `${code}${next}${mapName}`);
-		const replacement = compactDirectSymbolLoaderFunction({
-			functionName: match[1],
-			parameterName: match[2],
-			body,
-			mapName,
-			moduleCacheName
-		});
-		if (!replacement) {
-			FUNCTION_DECLARATION_RE.lastIndex = bodyEnd + 1;
-			continue;
-		}
-		next += code.slice(cursor, functionStart);
-		next += replacement;
-		cursor = bodyEnd + 1;
-		compacted++;
-		FUNCTION_DECLARATION_RE.lastIndex = cursor;
-	}
-	if (compacted === 0) return {
-		code,
-		compacted
-	};
-	return {
-		code: next + code.slice(cursor),
-		compacted
-	};
-}
-function compactDirectSymbolLoaderFunction(input) {
-	const returnSource = input.body.trim();
-	if (!returnSource.startsWith("return ")) return void 0;
-	const parsed = parseDirectSymbolLoaderBranches(returnSource.slice(7), input.parameterName);
-	if (!parsed) return void 0;
-	const first = parsed.branches[0];
-	if (parsed.branches.some((branch) => branch.importSpecifier !== first.importSpecifier || branch.helperName !== first.helperName)) return;
-	const generatedCount = generatedSymbolRangeCount(parsed.branches);
-	if (generatedCount !== void 0) return [
-		`let ${input.moduleCacheName};`,
-		`function ${input.functionName}(${input.parameterName}){`,
-		`let t=+${input.parameterName}.slice(7);`,
-		`if(${input.parameterName}===\`symbol:\${t}\`&&t>=0&&t<${generatedCount}){`,
-		`if(${input.moduleCacheName})return ${first.helperName}(${input.moduleCacheName},\`symbol_\${t}\`);`,
-		`return import(${JSON.stringify(first.importSpecifier)})`,
-		`.then(${first.moduleParameter}=>(${input.moduleCacheName}=${first.moduleParameter},${first.helperName}(${first.moduleParameter},\`symbol_\${t}\`)))`,
-		`}`,
-		`return ${parsed.fallback}`,
-		"}"
-	].join("");
-	const exportVariable = input.parameterName === "t" ? "n" : "t";
-	const mapEntries = parsed.branches.map((branch) => `${JSON.stringify(branch.symbolId)}:${JSON.stringify(branch.exportName)}`).join(",");
-	return [
-		`const ${input.mapName}={${mapEntries}};`,
-		`let ${input.moduleCacheName};`,
-		`function ${input.functionName}(${input.parameterName}){`,
-		`let ${exportVariable}=${input.mapName}[${input.parameterName}];`,
-		`if(${exportVariable}){`,
-		`if(${input.moduleCacheName})return ${first.helperName}(${input.moduleCacheName},${exportVariable});`,
-		`return import(${JSON.stringify(first.importSpecifier)})`,
-		`.then(${first.moduleParameter}=>(${input.moduleCacheName}=${first.moduleParameter},${first.helperName}(${first.moduleParameter},${exportVariable})))`,
-		`}`,
-		`return ${parsed.fallback}`,
-		"}"
-	].join("");
-}
-function parseDirectSymbolLoaderBranches(source, parameterName) {
-	const branches = [];
-	const branchRE = directSymbolLoaderBranchRE(parameterName);
-	let cursor = 0;
-	while (cursor < source.length) {
-		const match = source.slice(cursor).match(branchRE);
-		if (!match) break;
-		const symbolId = simpleStringLiteralValue(match[1]);
-		const importSpecifier = simpleStringLiteralValue(match[2]);
-		const moduleParameter = match[3];
-		const helperName = match[4];
-		const helperArgument = match[5];
-		const exportName = simpleStringLiteralValue(match[6]);
-		if (symbolId === void 0 || importSpecifier === void 0 || exportName === void 0 || moduleParameter !== helperArgument) return;
-		branches.push({
-			symbolId,
-			importSpecifier,
-			moduleParameter,
-			helperName,
-			exportName
-		});
-		cursor += match[0].length;
-	}
-	const fallback = source.slice(cursor);
-	if (branches.length < 2 || !fallback.startsWith("Promise.reject(")) return void 0;
-	return {
-		branches,
-		fallback
-	};
-}
-function generatedSymbolRangeCount(branches) {
-	for (const [index, branch] of branches.entries()) if (branch.symbolId !== `symbol:${index}` || branch.exportName !== `symbol_${index}`) return;
-	return branches.length;
-}
-function directSymbolLoaderBranchRE(parameterName) {
-	return new RegExp(`^${escapeRegExp(parameterName)}\\s*===\\s*(${STRING_LITERAL_SOURCE})\\s*\\?\\s*import\\(\\s*(${STRING_LITERAL_SOURCE})\\s*\\)\\.then\\(\\s*\\(?\\s*([$A-Z_a-z][$\\w]*)\\s*\\)?\\s*=>\\s*([$A-Z_a-z][$\\w]*)\\(\\s*([$A-Z_a-z][$\\w]*)\\s*,\\s*(${STRING_LITERAL_SOURCE})\\s*\\)\\s*\\)\\s*:`);
-}
-function simpleStringLiteralValue(source) {
-	const quote = source[0];
-	if (quote !== "\"" && quote !== "'" && quote !== "`" || source[source.length - 1] !== quote) return;
-	return source.slice(1, -1);
-}
-function findBlockEnd(code, open) {
-	let depth = 0;
-	let quote = null;
-	let escaped = false;
-	for (let index = open; index < code.length; index++) {
-		const char = code[index];
-		if (quote) {
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\") {
-				escaped = true;
-				continue;
-			}
-			if (char === quote) quote = null;
-			continue;
-		}
-		if (char === "\"" || char === "'" || char === "`") {
-			quote = char;
-			continue;
-		}
-		if (char === "{") {
-			depth++;
-			continue;
-		}
-		if (char === "}") {
-			depth--;
-			if (depth === 0) return index;
-		}
-	}
-	return -1;
-}
-function resolveChunkSpecifier$1(importerFileName, specifier) {
-	return normalize(join(dirname(importerFileName), specifier));
-}
-function relativeChunkSpecifier$1(importerFileName, targetFileName) {
-	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
-	return value.startsWith(".") ? value : `./${value}`;
-}
-function isGeneratedAsyncChunk(chunk) {
-	return chunk.moduleIds.some((id) => {
-		return normalizeVirtualId$2(id).startsWith("virtual:markless:") || TSRX_SOURCE_FILE$1.test(id);
-	});
-}
-function deleteBundleChunk(bundle, fileName) {
-	for (const [key, output] of Object.entries(bundle)) if (isGeneratedChunk$1(output) && output.fileName === fileName) delete bundle[key];
-}
-function isGeneratedChunk$1(value) {
-	if (!value || typeof value !== "object") return false;
-	const chunk = value;
-	return chunk.type === "chunk" && typeof chunk.fileName === "string" && typeof chunk.code === "string" && Array.isArray(chunk.exports) && Array.isArray(chunk.imports) && Array.isArray(chunk.dynamicImports) && Array.isArray(chunk.moduleIds);
-}
-function unique(values) {
-	return [...new Set(values)];
-}
-function replaceIdentifierNames(code, replacements) {
-	const names = [...replacements.keys()].sort((a, b) => b.length - a.length);
-	let next = code;
-	for (const name of names) next = next.replace(identifierNameRE(name), replacements.get(name));
-	return next;
-}
-function identifierNameRE(name) {
-	return new RegExp(`(?<![$\\w])${escapeRegExp(name)}(?![$\\w])`, "g");
-}
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function isLocalSpecifier(specifier) {
-	return specifier.startsWith("./") || specifier.startsWith("../");
-}
-function parseSymbolFacade(code) {
-	const match = code.trim().match(/^import\s*\{\s*([^}]*)\s*\}\s*from\s*(["'`])([^"'`]+)\2\s*;\s*([\s\S]*?)\s*export\s*\{\s*([^}]*)\s*\}\s*;?\s*$/);
-	if (!match) return void 0;
-	const imports = parseImportSpecifiers(match[1]);
-	const exportLocals = parseExportLocalNames(match[5]);
-	if (!imports || !exportLocals) return void 0;
-	const body = match[4].trim();
-	const initLocals = body ? body.split(";").map((statement) => statement.trim()).filter(Boolean).map((statement) => statement.match(/^([$A-Z_a-z][$\w]*)\(\)$/)?.[1]) : [];
-	if (initLocals.some((name) => !name)) return void 0;
-	for (const local of exportLocals) if (!imports.has(local)) return void 0;
-	return { initExports: unique(initLocals.filter((local) => !!local).map((local) => imports.get(local)).filter((name) => !!name)) };
-}
-function parseImportSpecifiers(value) {
-	const imports = /* @__PURE__ */ new Map();
-	for (const part of value.split(",")) {
-		const specifier = part.trim();
-		if (!specifier) continue;
-		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
-		const imported = (aliased?.[1] ?? specifier).trim();
-		const local = (aliased?.[2] ?? specifier).trim();
-		if (!isIdentifier(imported) || !isIdentifier(local)) return void 0;
-		imports.set(local, imported);
-	}
-	return imports;
-}
-function parseExportLocalNames(value) {
-	const locals = [];
-	for (const part of value.split(",")) {
-		const specifier = part.trim();
-		if (!specifier) continue;
-		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
-		const local = (aliased?.[1] ?? specifier).trim();
-		const exported = (aliased?.[2] ?? specifier).trim();
-		if (!isIdentifier(local) || !isIdentifier(exported)) return void 0;
-		locals.push(local);
-	}
-	return locals;
-}
-function parseExportSpecifiers(value) {
-	const specifiers = [];
-	for (const part of value.split(",")) {
-		const specifier = part.trim();
-		if (!specifier) continue;
-		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
-		const local = (aliased?.[1] ?? specifier).trim();
-		const exported = (aliased?.[2] ?? specifier).trim();
-		if (!isIdentifier(local) || !isIdentifier(exported)) return void 0;
-		specifiers.push({
-			local,
-			exported
-		});
-	}
-	return specifiers;
-}
-function formatExportSpecifier(specifier) {
-	return specifier.local === specifier.exported ? specifier.local : `${specifier.local} as ${specifier.exported}`;
-}
-function uniqueIdentifier(base, code) {
-	let candidate = base;
-	let index = 0;
-	while (identifierNameRE(candidate).test(code)) {
-		index++;
-		candidate = `${base}${index}`;
-	}
-	return candidate;
-}
-function isIdentifier(value) {
-	return /^[$A-Z_a-z][$\w]*$/.test(value);
-}
-function normalizeVirtualId$2(id) {
-	return id.startsWith("\0") ? id.slice(1) : id;
-}
-//#endregion
-//#region ../web/src/debug-channel.ts
-function installDebugChannelLayer(root, initialPhase, initiallyActive = true) {
-	const global = globalThis;
-	const previous = global.__MARKLESS_DEBUG__?.version === 1 ? global.__MARKLESS_DEBUG__ : void 0;
-	let priorRoot;
-	try {
-		priorRoot = previous?.explainInteraction(root, "__markless_debug_root__");
-	} catch {}
-	const priorContainer = priorRoot && "containerId" in priorRoot ? previous?.containers.find((entry) => entry.id === priorRoot.containerId) : void 0;
-	const seed = `${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-	const id = priorContainer?.id ?? `container:${seed}`;
-	const rootKey = priorContainer?.root.key ?? `root:${seed}`;
-	const rootRef = new WeakRef(root);
-	const events = /* @__PURE__ */ new WeakMap();
-	const keys = /* @__PURE__ */ new WeakMap();
-	const invalidated = /* @__PURE__ */ new WeakSet();
-	const routerSources = global[Symbol.for("markless.debug.channel.v1.router-sources")] ??= /* @__PURE__ */ new Set();
-	const ownViolations = [];
-	let phase = initialPhase;
-	let lifecycle = initiallyActive ? "active" : "registered";
-	let boundarySnapshots = Object.freeze([]);
-	let nextElement = 1;
-	let nextSequence = (previous?.violations.at(-1)?.sequence ?? 0) + 1;
-	let dropped = 0;
-	let pruned = false;
-	const freeze = (value) => Object.freeze(value);
-	const contains = (element) => {
-		const currentRoot = rootRef.deref();
-		return !!currentRoot && (currentRoot === element || currentRoot.contains?.(element) === true);
-	};
-	const keyFor = (element) => {
-		let key = keys.get(element);
-		if (!key) {
-			key = `${rootKey}:element:${nextElement++}`;
-			keys.set(element, key);
-		}
-		return key;
-	};
-	const eligibleAnchor = (element) => {
-		const anchor = element.closest?.("a[href]");
-		if (!anchor?.hasAttribute("data-markless-router-link") || anchor.hasAttribute("download")) return false;
-		const target = anchor.getAttribute("target");
-		if (target && target !== "_self" || anchor.relList?.contains("external")) return false;
-		try {
-			const base = global.location?.href ?? "http://localhost/";
-			return new URL(anchor.href ?? "", base).origin === new URL(base).origin;
-		} catch {
-			return false;
-		}
-	};
-	const none = (element, eventName, reason) => freeze({
-		kind: "none",
-		eventName,
-		reason,
-		containerId: id,
-		elementKey: keyFor(element)
-	});
-	const explain = (element, eventName) => {
-		if (lifecycle === "disposed" && (contains(element) || keys.has(element))) return none(element, eventName, "container-disposed");
-		if (!contains(element)) try {
-			return previous?.explainInteraction(element, eventName) ?? freeze({
-				kind: "none",
-				eventName,
-				reason: "outside-known-container"
-			});
-		} catch {
-			return freeze({
-				kind: "none",
-				eventName,
-				reason: "outside-known-container"
-			});
-		}
-		if (element.isConnected === false) return none(element, eventName, "element-disconnected");
-		if (eligibleAnchor(element)) {
-			const source = eventName === "navigate" && routerSources.has("navigation-event") ? "navigation-event" : eventName === "click" && routerSources.has("spa-click-listener") ? "spa-click-listener" : eventName === "click" && routerSources.has("ssr-link-bridge") ? "ssr-link-bridge" : void 0;
-			if (source) return freeze({
-				kind: "router-delegation",
-				source,
-				containerId: id,
-				elementKey: keyFor(element),
-				eventName
-			});
-		}
-		const interaction = events.get(element)?.get(eventName);
-		if (interaction) return freeze({ ...interaction });
-		if (invalidated.has(element)) return none(element, eventName, "not-registered");
-		try {
-			const prior = previous?.explainInteraction(element, eventName);
-			if (prior && prior.kind !== "none") return prior;
-		} catch {}
-		return none(element, eventName, "not-registered");
-	};
-	const cloneJson = (value, seen = /* @__PURE__ */ new Set()) => {
-		if (value === null) return null;
-		if (typeof value === "boolean" || typeof value === "string") return value;
-		if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
-		if (!value || typeof value !== "object" || seen.has(value)) return void 0;
-		seen.add(value);
-		if (Array.isArray(value)) {
-			const copy = value.map((entry) => cloneJson(entry, seen));
-			return copy.some((entry) => entry === void 0) ? void 0 : freeze(copy);
-		}
-		if (Object.getPrototypeOf(value) !== Object.prototype) return void 0;
-		const copy = {};
-		for (const [name, entry] of Object.entries(value)) {
-			const cloned = cloneJson(entry, seen);
-			if (cloned === void 0) return void 0;
-			copy[name] = cloned;
-		}
-		return freeze(copy);
-	};
-	const pushViolation = (input) => {
-		const cloned = input.details === void 0 ? void 0 : cloneJson(input.details);
-		const details = cloned && !Array.isArray(cloned) && typeof cloned === "object" ? cloned : void 0;
-		const { details: _details, ...metadata } = input;
-		ownViolations.push(freeze({
-			...metadata,
-			...details ? { details } : {},
-			sequence: nextSequence++,
-			timestamp: Date.now()
-		}));
-		if (input.details !== void 0 && !details) ownViolations.push(freeze({
-			code: "MARKLESS_DEBUG_DETAILS_DROPPED",
-			message: "Debug violation details were not JSON-safe and were dropped.",
-			sequence: nextSequence++,
-			timestamp: Date.now()
-		}));
-		while (ownViolations.length > 100) {
-			ownViolations.shift();
-			dropped++;
-		}
-	};
-	const channel = freeze({
-		version: 1,
-		get containers() {
-			const inherited = previous?.containers.filter((entry) => entry.id !== id) ?? [];
-			if (pruned || lifecycle === "disposed") return freeze([...inherited]);
-			const currentRoot = rootRef.deref();
-			const connected = !!currentRoot && currentRoot.isConnected !== false;
-			const snapshot = freeze({
-				id,
-				phase,
-				lifecycle: connected ? lifecycle : "disposed",
-				root: freeze({
-					key: rootKey,
-					connected
-				}),
-				boundaries: freeze([...boundarySnapshots])
-			});
-			if (!connected) pruned = true;
-			return freeze([...inherited, snapshot]);
-		},
-		get violations() {
-			return freeze([...previous?.violations ?? [], ...ownViolations].slice(-100));
-		},
-		violationCapacity: 100,
-		get droppedViolationCount() {
-			return (previous?.droppedViolationCount ?? 0) + dropped;
-		},
-		explainInteraction: explain
-	});
-	Object.defineProperty(global, "__MARKLESS_DEBUG__", {
-		configurable: true,
-		enumerable: false,
-		value: channel,
-		writable: false
-	});
-	return {
-		start(nextPhase, active = true) {
-			phase = nextPhase === "ssr-resume" && phase === "csr" ? "csr" : nextPhase;
-			if (active) lifecycle = "active";
-			return id;
-		},
-		activate: () => void (lifecycle === "disposed" || (lifecycle = "active")),
-		dispose() {
-			lifecycle = "disposed";
-			boundarySnapshots = freeze([]);
-		},
-		invalidate(element) {
-			events.delete(element);
-			invalidated.add(element);
-		},
-		record(element, eventName, input) {
-			if (lifecycle === "disposed") return;
-			let byName = events.get(element);
-			if (!byName) events.set(element, byName = /* @__PURE__ */ new Map());
-			const symbolIds = "symbolIds" in input ? freeze([...input.symbolIds]) : void 0;
-			byName.set(eventName, freeze({
-				...input,
-				...symbolIds ? { symbolIds } : {},
-				containerId: id,
-				elementKey: keyFor(element),
-				eventName
-			}));
-		},
-		violation: pushViolation,
-		router: (source) => void routerSources.add(source),
-		boundaries(value) {
-			boundarySnapshots = freeze(value.map((entry) => freeze({ ...entry })));
-		},
-		disposed: () => lifecycle === "disposed"
-	};
-}
-function __marklessDebugBootstrapSource() {
-	return `((root,phase,active)=>{const controls=(${installDebugChannelLayer.toString()})(root,phase,active);return Object.freeze({record:(element,eventName,input)=>controls.record(element,eventName,input),router:(source)=>controls.router(source),activate:()=>controls.activate()})})`;
-}
-//#endregion
-//#region src/inline-resumer.ts
-let oxcToolsPromise;
-const compiledSources = /* @__PURE__ */ new Map();
-function loadOxcTools() {
-	oxcToolsPromise ??= import("rolldown/experimental").then(({ minifySync, transformSync }) => ({
-		minifySync,
-		transformSync
-	}));
-	return oxcToolsPromise;
-}
-function compileInlineResumerSources(options) {
-	const cacheKey = `${options.debug ? "debug" : "production"}:${options.executionLog}`;
-	let compiled = compiledSources.get(cacheKey);
-	if (!compiled) {
-		compiled = compileInlineResumerSourceVariants(options);
-		compiledSources.set(cacheKey, compiled);
-	}
-	return compiled;
-}
-async function compileInlineResumerSourceVariants(options) {
-	const shared = {
-		debug: options.debug,
-		executionLog: options.executionLog
-	};
-	const [event, syncPolicy, graphSyncPolicyOwner, graphSyncPolicyConsumer] = await Promise.all([
-		compileInlineResumerSource({
-			...shared,
-			graphSyncPolicy: false,
-			sharedGraphPolicy: false,
-			syncPolicy: false
-		}),
-		compileInlineResumerSource({
-			...shared,
-			graphSyncPolicy: false,
-			sharedGraphPolicy: false,
-			syncPolicy: true
-		}),
-		compileInlineResumerSource({
-			...shared,
-			graphSyncPolicy: true,
-			sharedGraphPolicy: true,
-			syncPolicy: true
-		}),
-		compileInlineResumerSource({
-			...shared,
-			graphSyncPolicy: true,
-			sharedGraphPolicy: false,
-			syncPolicy: true
-		})
-	]);
-	return {
-		...shared,
-		event,
-		syncPolicy,
-		graphSyncPolicyOwner,
-		graphSyncPolicyConsumer
-	};
-}
-async function compileInlineResumerSource(options) {
-	const source = createInlineResumerSource({
-		...options,
-		...options.debug ? {
-			debugBootstrapSource: __marklessDebugBootstrapSource(),
-			debugRegistrationSource: createInlineResumerDebugRegistrationSource()
-		} : {}
-	});
-	const { minifySync, transformSync } = await loadOxcTools();
-	const transformed = transformSync("markless-inline-resumer.js", source, {
-		lang: "js",
-		sourceType: "script",
-		target: "es2020"
-	});
-	assertOxcResult("transform", transformed.errors);
-	const minified = minifySync("markless-inline-resumer.js", transformed.code, {
-		compress: true,
-		mangle: { toplevel: true },
-		module: false
-	});
-	assertOxcResult("minify", minified.errors);
-	return minified.code.trim();
-}
-function assertOxcResult(phase, errors) {
-	if (errors.length === 0) return;
-	throw new Error(`MARKLESS_INLINE_RESUMER_${phase.toUpperCase()}_FAILED:\n${errors.map((error) => error.message).join("\n")}`);
-}
-//#endregion
-//#region src/transform.ts
-let oxcTransformSyncPromise;
-function loadOxcTransformSync() {
-	oxcTransformSyncPromise ??= import("rolldown/experimental").then((mod) => mod.transformSync, () => void 0);
-	return oxcTransformSyncPromise;
-}
-async function stripEmittedTypes(code) {
-	const oxcTransformSync = await loadOxcTransformSync();
-	if (!oxcTransformSync) return code;
-	try {
-		const out = oxcTransformSync("markless-emitted.ts", code);
-		if (!out.code || (out.errors?.length ?? 0) > 0) return code;
-		return out.code;
-	} catch {
-		return code;
-	}
-}
-async function transformTsrxModule(input) {
-	const encodedFilename = encodeURIComponent(input.filename);
-	const payloadId = `${MARKLESS_VIRTUAL_PREFIX}payload:${encodedFilename}`;
-	const resolverId = `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodedFilename}`;
-	const resumeId = resumeVirtualModuleId(input.filename);
-	const { compiled, blockingDiagnostics } = await compileWithBlockingDiagnostics(input, resolverId);
-	throwIfBlocked(input, blockingDiagnostics);
-	const symbolRows = compiled.symbolModules.modules.map((module) => ({
-		id: module.symbolId,
-		chunk: symbolVirtualModuleId(input.filename, module.symbolId),
-		exportName: scopedSymbolExportName(input.filename, module.exportName)
-	}));
-	const importedBoundRows = compiled.boundSymbolResolver.rows.map((row) => row.loaderSymbolId ? {
-		...row,
-		baseSymbolId: row.loaderSymbolId
-	} : row);
-	const resolverSource = adaptImportedCaptureResolver(emitSymbolResolverModule({
-		buildId: input.buildId,
-		symbols: uniqueSymbolsById([...input.symbols ?? [], ...symbolRows]),
-		boundSymbols: importedBoundRows
-	}), importedBoundRows.some((row) => row.loaderSymbolId !== void 0));
-	const symbolRoutes = compiled.semanticGraph.componentEdges.flatMap((edge, index) => edge.importSource ? [{
-		prefix: `c${index}:`,
-		importSource: edge.importSource,
-		componentEdgeId: edge.id
-	}] : []);
-	const executionLogModuleHookMode = input.executionLogModuleHooks === false ? "never" : input.executionLog;
-	const manifest = {
-		source: input.filename,
-		captureMetadata: compiled.captureAnalysis,
-		symbolRoutes,
-		payload: { virtualModuleId: payloadId },
-		resolver: { virtualModuleId: resolverId },
-		symbols: compiled.symbolModules.modules.map((module, index) => ({
-			symbolId: module.symbolId,
-			kind: module.kind,
-			exportName: symbolRows[index].exportName,
-			virtualModuleId: symbolVirtualModuleId(input.filename, module.symbolId)
-		})),
-		runtimeDemandMap: compiled.runtimeDemandMap
-	};
-	const styleScope = compiled.publicRenderPlan.styleScopes[0];
-	const styleId = styleScope ? `${MARKLESS_VIRTUAL_PREFIX}style:${encodedFilename}.css` : null;
-	const virtualModules = [
-		...styleScope && styleId ? [{
-			id: styleId,
-			type: "style",
-			source: styleScope.cssText
-		}] : [],
-		{
-			id: payloadId,
-			type: "payload",
-			source: payloadModule({
-				...compiled.payloadScripts,
-				runtimeDemandMap: compiled.runtimeDemandMap
-			})
-		},
-		{
-			id: resolverId,
-			type: "resolver",
-			source: resolverSource
-		},
-		{
-			id: resumeId,
-			type: "resume",
-			source: emitResumeModule({
-				payloadId,
-				resolverId,
-				payloadState: compiled.payloadScripts.state,
-				payloadView: containerScopedResumeView(compiled.payloadScripts.view),
-				runtimeDemandMap: compiled.runtimeDemandMap,
-				executionLog: input.executionLog,
-				needsFullResume: needsFullResume(compiled.protocolState, compiled.protocolView, compiled.runtimeDemandMap),
-				hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
-				symbols: symbolRows,
-				symbolRoutes
-			})
-		},
-		...await Promise.all(compiled.symbolModules.modules.map(async (module, index) => ({
-			id: symbolVirtualModuleId(input.filename, module.symbolId),
-			type: "symbol",
-			symbolId: module.symbolId,
-			exportName: symbolRows[index].exportName,
-			source: injectExecutionLogModuleHook(await stripEmittedTypes(rewriteSymbolModuleExport(module.source, module.exportName, symbolRows[index].exportName)), `symbol:${module.symbolId}`, executionLogModuleHookMode)
-		})))
-	];
-	const styleImport = styleId ? `import ${JSON.stringify(styleId)};\n` : "";
-	const inlineResumerSources = (input.environment ?? "lib") === "client" ? void 0 : await compileInlineResumerSources({
-		debug: input.inlineResumerDebug === true,
-		executionLog: input.executionLog ?? "never"
-	});
-	const headInjections = [...input.headInjections ?? [], ...styleId && input.styleModuleUrl ? [{
-		tag: "link",
-		location: "head",
-		attributes: {
-			rel: "stylesheet",
-			href: input.styleModuleUrl(styleId)
-		}
-	}] : []];
-	const storageSeeds = compiled.payloadArena.state.storage.map((storage) => {
-		const binding = compiled.semanticGraph.graphBindings.find((candidate) => candidate.id === storage.graphNodeId);
-		if (typeof binding?.initialValue !== "string") throw new Error(`MARKLESS_STORAGE_SEED_FALLBACK_MISSING: ${storage.graphNodeId} has no static string fallback.`);
-		return createStorageSeedMetadataFromGraphNodeId(storage.graphNodeId, storage.key, binding.initialValue);
-	});
-	return {
-		code: styleImport + await stripEmittedTypes(emitSourceModule({
-			filename: input.filename,
-			payloadId,
-			resolverId,
-			environment: input.environment ?? "lib",
-			clientOutput: input.clientOutput ?? "full",
-			executionLog: input.executionLog,
-			headInjections: headInjections.length > 0 ? headInjections : void 0,
-			storageSeeds: storageSeeds.length > 0 ? storageSeeds : void 0,
-			inlineResumerSources,
-			devResumeReexport: input.devResumeReexport === true,
-			needsFullResume: needsFullResume(compiled.protocolState, compiled.protocolView, compiled.runtimeDemandMap),
-			resumeModuleUrl: input.resumeModuleUrl,
-			publicRenderModuleSource: compiled.publicRenderModule.moduleSource,
-			publicRenderRootExportName: compiled.publicRenderModule.rootExportName,
-			publicCsrModuleSource: compiled.publicRenderModule.csrModuleSource,
-			publicRenderCsrExportName: compiled.publicRenderModule.csrExportName,
-			publicSsrModuleSource: compiled.publicRenderModule.ssrModuleSource,
-			publicRenderSsrExportName: compiled.publicRenderModule.ssrExportName,
-			hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
-			symbols: symbolRows,
-			symbolRoutes
-		})),
-		map: null,
-		virtualModules,
-		manifest
-	};
-}
-async function preflightTsrxModuleDiagnostics(input) {
-	const { blockingDiagnostics } = await compileWithBlockingDiagnostics(input, `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodeURIComponent(input.filename)}`);
-	throwIfBlocked(input, blockingDiagnostics);
-}
-async function compileWithBlockingDiagnostics(input, resolverId) {
-	const compiled = await compileTsrxModule({
-		filename: input.filename,
-		source: input.source,
-		buildId: input.buildId,
-		resolverId,
-		symbols: input.symbols ?? []
-	});
-	return {
-		compiled,
-		blockingDiagnostics: collectTsrxModuleDiagnostics(compiled).filter((diagnostic) => diagnostic.severity === "error")
-	};
-}
-function throwIfBlocked(input, blockingDiagnostics) {
-	if (blockingDiagnostics.length === 0) return;
-	const details = formatBlockedCompileError(input, blockingDiagnostics);
-	throw new MarklessCompileError(createCompileErrorPayload({
-		filename: input.filename,
-		source: input.source,
-		diagnostics: blockingDiagnostics,
-		details
-	}));
-}
-function formatBlockedCompileError(input, diagnostics) {
-	return [`MARKLESS_COMPILE_BLOCKED: ${input.filename} has ${diagnostics.length} compiler error(s).`, ...diagnostics.map((diagnostic) => {
-		const position = diagnostic.primarySpan ? formatSourcePosition(input.source, diagnostic.primarySpan.start) : void 0;
-		const location = position ? ` (${diagnostic.primarySpan.filename}:${position.line}:${position.column})` : "";
-		return [
-			`${diagnostic.code}: ${diagnostic.message}${location}`,
-			diagnostic.why,
-			diagnostic.suggestions[0]?.message,
-			diagnostic.docsUrl
-		].filter((line) => Boolean(line)).join("\n");
-	})].join("\n\n");
-}
-function formatSourcePosition(source, start) {
-	const sourceBeforeSpan = source.slice(0, start);
-	const lastLineBreak = sourceBeforeSpan.lastIndexOf("\n");
-	return {
-		line: sourceBeforeSpan.split("\n").length,
-		column: sourceBeforeSpan.length - lastLineBreak
-	};
-}
-function uniqueSymbolsById(symbols) {
-	return [...new Map(symbols.map((symbol) => [symbol.id, symbol])).values()];
-}
-function adaptImportedCaptureResolver(source, hasImportedRows) {
-	if (!hasImportedRows) return source;
-	const original = "	return (context) => base({ ...context, capture: createCaptureContext(context, bound) });";
-	const replacement = [
-		"	return async (context) => {",
-		"		const pendingCallbacks = [];",
-		"		const capture = createCaptureContext(context, bound);",
-		"		const result = await base({ ...context, graph: createBoundGraph(context, bound, capture, pendingCallbacks), capture });",
-		"		await Promise.all(pendingCallbacks);",
-		"		return result;",
-		"	};"
-	].join("\n");
-	const helper = [
-		"function createBoundGraph(context, bound, capture, pendingCallbacks) {",
-		"	const legacySlots = new Map(bound.captureSlots.flatMap((slot) => slot.legacyGraphRead ? [[JSON.stringify([slot.legacyGraphRead.graphNodeId, slot.legacyGraphRead.path ?? []]), slot]] : []));",
-		"	return {",
-		"		...context.graph,",
-		"		read(graphNodeId, path = []) {",
-		"			const slot = legacySlots.get(JSON.stringify([graphNodeId, path]));",
-		"			if (!slot) return context.graph.read(graphNodeId, path);",
-		"			if (slot.route.kind === callbackRoute) return (...args) => {",
-		"				const pending = context.invokeSymbol(slot.route.callbackSymbolId, { ...context, event: context.event, args });",
-		"				pendingCallbacks.push(Promise.resolve(pending));",
-		"				return pending;",
-		"			};",
-		"			return capture.read(slot.slotId);",
-		"		},",
-		"	};",
-		"}",
-		""
-	].join("\n");
-	return source.replace(original, replacement).replace("function createCaptureContext(context, bound) {", `${helper}function createCaptureContext(context, bound) {`);
-}
-function containerScopedResumeView(view) {
-	return {
-		...view,
-		locators: (view.locators ?? []).map((locator) => ({
-			...locator,
-			index: locator.index + 1
-		}))
-	};
-}
-function needsFullResume(state, view, runtimeDemandMap) {
-	if ((state.storage?.length ?? 0) > 0) return true;
-	if ((view.branches?.length ?? 0) > 0) return true;
-	if ((view.elementHandles?.length ?? 0) > 0) return true;
-	if ((view.asyncBoundaries?.length ?? 0) > 0) return true;
-	if ((view.keyedRepeats?.length ?? 0) === 0) return false;
-	return !recordKindReplaced(runtimeDemandMap, "keyed-repeat");
-}
-function recordKindReplaced(runtimeDemandMap, kind) {
-	return runtimeDemandMap.recordKinds.some((record) => record.kind === kind && record.replaced === true);
-}
-//#endregion
-//#region src/build/symbol-table.ts
-const SYMBOL_VIRTUAL_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}symbol:`;
-const PACKED_SYMBOL_VIRTUAL_LIST_RE = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1\.split\(\s*(["'`]),\3\s*\)/g;
-const SYMBOL_VIRTUAL_STRING_RE$1 = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1/g;
-const STRING_LIST_SOURCE = String.raw`(?:\[[^\]]*\]|["'\x60][^"'\x60]*["'\x60]\.split\(\s*["'\x60][^"'\x60]*["'\x60]\s*\))`;
-const SYMBOL_MANIFEST_TUPLE_RE = new RegExp(String.raw`(\[1,(?:null|["'\x60][^"'\x60]*["'\x60]),(?:null|["'\x60][^"'\x60]*["'\x60]),)(${STRING_LIST_SOURCE}),(${STRING_LIST_SOURCE}),(\{[^}]*\})(\])`, "g");
-const STRING_LITERAL_RE = /(["'`])([^"'`]*)\1/g;
-const SYMBOL_ROW_RE = /((?:["'`][^"'`]*["'`])\s*:\s*\[)(\d+)(,\s*\d+\])/g;
-const SYMBOL_ROW_CAPTURE_RE = /(["'`])([^"'`]*)\1\s*:\s*\[(\d+),\s*(\d+)\]/g;
-function rewriteGeneratedSymbolTableUrls(bundle) {
-	const chunks = collectChunks(bundle);
-	const symbolFiles = collectGeneratedSymbolFiles(chunks);
-	let rewritten = 0;
-	const unresolved = /* @__PURE__ */ new Set();
-	for (const chunk of chunks.values()) {
-		if (!chunk.code.includes(SYMBOL_VIRTUAL_PREFIX)) continue;
-		const result = rewriteSymbolVirtualStrings(chunk, symbolFiles);
-		chunk.code = result.code;
-		rewritten += result.rewritten;
-		for (const id of result.unresolved) unresolved.add(id);
-	}
-	return {
-		rewritten,
-		unresolved: [...unresolved].sort()
-	};
-}
-/**
-* Checks emitted resolver routes against compiler manifests and Rolldown's
-* chunk ownership/export metadata. Table source is read only to recover each
-* claimed file; termination evidence stays structural.
-*/
-function verifyGeneratedSymbolTableRoutes(bundle, manifests) {
-	const chunks = collectChunks(bundle);
-	const errors = [];
-	let verified = 0;
-	for (const manifest of manifests) {
-		if (manifest.symbols.length === 0) continue;
-		const resolverChunk = findResolverRouteChunk(chunks, manifest.resolver.virtualModuleId, manifest.symbols);
-		const routeChunk = resolverChunk ?? findChunkForVirtualId(chunks, manifest.source);
-		if (!routeChunk) {
-			for (const symbol of manifest.symbols) errors.push({
-				symbolId: symbol.symbolId,
-				claimedChunk: "<missing route chunk>",
-				reason: `neither compiler resolver ${manifest.resolver.virtualModuleId} nor source ${manifest.source} was emitted`
-			});
-			continue;
-		}
-		const table = resolverChunk ? findSymbolTable(routeChunk.code, manifest.symbols) : void 0;
-		for (const symbol of manifest.symbols) {
-			if (!table) {
-				const directRoute = verifyDirectRoute(chunks, routeChunk, symbol);
-				if (directRoute.reason) errors.push({
-					symbolId: symbol.symbolId,
-					claimedChunk: directRoute.claimedChunk,
-					reason: directRoute.reason
-				});
-				else verified++;
-				continue;
-			}
-			const specifier = tableRouteSpecifier(table, symbol, routeChunk.fileName, errors);
-			if (!specifier) continue;
-			const claimedChunk = resolveChunkSpecifier(routeChunk.fileName, specifier);
-			const reason = routeTerminationError(chunks, claimedChunk, symbol);
-			if (reason) errors.push({
-				symbolId: symbol.symbolId,
-				claimedChunk,
-				reason
-			});
-			else verified++;
-		}
-	}
-	return {
-		verified,
-		errors
-	};
-}
-function collectChunks(bundle) {
-	const chunks = /* @__PURE__ */ new Map();
-	for (const output of Object.values(bundle)) if (isGeneratedChunk(output)) chunks.set(output.fileName, output);
-	return chunks;
-}
-function collectGeneratedSymbolFiles(chunks) {
-	const symbolFiles = /* @__PURE__ */ new Map();
-	for (const chunk of chunks.values()) {
-		const facadeId = chunk.facadeModuleId ? normalizeVirtualId$1(chunk.facadeModuleId) : void 0;
-		if (facadeId?.startsWith(SYMBOL_VIRTUAL_PREFIX)) symbolFiles.set(facadeId, chunk.fileName);
-	}
-	for (const chunk of chunks.values()) for (const id of chunk.moduleIds.map(normalizeVirtualId$1)) if (id.startsWith(SYMBOL_VIRTUAL_PREFIX) && !symbolFiles.has(id)) symbolFiles.set(id, chunk.fileName);
-	return symbolFiles;
-}
-function findSymbolTable(code, symbols) {
-	let bestMatch;
-	let bestScore = -1;
-	for (const match of code.matchAll(SYMBOL_MANIFEST_TUPLE_RE)) {
-		const moduleUrls = parseStringList(match[2]);
-		const exportNames = parseStringList(match[3]);
-		if (!moduleUrls || !exportNames) continue;
-		const rows = /* @__PURE__ */ new Map();
-		for (const row of match[4].matchAll(SYMBOL_ROW_CAPTURE_RE)) rows.set(row[2], [Number(row[3]), Number(row[4])]);
-		if (rows.size === 0) continue;
-		const score = symbols.filter((symbol) => exportNames.includes(symbol.exportName)).length;
-		if (score > bestScore) {
-			bestMatch = {
-				moduleUrls,
-				exportNames,
-				rows
-			};
-			bestScore = score;
-		}
-	}
-	return bestMatch;
-}
-function tableRouteSpecifier(table, symbol, resolverFileName, errors) {
-	const row = table.rows.get(symbol.symbolId);
-	if (!row) {
-		errors.push({
-			symbolId: symbol.symbolId,
-			claimedChunk: resolverFileName,
-			reason: "emitted symbol table has no row for this compiler symbol"
-		});
-		return;
-	}
-	const specifier = table.moduleUrls[row[0]];
-	if (!specifier) {
-		errors.push({
-			symbolId: symbol.symbolId,
-			claimedChunk: resolverFileName,
-			reason: `emitted symbol table references missing module URL index ${row[0]}`
-		});
-		return;
-	}
-	const exportName = table.exportNames[row[1]];
-	if (exportName !== symbol.exportName) {
-		errors.push({
-			symbolId: symbol.symbolId,
-			claimedChunk: resolveChunkSpecifier(resolverFileName, specifier),
-			reason: `emitted symbol table claims export ${exportName ?? `<missing index ${row[1]}>`} instead of ${symbol.exportName}`
-		});
-		return;
-	}
-	return specifier;
-}
-function verifyDirectRoute(chunks, routeChunk, symbol) {
-	const target = findChunkForVirtualId(chunks, symbol.virtualModuleId);
-	if (!target) return {
-		claimedChunk: "<missing symbol chunk>",
-		reason: `generated symbol module ${symbol.virtualModuleId} was not emitted`
-	};
-	if (!(target.exports ?? []).includes(symbol.exportName)) return {
-		claimedChunk: target.fileName,
-		reason: `claimed chunk does not export ${symbol.exportName}`
-	};
-	if (!dynamicRouteReachesChunk(chunks, routeChunk, target.fileName) && !rewrittenSpecifierRoutesTo(routeChunk, target.fileName)) return {
-		claimedChunk: target.fileName,
-		reason: `source chunk ${routeChunk.fileName} has no emitted dynamic route to the claimed chunk`
-	};
-	return { claimedChunk: target.fileName };
-}
-function rewrittenSpecifierRoutesTo(routeChunk, targetFileName) {
-	const specifier = relativeChunkSpecifier(routeChunk.fileName, targetFileName);
-	return routeChunk.code.includes(JSON.stringify(specifier)) || routeChunk.code.includes(`'${specifier}'`) || routeChunk.code.includes(`\`${specifier}\``);
-}
-function dynamicRouteReachesChunk(chunks, start, targetFileName) {
-	const pending = [start];
-	const visited = /* @__PURE__ */ new Set();
-	while (pending.length > 0) {
-		const chunk = pending.shift();
-		if (chunk.fileName === targetFileName) return true;
-		if (visited.has(chunk.fileName)) continue;
-		visited.add(chunk.fileName);
-		for (const importedFileName of chunk.dynamicImports ?? []) {
-			const imported = chunks.get(importedFileName);
-			if (imported) pending.push(imported);
-		}
-	}
-	return false;
-}
-function routeTerminationError(chunks, claimedChunk, symbol) {
-	const target = chunks.get(claimedChunk);
-	if (!target) return "claimed chunk was not emitted. markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package";
-	if (!chunkOrReexportChainContainsSymbol(chunks, target, normalizeVirtualId$1(symbol.virtualModuleId), symbol.exportName)) return `claimed chunk does not contain its generated symbol module ${symbol.virtualModuleId} or a live re-export chain to it. markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package`;
-	if (!(target.exports ?? []).includes(symbol.exportName)) return `claimed chunk does not export ${symbol.exportName}. markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package`;
-}
-function chunkOrReexportChainContainsSymbol(chunks, start, virtualId, exportName) {
-	const pending = [start];
-	const visited = /* @__PURE__ */ new Set();
-	while (pending.length > 0) {
-		const chunk = pending.shift();
-		if (visited.has(chunk.fileName)) continue;
-		visited.add(chunk.fileName);
-		if (virtualIds(chunk).includes(virtualId) && (chunk.exports ?? []).includes(exportName)) return true;
-		if (!(chunk.exports ?? []).includes(exportName)) continue;
-		for (const importedFileName of chunk.imports ?? []) {
-			const imported = chunks.get(importedFileName);
-			if (imported && (imported.exports ?? []).includes(exportName)) pending.push(imported);
-		}
-	}
-	return false;
-}
-function findChunkForVirtualId(chunks, virtualId) {
-	const normalized = normalizeVirtualId$1(virtualId);
-	return [...chunks.values()].find((chunk) => !!chunk.facadeModuleId && normalizeVirtualId$1(chunk.facadeModuleId) === normalized) ?? [...chunks.values()].find((chunk) => chunk.moduleIds.map(normalizeVirtualId$1).includes(normalized));
-}
-function findResolverRouteChunk(chunks, virtualId, symbols) {
-	const normalized = normalizeVirtualId$1(virtualId);
-	const candidates = [...chunks.values()].filter((chunk) => virtualIds(chunk).includes(normalized));
-	return candidates.find((chunk) => !!findSymbolTable(chunk.code, symbols)) ?? candidates.find((chunk) => chunk.moduleIds.map(normalizeVirtualId$1).includes(normalized)) ?? candidates[0];
-}
-function resolveChunkSpecifier(importerFileName, specifier) {
-	if (!specifier.startsWith(".")) return normalize(specifier);
-	return normalize(join(dirname(importerFileName), specifier));
-}
-function virtualIds(chunk) {
-	return [chunk.facadeModuleId ?? void 0, ...chunk.moduleIds].filter((id) => !!id).map(normalizeVirtualId$1);
-}
-function rewriteSymbolVirtualStrings(chunk, symbolFiles) {
-	let rewritten = 0;
-	const unresolved = /* @__PURE__ */ new Set();
-	return {
-		code: compactSymbolManifestTables(chunk.code.replace(PACKED_SYMBOL_VIRTUAL_LIST_RE, (match, _quote, packedVirtualIds) => {
-			const virtualIds = packedVirtualIds.split(",");
-			if (virtualIds.length < 2 || virtualIds.some((id) => !id.startsWith(SYMBOL_VIRTUAL_PREFIX))) return match;
-			return JSON.stringify(virtualIds.map((virtualId) => {
-				const fileName = symbolFiles.get(virtualId);
-				if (!fileName) return virtualId;
-				rewritten++;
-				return relativeChunkSpecifier(chunk.fileName, fileName);
-			}));
-		}).replace(SYMBOL_VIRTUAL_STRING_RE$1, (match, _quote, virtualId) => {
-			const fileName = symbolFiles.get(virtualId);
-			if (!fileName) {
-				unresolved.add(virtualId);
-				return match;
-			}
-			rewritten++;
-			return JSON.stringify(relativeChunkSpecifier(chunk.fileName, fileName));
-		})),
-		rewritten,
-		unresolved: [...unresolved]
-	};
-}
-function compactSymbolManifestTables(code) {
-	return code.replace(SYMBOL_MANIFEST_TUPLE_RE, (match, prefix, moduleUrlsSource, exportNamesSource, symbolRowsSource, suffix) => {
-		const moduleUrls = parseStringArray(moduleUrlsSource);
-		if (!moduleUrls) return match;
-		const nextModuleUrls = [];
-		const moduleIndexMap = /* @__PURE__ */ new Map();
-		const seen = /* @__PURE__ */ new Map();
-		for (const [index, moduleUrl] of moduleUrls.entries()) {
-			let nextIndex = seen.get(moduleUrl);
-			if (nextIndex === void 0) {
-				nextIndex = nextModuleUrls.length;
-				seen.set(moduleUrl, nextIndex);
-				nextModuleUrls.push(moduleUrl);
-			}
-			moduleIndexMap.set(index, nextIndex);
-		}
-		if (nextModuleUrls.length === moduleUrls.length) return match;
-		const nextSymbolRows = symbolRowsSource.replace(SYMBOL_ROW_RE, (rowMatch, rowPrefix, moduleIndexSource, rowSuffix) => {
-			const moduleIndex = Number(moduleIndexSource);
-			const nextModuleIndex = moduleIndexMap.get(moduleIndex);
-			if (nextModuleIndex === void 0) return rowMatch;
-			return `${rowPrefix}${nextModuleIndex}${rowSuffix}`;
-		});
-		return `${prefix}${JSON.stringify(nextModuleUrls)},${exportNamesSource},${nextSymbolRows}${suffix}`;
-	});
-}
-function parseStringArray(source) {
-	const values = [];
-	let end = 1;
-	for (const match of source.matchAll(STRING_LITERAL_RE)) {
-		values.push(match[2]);
-		end = (match.index ?? 0) + match[0].length;
-	}
-	if (source.slice(end).trim() !== "]") return void 0;
-	return values;
-}
-function parseStringList(source) {
-	if (source.startsWith("[")) return parseStringArray(source);
-	const packed = source.match(/^(["'`])([^"'`]*)\1\.split\(\s*(["'`])([^"'`]*)\3\s*\)$/);
-	return packed ? packed[2].split(packed[4]) : void 0;
-}
-function relativeChunkSpecifier(importerFileName, targetFileName) {
-	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
-	return value.startsWith(".") ? value : `./${value}`;
-}
-function isGeneratedChunk(value) {
-	if (!value || typeof value !== "object") return false;
-	const chunk = value;
-	return chunk.type === "chunk" && typeof chunk.fileName === "string" && typeof chunk.code === "string" && Array.isArray(chunk.moduleIds);
-}
-function normalizeVirtualId$1(id) {
-	return id.startsWith("\0") ? id.slice(1) : id;
-}
-//#endregion
-//#region src/dev.ts
-function createMarklessDevGraph() {
-	const parentModules = /* @__PURE__ */ new Map();
-	return {
-		record(parent, ids, environment) {
-			const entries = [...ids];
-			for (const path of parentKeys(parent)) {
-				const key = parentKey(environment, path);
-				const existing = parentModules.get(key) ?? /* @__PURE__ */ new Set();
-				for (const id of entries) existing.add(id);
-				parentModules.set(key, existing);
-			}
-		},
-		clear(parent, environment) {
-			const deleted = [];
-			for (const currentEnvironment of targetEnvironments(environment)) for (const path of parentKeys(parent)) {
-				const key = parentKey(currentEnvironment, path);
-				const ids = parentModules.get(key);
-				if (!ids) continue;
-				deleted.push(...ids);
-				parentModules.delete(key);
-			}
-			return [...new Set(deleted)];
-		},
-		reset() {
-			parentModules.clear();
-		}
-	};
-}
-function targetEnvironments(environment) {
-	if (environment) return [environment];
-	return allEnvironments;
-}
-const allEnvironments = [
-	"client",
-	"server",
-	"lib"
-];
-function parentKeys(parent) {
-	const path = pathname$1(parent);
-	const normalized = normalize(path);
-	const leadingPath = withLeadingSlash(normalized);
-	const barePath = leadingPath.slice(1);
-	return new Set([
-		path,
-		normalized,
-		leadingPath,
-		barePath
-	]);
-}
-function parentKey(environment, parent) {
-	return `${environment}:${parent}`;
-}
-function pathname$1(id) {
-	return parsePath(id).pathname;
-}
-//#endregion
-//#region src/rolldown.ts
-const TSRX_SOURCE_FILE = /\.tsrx(?:[?#].*)?$/;
-const MARKLESS_SYMBOL_SOURCE_QUERY_RE = /[?&]markless-symbols(?:[&#]|$)/;
-const MARKLESS_RESUME_SOURCE_QUERY_RE = /[?&]markless-resume(?:[&#]|$)/;
-const RESUME_VIRTUAL_ID_RE = /^virtual:markless:resume:([^:]+)$/;
-const SYMBOL_VIRTUAL_STRING_RE = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1/g;
-const marklessClient = (options = {}) => createMarklessRolldownPlugin({
-	environment: "client",
-	options
-});
-const marklessServer = (options = {}) => createMarklessRolldownPlugin({
-	environment: "server",
-	options
-});
-const marklessLib = (options = {}) => createMarklessRolldownPlugin({
-	environment: "lib",
-	options
-});
-function createMarklessRolldownPlugin(input) {
-	const environment = input.environment;
-	const internalOptions = input.options ?? {};
-	const virtualModules = /* @__PURE__ */ new Map();
-	const transformManifests = /* @__PURE__ */ new Map();
-	const importedChildren = /* @__PURE__ */ new Map();
-	const importedChildSources = /* @__PURE__ */ new Set();
-	const emittedClientResolverSources = /* @__PURE__ */ new Set();
-	const sourceVirtualModules = /* @__PURE__ */ new Map();
-	const clientSymbolEntrySources = /* @__PURE__ */ new Set();
-	const executionLogEstimatedSizes = /* @__PURE__ */ new Map();
-	const dev = createMarklessDevGraph();
-	let root = internalOptions.rootDir;
-	const name = pluginName(environment);
-	function getEnvironment(context) {
-		if (typeof environment === "function") return environment(context);
-		return environment;
-	}
-	function getRoot() {
-		return root ?? internalOptions.rootDir;
-	}
-	return {
-		api: { invalidateGeneratedModules(parent, currentEnvironment) {
-			const ids = dev.clear(parent, currentEnvironment);
-			const resolvedIds = /* @__PURE__ */ new Set();
-			for (const id of ids) {
-				const type = virtualModules.get(id)?.type;
-				virtualModules.delete(id);
-				const resolvedId = resolveVirtualId(id);
-				resolvedIds.add(resolvedId);
-				if (type === "style") resolvedIds.add(`${resolvedId}?direct`);
-			}
-			if ((currentEnvironment === "client" || currentEnvironment === void 0 && environment === "client") && internalOptions.dev === true && normalizeExecutionLogMode(internalOptions.executionLog) !== "never") resolvedIds.add(resolveVirtualId(MARKLESS_EXECUTION_LOG_MODULE_ID));
-			return [...resolvedIds];
-		} },
-		name,
-		options(input) {
-			if (getEnvironment(this) !== "client") return input;
-			return {
-				...input,
-				preserveEntrySignatures: input.preserveEntrySignatures ?? "allow-extension"
-			};
-		},
-		async buildStart(input) {
-			if (!root) root = internalOptions.rootDir ?? input.cwd;
-			clientSymbolEntrySources.clear();
-			virtualModules.clear();
-			transformManifests.clear();
-			importedChildren.clear();
-			importedChildSources.clear();
-			emittedClientResolverSources.clear();
-			sourceVirtualModules.clear();
-			executionLogEstimatedSizes.clear();
-			dev.reset();
-			const currentRoot = getRoot();
-			if (getEnvironment(this) === "client") for (const source of clientSymbolEntries(input.input, currentRoot)) clientSymbolEntrySources.add(source);
-		},
-		outputOptions(output) {
-			return outputDefaults(output, getEnvironment(this));
-		},
-		async resolveId(source, importer) {
-			if (source.startsWith("@markless/web/fns/")) {
-				const resolved = import.meta.resolve(source);
-				if (resolved?.startsWith("file://")) return { id: decodeURIComponent(resolved.slice(7)) };
-			}
-			if (source.startsWith("@markless/web/inline/")) {
-				const resolvedRoot = import.meta.resolve("@markless/web");
-				if (resolvedRoot?.startsWith("file://") && resolvedRoot.endsWith("/index.ts")) {
-					const helperPath = source.slice(14);
-					return { id: decodeURIComponent(resolvedRoot.slice(7, -8) + `${helperPath}.ts`) };
-				}
-			}
-			const normalized = normalizeVirtualId(source);
-			if (normalized === "virtual:markless:dev-log") return {
-				id: resolveVirtualId(MARKLESS_EXECUTION_LOG_MODULE_ID),
-				moduleSideEffects: true
-			};
-			const virtualModule = virtualModules.get(normalized);
-			if (virtualModule) {
-				const directQuery = virtualModule.type === "style" && /(?:[?&])direct(?:[=&]|$)/.test(source) ? "?direct" : "";
-				return {
-					id: `${resolveVirtualId(normalized)}${directQuery}`,
-					moduleSideEffects: true
-				};
-			}
-			const symbolSource = sourceForSymbolVirtualImporter(importer);
-			if (symbolSource && isRelativeImport(source)) return await this.resolve(source, symbolSource, { skipSelf: true });
-			const resumeSource = sourceForResumeVirtualImporter(importer);
-			if (resumeSource && isRelativeImport(source)) return await this.resolve(source, resumeSource, { skipSelf: true });
-			return null;
-		},
-		load(id) {
-			if (normalizeVirtualId(id) === "virtual:markless:dev-log") {
-				const embedsDevSizes = internalOptions.dev === true && getEnvironment(this) === "client";
-				return executionLogVirtualModuleSource({
-					moduleSizes: embedsDevSizes ? executionLogEstimatedSizes : void 0,
-					attribution: embedsDevSizes ? executionAttributionTables(transformManifests, getRoot(), importedChildren.values()) : void 0,
-					sizesUrl: internalOptions.dev === true ? void 0 : internalOptions.publicPath?.(MARKLESS_EXECUTION_SIZES) ?? `/${MARKLESS_EXECUTION_SIZES}`
-				});
-			}
-			const module = virtualModules.get(normalizeVirtualId(id));
-			if (module) return virtualModuleSourceForLoad(module, {
-				dev: internalOptions.dev === true && getEnvironment(this) === "client",
-				publicPath: internalOptions.publicPath
-			});
-			return null;
-		},
-		async transform(code, id) {
-			const currentEnvironment = getEnvironment(this);
-			const virtualId = normalizeVirtualId(id);
-			if (!TSRX_SOURCE_FILE.test(id)) {
-				if (currentEnvironment === "client" && internalOptions.dev === true && normalizeExecutionLogMode(internalOptions.executionLog) !== "never" && isMarklessRuntimeModule(id)) {
-					executionLogEstimatedSizes.set(executionLogRuntimeModuleId(id), code.length);
-					return {
-						code: injectExecutionLogModuleHook(code, executionLogRuntimeModuleId(id), internalOptions.executionLog),
-						map: null
-					};
-				}
-				return null;
-			}
-			if (virtualId.startsWith("virtual:markless:")) return null;
-			const source = pathname(id);
-			clearSourceVirtualModules(source, virtualModules, sourceVirtualModules);
-			let transformed = await transformTsrxModule({
-				filename: source,
-				source: code,
-				buildId: internalOptions.buildId,
-				executionLog: normalizeExecutionLogMode(internalOptions.executionLog),
-				executionLogModuleHooks: internalOptions.dev === true && currentEnvironment === "client",
-				inlineResumerDebug: internalOptions.inlineResumerDebug === true,
-				environment: currentEnvironment,
-				clientOutput: currentEnvironment === "client" && (clientSymbolEntrySources.has(source) || isSymbolOnlySourceRequest(id)) ? "symbols-only" : void 0,
-				resumeModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? devBrowserSourceModuleUrl(source, getRoot(), internalOptions.publicPath) : void 0,
-				styleModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? (virtualId) => withQuery(devBrowserVirtualModuleUrl(virtualId, internalOptions.publicPath), { direct: null }) : void 0,
-				headInjections: internalOptions.dev === true && currentEnvironment === "server" ? internalOptions.devInjections : void 0,
-				devResumeReexport: internalOptions.dev === true && currentEnvironment === "client"
-			});
-			registerTransformArtifacts({
-				source,
-				result: transformed,
-				virtualModules,
-				transformManifests,
-				sourceVirtualModules,
-				executionLogEstimatedSizes,
-				dev,
-				environment: currentEnvironment
-			});
-			const resolvedChildren = await resolveImportedChildren.call(this, source, transformed.manifest);
-			for (const child of resolvedChildren) {
-				importedChildren.set(importedChildKey(child), child);
-				importedChildSources.add(child.source);
-			}
-			for (const child of resolvedChildren) {
-				if (!transformManifests.has(child.source)) {
-					if (internalOptions.dev === true) await internalOptions.devServer?.transformRequest(child.source, currentEnvironment);
-					else if (typeof this.load === "function") await this.load({ id: child.source });
-				}
-				if (internalOptions.dev === true) validateImportedChild(child, transformManifests);
-			}
-			if (resolvedChildren.length > 0) transformed = await transformTsrxModule({
-				filename: source,
-				source: code,
-				buildId: internalOptions.buildId,
-				symbols: importedSymbolInputs(resolvedChildren, transformManifests),
-				executionLog: normalizeExecutionLogMode(internalOptions.executionLog),
-				executionLogModuleHooks: internalOptions.dev === true && currentEnvironment === "client",
-				inlineResumerDebug: internalOptions.inlineResumerDebug === true,
-				environment: currentEnvironment,
-				clientOutput: currentEnvironment === "client" && (clientSymbolEntrySources.has(source) || isSymbolOnlySourceRequest(id)) ? "symbols-only" : void 0,
-				resumeModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? devBrowserSourceModuleUrl(source, getRoot(), internalOptions.publicPath) : void 0,
-				styleModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? (virtualId) => withQuery(devBrowserVirtualModuleUrl(virtualId, internalOptions.publicPath), { direct: null }) : void 0,
-				headInjections: internalOptions.dev === true && currentEnvironment === "server" ? internalOptions.devInjections : void 0,
-				devResumeReexport: internalOptions.dev === true && currentEnvironment === "client"
-			});
-			registerTransformArtifacts({
-				source,
-				result: transformed,
-				virtualModules,
-				transformManifests,
-				sourceVirtualModules,
-				executionLogEstimatedSizes,
-				dev,
-				environment: currentEnvironment
-			});
-			for (const child of resolvedChildren) dev.record(child.source, [transformed.manifest.resolver.virtualModuleId], currentEnvironment);
-			if (currentEnvironment === "client" && isResumeSourceRequest(id)) {
-				const resumeModule = transformed.virtualModules.find((module) => module.type === "resume");
-				if (resumeModule) return {
-					code: resumeModule.source,
-					map: null
-				};
-			}
-			if (currentEnvironment === "client" && !internalOptions.dev) for (const module of transformed.virtualModules.filter((item) => {
-				if (item.type === "symbol") return true;
-				if (item.type === "resolver") return (importedChildSources.has(source) || (transformed.manifest.captureMetadata?.boundResolverRows?.length ?? 0) > 0) && !emittedClientResolverSources.has(source);
-				return item.type === "resume" && internalOptions.emitResumeModules === true && clientSymbolEntrySources.has(source);
-			})) {
-				this.emitFile({
-					type: "chunk",
-					id: module.id,
-					preserveSignature: "strict"
-				});
-				if (module.type === "resolver") emittedClientResolverSources.add(source);
-			}
-			return transformed;
-		},
-		generateBundle: {
-			order: "post",
-			async handler(_, bundle) {
-				for (const child of importedChildren.values()) validateImportedChild(child, transformManifests);
-				if (getEnvironment(this) !== "client") return;
-				stripEmptyPreloadWrappersFromChunks(bundle);
-				const removedSymbolFacades = rewriteGeneratedSymbolFacadeImports(bundle);
-				rewriteGeneratedSymbolInitExports(bundle);
-				compactGeneratedDirectSymbolLoaders(bundle);
-				const manifestBundle = bundleWithoutRemovedChunks(bundle, removedSymbolFacades);
-				const tableRewrite = rewriteGeneratedSymbolTableUrls(manifestBundle);
-				if (tableRewrite.unresolved.length > 0) this.error(`Markless symbol resolver table contains unresolved generated symbol chunks: ${tableRewrite.unresolved.join(", ")}. markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package`);
-				const tableIntegrity = verifyGeneratedSymbolTableRoutes(manifestBundle, transformManifests.values());
-				if (tableIntegrity.errors.length > 0) this.error(`Markless symbol resolver table integrity check failed:\n${tableIntegrity.errors.map((error) => `- ${error.symbolId} -> ${error.claimedChunk}: ${error.reason}`).join("\n")}`);
-				const clientManifest = createBuildMetadata(manifestBundle, transformManifests.values(), getRoot(), {
-					bundleGraphAsset: MARKLESS_BUNDLE_GRAPH,
-					bundleGraphAdders: internalOptions.bundleGraphAdders,
-					canonPath: stripBuildPrefix,
-					publicPath: internalOptions.publicPath,
-					injections: internalOptions.devInjections
-				});
-				const executionLogInjection = executionLogActivationInjection(internalOptions.executionLog);
-				if (executionLogInjection) injectHeadLinks(bundle, [executionLogInjection]);
-				injectHeadLinks(bundle, collectModulePreloadInjections(clientManifest, {
-					publicPath: internalOptions.publicPath,
-					entryChunks: Object.values(bundle).filter((output) => !!output && typeof output === "object" && output.type === "chunk" && output.isEntry === true).map((chunk) => stripBuildPrefix(chunk.fileName))
-				}));
-				this.emitFile({
-					type: "asset",
-					fileName: MARKLESS_BUNDLE_GRAPH,
-					source: JSON.stringify(clientManifest.bundleGraph)
-				});
-				this.emitFile(await createExecutionSizesAsset(manifestBundle, clientManifest, stripBuildPrefix, executionLogInjection ? executionAttributionTables(transformManifests, getRoot(), importedChildren.values()) : void 0));
-				this.emitFile({
-					type: "asset",
-					fileName: `${MARKLESS_BUILD_PREFIX}execution-demand.json`,
-					source: JSON.stringify(Object.fromEntries(clientManifest.modules.filter((module) => module.runtimeDemandMap).map((module) => [module.source, module.runtimeDemandMap])))
-				});
-			}
-		}
-	};
-}
-async function resolveImportedChildren(parent, manifest) {
-	return await Promise.all((manifest.symbolRoutes ?? []).map(async (route) => {
-		const resolvedImport = await this.resolve(route.importSource, parent, { skipSelf: true });
-		const resolvedId = typeof resolvedImport === "string" ? resolvedImport : resolvedImport && typeof resolvedImport === "object" && "id" in resolvedImport ? String(resolvedImport.id) : fallbackImportedSource(parent, route.importSource);
-		return {
-			parent,
-			specifier: route.importSource,
-			source: pathname(resolvedId),
-			componentEdgeId: route.componentEdgeId
-		};
-	}));
-}
-function importedSymbolInputs(children, manifests) {
-	return children.flatMap((child) => {
-		const manifest = manifests.get(child.source);
-		if (!manifest?.captureMetadata || !child.componentEdgeId) return [];
-		return manifest.symbols.flatMap((symbol) => {
-			const captureSymbol = manifest.captureMetadata?.extractedSymbols.find((candidate) => candidate.symbolId === symbol.symbolId);
-			return captureSymbol?.captureSlots.some((slot) => slot.propName !== void 0) ? [{
-				id: `imported:${encodeURIComponent(child.source)}:${symbol.symbolId}`,
-				chunk: symbol.virtualModuleId,
-				exportName: symbol.exportName,
-				componentEdgeId: child.componentEdgeId,
-				captureSymbol
-			}] : [];
-		});
-	});
-}
-function fallbackImportedSource(parent, specifier) {
-	const source = specifier.split("?")[0];
-	return isRelativeImport(source) ? resolve(dirname(parent), source) : source;
-}
-function importedChildKey(child) {
-	return `${child.parent}\0${child.specifier}\0${child.source}`;
-}
-function validateImportedChild(child, manifests) {
-	const parentMetadata = manifests.get(child.parent)?.captureMetadata;
-	const childMetadata = manifests.get(child.source)?.captureMetadata;
-	if (!childMetadata && isPlainTypeScriptSource(child.source)) return;
-	if (parentMetadata && childMetadata?.passId === parentMetadata.passId && Array.isArray(childMetadata.extractedSymbols) && Array.isArray(childMetadata.diagnostics)) return;
-	throw new Error(`MARKLESS_CAPTURE_METADATA_MISSING: Parent module ${JSON.stringify(child.parent)} composes imported child ${JSON.stringify(child.specifier)}, but its compiled artifact has no current capture metadata. Rebuild the child with the current Markless compiler and clear any stale build cache.`);
-}
-function isPlainTypeScriptSource(source) {
-	return /\.[cm]?tsx?$/.test(source);
-}
-function executionAttributionRoots(manifests, childrenByRoute) {
-	const children = /* @__PURE__ */ new Set();
-	for (const manifest of manifests.values()) for (const route of manifest.symbolRoutes ?? []) {
-		const child = resolvedRouteSource(manifest.source, route.importSource, childrenByRoute);
-		if (manifests.has(child)) children.add(child);
-	}
-	return [...manifests.keys()].filter((source) => !children.has(source));
-}
-function executionAttributionTables(manifests, root, children) {
-	const childrenByRoute = new Map([...children].map((child) => [routeKey(child.parent, child.specifier), child.source]));
-	return Object.fromEntries(executionAttributionRoots(manifests, childrenByRoute).sort().map((source) => [executionAttributionRouteKey(source, root), flattenExecutionAttributionScopes(source, manifests, childrenByRoute)]));
-}
-function executionAttributionRouteKey(source, root) {
-	const prefix = root ? `${root.replace(/[/\\]+$/, "")}/` : "";
-	return (prefix && source.startsWith(prefix) ? source.slice(prefix.length) : source).replace(/^[/\\]+/, "");
-}
-function flattenExecutionAttributionScopes(root, manifests, childrenByRoute) {
-	const scopes = {};
-	const visit = (source, scope, seen) => {
-		if (seen.has(source)) return;
-		scopes[scope] = encodedSymbolSource(source);
-		const manifest = manifests.get(source);
-		for (const route of manifest?.symbolRoutes ?? []) {
-			const child = resolvedRouteSource(source, route.importSource, childrenByRoute);
-			if (!manifests.has(child)) continue;
-			visit(child, scope + route.prefix, new Set([...seen, source]));
-		}
-	};
-	visit(root, "", /* @__PURE__ */ new Set());
-	return scopes;
-}
-function resolvedRouteSource(parent, specifier, childrenByRoute) {
-	return childrenByRoute.get(routeKey(parent, specifier)) ?? fallbackImportedSource(parent, specifier);
-}
-function routeKey(parent, specifier) {
-	return `${parent}\0${specifier}`;
-}
-function bundleWithoutRemovedChunks(bundle, removedFileNames) {
-	if (removedFileNames.size === 0) return bundle;
-	const next = {};
-	for (const [key, output] of Object.entries(bundle)) {
-		if (isChunkFile(output) && removedFileNames.has(output.fileName)) continue;
-		next[key] = output;
-	}
-	return next;
-}
-function stripEmptyPreloadWrappersFromChunks(bundle) {
-	for (const output of Object.values(bundle)) {
-		if (!isChunkWithCode(output)) continue;
-		const nextCode = stripEmptyVitePreloadWrappers(output.code);
-		if (nextCode !== output.code) output.code = nextCode;
-	}
-}
-function isChunkFile(output) {
-	if (!output || typeof output !== "object") return false;
-	const chunk = output;
-	return chunk.type === "chunk" && typeof chunk.fileName === "string";
-}
-function isChunkWithCode(output) {
-	if (!output || typeof output !== "object") return false;
-	const chunk = output;
-	return chunk.type === "chunk" && typeof chunk.code === "string";
-}
-function pluginName(environment) {
-	if (typeof environment === "function") return "markless:rolldown";
-	return `markless:rolldown:${environment}`;
-}
-function registerTransformArtifacts(input) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const module of input.result.virtualModules) {
-		const isClientSymbol = input.environment === "client" && module.type === "symbol";
-		const stored = isClientSymbol ? {
-			...module,
-			source: requalifyExecutionLogModuleHook(module.source, module.id)
-		} : module;
-		input.virtualModules.set(module.id, stored);
-		ids.add(module.id);
-		if (isClientSymbol) input.executionLogEstimatedSizes.set(module.id, stored.source.length);
-	}
-	input.transformManifests.set(input.source, input.result.manifest);
-	input.sourceVirtualModules.set(input.source, ids);
-	input.dev.record(input.source, ids, input.environment);
-}
-function clearSourceVirtualModules(source, virtualModules, sourceVirtualModules) {
-	const stale = sourceVirtualModules.get(source);
-	if (!stale) return;
-	for (const id of stale) virtualModules.delete(id);
-	sourceVirtualModules.delete(source);
-}
-function stripBuildPrefix(fileName) {
-	return fileName.startsWith(MARKLESS_BUILD_PREFIX) ? fileName.slice(MARKLESS_BUILD_PREFIX.length) : fileName;
-}
-function virtualModuleSourceForLoad(module, options) {
-	if (!options.dev || module.type !== "resolver") return module.source;
-	if (!module.source.includes("moduleUrls[row[0]]")) return module.source;
-	return module.source.replace(SYMBOL_VIRTUAL_STRING_RE, (_match, _quote, virtualId) => JSON.stringify(devBrowserVirtualModuleUrl(virtualId, options.publicPath)));
-}
-function devBrowserSourceModuleUrl(source, _root, publicPath) {
-	const path = withQuery(joinURL("@fs", withoutLeadingSlash(source)), { import: null });
-	return publicPath ? publicPath(path) : joinURL("/", path);
-}
-function devBrowserVirtualModuleUrl(virtualId, publicPath) {
-	const path = joinURL("@id", resolveVirtualId(virtualId).replace("\0", "__x00__"));
-	return publicPath ? publicPath(path) : joinURL("/", path);
-}
-function clientSymbolEntries(input, root) {
-	if (!input || typeof input !== "object" || Array.isArray(input)) return [];
-	const sources = [];
-	for (const [name, value] of Object.entries(input)) {
-		if (!/symbol/i.test(name)) continue;
-		for (const entry of inputEntryValues(value)) if (typeof entry === "string" && TSRX_SOURCE_FILE.test(entry)) sources.push(normalizeInputSource(entry, root));
-	}
-	return sources;
-}
-function inputEntryValues(value) {
-	return Array.isArray(value) ? value.flatMap(inputEntryValues) : [value];
-}
-function normalizeInputSource(source, root) {
-	const path = pathname(source);
-	if (isAbsolute(path)) return path;
-	return pathname(resolve(root ?? "", path));
-}
-function isSymbolOnlySourceRequest(id) {
-	return MARKLESS_SYMBOL_SOURCE_QUERY_RE.test(id);
-}
-function isResumeSourceRequest(id) {
-	return MARKLESS_RESUME_SOURCE_QUERY_RE.test(id);
-}
-function sourceForSymbolVirtualImporter(importer) {
-	if (!importer) return null;
-	return symbolVirtualModuleSourceFile(normalizeVirtualId(importer));
-}
-function sourceForResumeVirtualImporter(importer) {
-	if (!importer) return null;
-	const match = normalizeVirtualId(importer).match(RESUME_VIRTUAL_ID_RE);
-	return match?.[1] ? decodeURIComponent(match[1]) : null;
-}
-function isRelativeImport(source) {
-	return source.startsWith("./") || source.startsWith("../");
-}
-function isMarklessRuntimeModule(id) {
-	const path = pathname(id);
-	return /[/\\](?:web|runtime|serializer)[/\\]src[/\\].+\.ts$/.test(path);
-}
-function executionLogRuntimeModuleId(id) {
-	const path = pathname(id);
-	const match = path.match(/[/\\](web|runtime|serializer)[/\\]src[/\\]([^?#]+)\.ts$/);
-	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : path;
-}
-function normalizeVirtualId(id) {
-	const bare = id.startsWith("\0") ? id.slice(1) : id;
-	if (!bare.startsWith("virtual:markless:")) return bare;
-	const queryIndex = bare.indexOf("?");
-	return `${MARKLESS_VIRTUAL_PREFIX}${(queryIndex === -1 ? bare : bare.slice(0, queryIndex)).slice(MARKLESS_VIRTUAL_PREFIX.length).split(":").map((segment) => {
-		try {
-			return encodeURIComponent(decodeURIComponent(segment));
-		} catch {
-			return segment;
-		}
-	}).join(":")}`;
-}
-function resolveVirtualId(id) {
-	if (id.startsWith("\0")) return id;
-	return `\0${id}`;
-}
-function pathname(id) {
-	return parsePath(id).pathname;
-}
-//#endregion
-export { preflightTsrxModuleDiagnostics as a, collectHeadLinkInjections as c, marklessServer as i, convertManifestToBundleGraph as l, marklessClient as n, transformTsrxModule as o, marklessLib as r, createBuildMetadata as s, createMarklessRolldownPlugin as t, createPreloadGraphAdder as u };