@markless/bundler 0.2.2 → 0.3.0

package/dist/rolldown-DAsY_7V1.js

@@ -0,0 +1,4515 @@
+import { MarklessCompileError, createCompileErrorPayload } from "./dev-error.js";
+import { S as requalifyExecutionLogModuleHook, _ as executionLogActivationInjection, a as encodedSymbolSource, b as injectExecutionLogModuleHook, d as scopedSymbolExportName, f as settleVirtualModuleId, g as MARKLESS_EXECUTION_LOG_MODULE_ID, h as EXECUTION_LOG_DISPATCH_MODULE_IDS, i as emitSourceModule, l as resumeVirtualModuleId, m as symbolVirtualModuleSourceFile, n as emitResumeModule, o as payloadModule, p as symbolVirtualModuleId, r as emitSettleModule, s as prerenderWakeVirtualModuleId, t as MARKLESS_VIRTUAL_PREFIX, u as rewriteSymbolModuleExport, v as executionLogVirtualModuleSource, w as planModulePreloads, x as normalizeExecutionLogMode, y as hasExecutionLogModuleHook } from "./source-module-BCEdLQvG.js";
+import { joinURL, parsePath, withLeadingSlash, withQuery, withoutLeadingSlash } from "ufo";
+import { PROTOCOL_EVENT_ACTION_KIND, createStorageSeedMetadataFromGraphNodeId, protocolEventActionKind } from "@markless/serializer";
+import { existsSync, statSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
+import { defDGraph } from "@thi.ng/dgraph";
+import { collectTsrxModuleDiagnostics, compileTsrxModule, emitSymbolResolverModule, parseJavaScriptModule } from "@markless/compiler";
+import { PRERENDER_INLINE_EVENT_NAMES_TOKEN, createInlineResumerDebugRegistrationSource, createInlineResumerSelfWakeSource, createInlineResumerSource, createPrerenderInlineResumerSource, createPrerenderSettleInlineResumerSource } 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;
+}
+const MARKLESS_BUILD_PREFIX = `build/`;
+const MARKLESS_BUNDLE_GRAPH = `${MARKLESS_BUILD_PREFIX}bundle-graph.json`;
+const WEB_RUNTIME_CAPABILITY_GROUPS = [
+	{
+		name: "markless-direct-renderer",
+		test: fileBasenamePattern("direct")
+	},
+	{
+		name: "markless-resume-branches",
+		test: fileBasenamePattern("resume-branches")
+	},
+	{
+		name: "markless-resume-behaviors",
+		test: fileBasenamePattern("resume-behaviors")
+	},
+	{
+		name: "markless-resume-repeats",
+		test: fileBasenamePattern("resume-keyed-repeats", "repeat-runtime")
+	},
+	{
+		name: "markless-resume-async",
+		test: fileBasenamePattern("resume-async-boundaries", "resume-async-wiring")
+	},
+	{
+		name: "markless-resume-shared-patch",
+		test: fileBasenamePattern("resume-shared-patch")
+	},
+	{
+		name: "markless-resume-runtime",
+		test: fileBasenamePattern("resume-runtime")
+	},
+	{
+		name: "markless-resume-runtime-start",
+		test: fileBasenamePattern("resume-runtime-start")
+	},
+	{
+		name: "markless-resume-runtime-shared",
+		test: fileBasenamePattern("resume-runtime-shared")
+	},
+	{
+		name: "markless-resume-events",
+		test: fileBasenamePattern("resume-events")
+	},
+	{
+		name: "markless-resume-handoff",
+		test: fileBasenamePattern("resume-handoff")
+	},
+	{
+		name: "markless-resume-locators",
+		test: fileBasenamePattern("resume-locators")
+	},
+	{
+		name: "markless-resume-errors",
+		test: fileBasenamePattern("resume-errors")
+	},
+	{
+		name: "markless-resume-sync-computed",
+		test: fileBasenamePattern("resume-sync-computed")
+	},
+	{
+		name: "markless-resume-sync-demand",
+		test: fileBasenamePattern("resume-sync-demand")
+	},
+	{
+		name: "markless-payload-full",
+		test: fileBasenamePattern("payload-full", "payload-full-storage-free")
+	},
+	{
+		name: "markless-payload-resume",
+		test: fileBasenamePattern("payload-resume")
+	},
+	{
+		name: "markless-inline-payload-document",
+		test: /[/\\]web[/\\]src[/\\]inline[/\\]payload-document\.ts(?:[?#].*)?$/
+	},
+	{
+		name: "markless-payload-document",
+		test: fileBasenamePattern("payload-document", "payload-document-common", "payload-resume-registry")
+	},
+	{
+		name: "markless-payload-graph-construct",
+		test: fileBasenamePattern("payload-graph-construct")
+	},
+	{
+		name: "markless-dom-journal",
+		test: fileBasenamePattern("dom-journal")
+	},
+	{
+		name: "markless-protocol-decode",
+		test: fileBasenamePattern("protocol-client", "protocol-client-storage", "protocol-state", "storage-record-client")
+	},
+	{
+		name: "markless-value-decode",
+		test: fileBasenamePattern("value-decode-client", "value-decode-extensions")
+	},
+	{
+		name: "markless-payload-leaves",
+		test: fileBasenamePattern("payload", "payload-document")
+	},
+	{
+		name: "markless-dev-log",
+		test: /virtual:markless:dev-log|[/\\]web[/\\]src[/\\]dev-log\.ts(?:[?#].*)?$/
+	},
+	{
+		name: "markless-resume-core",
+		test: fileBasenamePattern("resume")
+	},
+	{
+		name: "markless-runtime-graph-core",
+		test: fileBasenamePattern("graph-core")
+	},
+	{
+		name: "markless-runtime-graph-collections",
+		test: fileBasenamePattern("graph-collections")
+	},
+	{
+		name: "markless-runtime-graph-computed",
+		test: fileBasenamePattern("graph-computed")
+	},
+	{
+		name: "markless-runtime-graph-async",
+		test: fileBasenamePattern("graph-async")
+	},
+	{
+		name: "markless-runtime-graph-scheduler",
+		test: fileBasenamePattern("graph-scheduler")
+	},
+	{
+		name: "markless-runtime-graph-shared",
+		test: fileBasenamePattern("graph-shared")
+	},
+	{
+		name: "markless-graph",
+		test: /[/\\](?:runtime[/\\]src[/\\](?!graph-(?:core|collections|computed|async|scheduler|shared)\.ts)|core[/\\]src[/\\]runtime)[/\\]?/
+	},
+	{
+		name: "markless-serializer",
+		test: /[/\\]serializer[/\\]src[/\\](?!protocol-validation)/
+	}
+];
+function fileBasenamePattern(...names) {
+	return new RegExp(`[/\\\\](?:${names.join("|")})\\.ts(?:[?#].*)?$`);
+}
+const MARKLESS_RUNTIME_GROUPS = [...WEB_RUNTIME_CAPABILITY_GROUPS, {
+	name: "markless-runtime",
+	test: /[/\\]@markless[/\\]runtime[/\\]/
+}];
+function outputDefaults(output, environment) {
+	if (environment === "lib") return output;
+	const next = {
+		...output,
+		hoistTransitiveImports: false
+	};
+	if (environment === "server") {
+		next.entryFileNames ??= "[name].js";
+		next.chunkFileNames ??= "chunk-[hash].js";
+		next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
+		return next;
+	}
+	next.entryFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
+	next.chunkFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
+	next.minifyInternalExports = true;
+	next.strictExecutionOrder = true;
+	next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
+	return next;
+}
+function marklessCodeSplitting(codeSplitting) {
+	if (typeof codeSplitting === "boolean") throw new Error("@markless/bundler requires output.codeSplitting to be an object so runtime chunks can be grouped.");
+	return {
+		...codeSplitting,
+		groups: [...MARKLESS_RUNTIME_GROUPS, ...codeSplitting?.groups ?? []]
+	};
+}
+//#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"
+		})),
+		...(options.wakeChunks ?? []).map((name) => ({
+			name,
+			priority: "auto"
+		}))
+	];
+	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 = [...new Map(injections.map((injection) => [headLinkKey(injection), injection])).values()].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) {
+	if (injection.tag === "link" && injection.attributes?.rel === "modulepreload") return `<link ${Object.entries(injection.attributes).map(([name, value]) => compactAttribute(name, value)).join(" ")}>`;
+	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 headLinkKey(injection) {
+	return JSON.stringify([
+		injection.tag,
+		injection.location,
+		Object.entries(injection.attributes ?? {}),
+		injection.children
+	]);
+}
+function compactAttribute(name, value) {
+	if (name === "crossorigin" && value === "anonymous") return name;
+	return /^[^\s"'`=<>]+$/.test(value) ? `${name}=${value}` : `${name}="${value.replaceAll("\"", "&quot;")}"`;
+}
+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 ../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 delegatedEvents = /* @__PURE__ */ new Set();
+	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 (delegatedEvents.has(eventName)) return freeze({
+			kind: "inline-resumer",
+			source: "ssr-inline",
+			containerId: id,
+			elementKey: keyFor(element),
+			eventName
+		});
+		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
+			}));
+		},
+		delegated(eventNames) {
+			if (lifecycle === "disposed") return;
+			for (const eventName of eventNames) delegatedEvents.add(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),delegated:(eventNames)=>controls.delegated(eventNames),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")}`);
+}
+const compiledPrerenderSources = /* @__PURE__ */ new Map();
+function compilePrerenderInlineResumerSources() {
+	let compiled = compiledPrerenderSources.get("production");
+	if (!compiled) {
+		compiled = compilePrerenderVariants();
+		compiledPrerenderSources.set("production", compiled);
+	}
+	return compiled;
+}
+async function compilePrerenderVariants() {
+	const [prerender, prerenderSelfWake, prerenderSettle] = await Promise.all([
+		compilePrerenderInlineResumerSource(false),
+		compilePrerenderInlineResumerSource(true),
+		compilePrerenderInlineResumerSource("settle")
+	]);
+	return {
+		prerender,
+		prerenderSelfWake,
+		prerenderSettle
+	};
+}
+async function compilePrerenderInlineResumerSource(selfWake) {
+	const source = parameterizedPrerenderInlineResumerSource(selfWake);
+	const { minifySync, transformSync } = await loadOxcTools();
+	const transformed = transformSync("markless-prerender-inline-resumer.js", source, {
+		lang: "js",
+		sourceType: "script",
+		target: "es2020"
+	});
+	assertOxcResult("transform", transformed.errors);
+	const minified = minifySync("markless-prerender-inline-resumer.js", transformed.code, {
+		compress: true,
+		mangle: { toplevel: true },
+		module: false
+	});
+	assertOxcResult("minify", minified.errors);
+	const code = minified.code.trim();
+	if (code.split(PRERENDER_INLINE_EVENT_NAMES_TOKEN).length !== 2) throw new Error("MARKLESS_PRERENDER_INLINE_RESUMER_EVENT_NAMES_TOKEN_LOST");
+	return code;
+}
+function parameterizedPrerenderInlineResumerSource(selfWake) {
+	const placeholder = [PRERENDER_INLINE_EVENT_NAMES_TOKEN];
+	const literal = JSON.stringify(placeholder);
+	const plain = selfWake === "settle" ? createPrerenderSettleInlineResumerSource(placeholder, void 0) : createPrerenderInlineResumerSource(placeholder, void 0);
+	if (plain.split(literal).length !== 2) throw new Error("MARKLESS_PRERENDER_INLINE_RESUMER_EVENT_NAMES_UNPLACEABLE");
+	return `${plain.replace(literal, PRERENDER_INLINE_EVENT_NAMES_TOKEN)}${selfWake === true ? createInlineResumerSelfWakeSource(void 0) : ""}`;
+}
+//#endregion
+//#region src/bound-resolver.ts
+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) {`);
+}
+//#endregion
+//#region src/trigger-groups.ts
+const EVENT_STAGES_BROWSER_TRIGGER = {
+	[PROTOCOL_EVENT_ACTION_KIND.event]: true,
+	[PROTOCOL_EVENT_ACTION_KIND.externalDelegate]: false
+};
+function triggerGroupVirtualModuleId(filename, index) {
+	return `virtual:markless:trigger-group:${encodeURIComponent(filename)}:${index}`;
+}
+function triggerGroupVirtualModuleSourceFile(moduleId) {
+	const bare = moduleId.startsWith("\0") ? moduleId.slice(1) : moduleId;
+	const match = /^virtual:markless:trigger-group:([^:]+):\d+$/.exec(bare);
+	if (!match?.[1]) return null;
+	try {
+		return decodeURIComponent(match[1]);
+	} catch {
+		return null;
+	}
+}
+function emitPrerenderTriggerGroupModule(input) {
+	const armRendererModuleId = input.armRendererModuleId ?? input.group.armRendererModuleId;
+	const ids = new Set(input.group.symbolIds);
+	const boundRows = input.boundRows.filter((row) => ids.has(row.id));
+	let source = emitSymbolResolverModule({
+		symbols: input.symbols.filter((symbol) => ids.has(symbol.id)),
+		boundSymbols: boundRows
+	});
+	const routes = input.symbolRoutes ?? [];
+	if (routes.length > 0) {
+		source = source.replaceAll("loadSymbol(", "marklessLoadLocalSymbol(");
+		source += [
+			"export function loadSymbol(symbolId) {",
+			...routes.flatMap((route) => [
+				`\tif (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
+				`\t\treturn import(${JSON.stringify(symbolRouteImportSource(route.importSource))}).then((mod) => mod.loadSymbol ? mod.loadSymbol(symbolId.slice(${route.prefix.length})) : Promise.reject(new Error(\`Unknown child async symbol \${symbolId}\`)));`,
+				"	}"
+			]),
+			"	return marklessLoadLocalSymbol(symbolId);",
+			"}"
+		].join("\n");
+	}
+	return [
+		armRendererModuleId ? [
+			`import { prepareBoundaryArm as marklessPrepareBoundaryArm, renderBoundaryArm as marklessRenderBoundaryArm } from ${JSON.stringify(armRendererModuleId)};`,
+			"export function prepareBoundaryArm(boundaryId, status, graph) {",
+			"	return marklessPrepareBoundaryArm(boundaryId, status, graph, loadSymbol);",
+			"}",
+			"export function renderBoundaryArm(boundaryId, status, graph) {",
+			"	return marklessRenderBoundaryArm(boundaryId, status, graph, loadSymbol);",
+			"}"
+		].join("\n") : "",
+		adaptImportedCaptureResolver(source, boundRows.some((row) => row.loaderSymbolId !== void 0)),
+		`export const groupId=${JSON.stringify(input.group.id)};`,
+		`export const state=${JSON.stringify(input.group.state)};`,
+		`export const view=${JSON.stringify(input.group.view)};`,
+		`export const graphNodeIds=${JSON.stringify(input.group.graphNodeIds)};`
+	].join("\n");
+}
+function emitPrerenderBoundaryRendererModule(renderDataId) {
+	return [
+		`import { marklessPrerenderData } from ${JSON.stringify(renderDataId)};`,
+		"import { renderPrerenderBoundary } from '@markless/web/fns/prerender-resume';",
+		"const marklessPreparedBoundaryArms = new Map();",
+		"export async function prepareBoundaryArm(boundaryId, status, graph, loadSymbol) {",
+		"	const rendered = await renderPrerenderBoundary(marklessPrerenderData, boundaryId, status, graph, loadSymbol);",
+		"	marklessPreparedBoundaryArms.set(`${boundaryId}:${status}`, rendered);",
+		"}",
+		"export function renderBoundaryArm(boundaryId, status) {",
+		"	const key = `${boundaryId}:${status}`;",
+		"	const rendered = marklessPreparedBoundaryArms.get(key);",
+		"	if (!rendered) throw new Error(`Markless prerender arm ${key} was not prepared.`);",
+		"	marklessPreparedBoundaryArms.delete(key);",
+		"	return rendered;",
+		"}"
+	].join("\n");
+}
+function symbolRouteImportSource(importSource) {
+	return importSource.includes("?") ? `${importSource}&markless-symbols` : `${importSource}?markless-symbols`;
+}
+function planPrerenderTriggerGroups(input) {
+	const symbols = new Map(input.symbolResolver.symbols.map((symbol) => [symbol.id, symbol]));
+	const bounds = new Map(input.boundRows.map((row) => [row.id, row]));
+	const completeView = input.completeView ?? input.view;
+	const completeBoundaries = new Map(completeView.asyncBoundaries.map((boundary) => [boundary.id, boundary]));
+	const selfWakeBoundaries = unsettledAsyncBoundaryIndexes(input.state, input.view);
+	const groups = [
+		...selfWakeBoundaries.length > 0 ? [{
+			event: {
+				hostNodeId: "self-wake",
+				eventName: "self-wake",
+				symbolIds: []
+			},
+			selfWakeBoundaries
+		}] : [],
+		...input.view.events.filter((event) => EVENT_STAGES_BROWSER_TRIGGER[protocolEventActionKind(event)]).map((event) => ({ event })),
+		...(input.view.branches ?? []).flatMap((branch, branchIndex) => {
+			const events = /* @__PURE__ */ new Map();
+			for (const arm of branch.armRecords ?? []) for (const event of arm.events) {
+				const key = `${event.eventName}:${event.hostPath.join(".")}`;
+				const route = events.get(key) ?? {
+					eventName: event.eventName,
+					hostPath: event.hostPath,
+					symbolIds: /* @__PURE__ */ new Set()
+				};
+				for (const symbolId of event.symbolIds ?? []) route.symbolIds.add(symbolId);
+				events.set(key, route);
+			}
+			return [...events.values()].map((route) => ({
+				event: {
+					hostNodeId: `branch:${branch.id}:${route.hostPath.join(".")}`,
+					eventName: route.eventName,
+					symbolIds: [...route.symbolIds]
+				},
+				branch,
+				branchIndex,
+				hostPath: route.hostPath
+			}));
+		})
+	].flatMap(({ event, branch, branchIndex, hostPath, selfWakeBoundaries }) => {
+		const closureView = selfWakeBoundaries ? completeView : input.view;
+		if (event.eventName === "visible") return [];
+		const host = branch ? void 0 : input.view.locators.find((locator) => locator.hostNodeId === event.hostNodeId);
+		if (!host && !branch && !selfWakeBoundaries) return [];
+		const compilerGroup = input.triggerGroups.groups.find((group) => group.hostNodeId === event.hostNodeId && group.eventName === event.eventName);
+		const graphNodeIds = /* @__PURE__ */ new Set();
+		const symbolIds = new Set(event.symbolIds ?? []);
+		const selected = {
+			domUpdates: /* @__PURE__ */ new Set(),
+			behaviors: /* @__PURE__ */ new Set(),
+			branches: /* @__PURE__ */ new Set(),
+			boundaries: /* @__PURE__ */ new Set(),
+			repeats: /* @__PURE__ */ new Set(),
+			elementHandles: /* @__PURE__ */ new Set()
+		};
+		if (branch && branchIndex !== void 0) {
+			selected.branches.add(branchIndex);
+			if (branch.symbolId) symbolIds.add(branch.symbolId);
+			for (const read of branch.testReads ?? []) graphNodeIds.add(read.graphNodeId);
+			for (const arm of branch.armRecords ?? []) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
+		}
+		const adoptedBoundaryIds = /* @__PURE__ */ new Set();
+		for (const boundaryIndex of selfWakeBoundaries ?? []) {
+			const servedBoundary = input.view.asyncBoundaries[boundaryIndex];
+			selected.boundaries.add(boundaryIndex);
+			collectSettledBoundaryClosure(input, completeBoundaries.get(servedBoundary.id) ?? servedBoundary, graphNodeIds, symbolIds);
+		}
+		closureView.behaviors.forEach((behavior, index) => {
+			if (selfWakeBoundaries) return;
+			const recordId = `behavior:${behavior.hostNodeId}:${behavior.symbolId ?? ""}`;
+			if ((behavior.inputGraphReads?.length ?? 0) > 0 && !compilerGroup?.payloadRecordIds.includes(recordId)) return;
+			selected.behaviors.add(index);
+			if (behavior.symbolId) symbolIds.add(behavior.symbolId);
+		});
+		let changed = true;
+		while (changed) {
+			const before = closureSize(graphNodeIds, symbolIds, selected);
+			const currentSymbolIds = Array.from(symbolIds);
+			for (const symbolId of currentSymbolIds) {
+				const bound = bounds.get(symbolId);
+				if (bound) {
+					symbolIds.add(bound.loaderSymbolId ?? bound.baseSymbolId);
+					for (const slot of bound.captureSlots) {
+						if (slot.route.kind === "graph-reference") graphNodeIds.add(slot.route.graphNodeId);
+						if (slot.route.kind === "callback-route") symbolIds.add(slot.route.callbackSymbolId);
+					}
+				}
+				const symbol = symbols.get(symbolId);
+				if (!symbol) continue;
+				if ("reads" in symbol) for (const read of symbol.reads ?? []) graphNodeIds.add(read.graphNodeId);
+				if ("writes" in symbol) for (const write of symbol.writes ?? []) graphNodeIds.add(write.graphNodeId);
+				if (symbol.kind === "async-computed-runner" || symbol.kind === "sync-computed-derive") {
+					graphNodeIds.add(symbol.graphNodeId);
+					for (const dependency of symbol.dependencies ?? []) graphNodeIds.add(dependency.graphNodeId);
+				}
+				if ("elementHandleCalls" in symbol) for (const call of symbol.elementHandleCalls ?? []) closureView.elementHandles.forEach((handle, index) => {
+					if (handle.name === call.handleName) selected.elementHandles.add(index);
+				});
+			}
+			closeComputedGraph(graphNodeIds, input.state);
+			for (const graphNodeId of graphNodeIds) {
+				const runnerSymbolId = closureView.asyncRunners?.[graphNodeId];
+				if (runnerSymbolId) symbolIds.add(runnerSymbolId);
+			}
+			selectViewSubscribers(closureView, graphNodeIds, symbolIds, selected);
+			if (!selfWakeBoundaries) input.view.asyncBoundaries.forEach((servedBoundary, index) => {
+				if (adoptedBoundaryIds.has(servedBoundary.id)) return;
+				const boundary = completeBoundaries.get(servedBoundary.id) ?? servedBoundary;
+				if (!settledArmReadGraphNodeIds(input, boundary).some((graphNodeId) => graphNodeIds.has(graphNodeId))) return;
+				adoptedBoundaryIds.add(servedBoundary.id);
+				selected.boundaries.add(index);
+				collectSettledBoundaryClosure(input, boundary, graphNodeIds, symbolIds);
+				collectSettledArmHostRecordClosure(completeView, boundary, graphNodeIds, symbolIds);
+			});
+			if (selfWakeBoundaries || adoptedBoundaryIds.size > 0) {
+				for (const symbol of symbols.values()) if (symbol.kind === "state-initializer" && graphNodeIds.has(symbol.graphNodeId)) symbolIds.add(symbol.id);
+			}
+			changed = closureSize(graphNodeIds, symbolIds, selected) !== before;
+		}
+		const neededHosts = new Set(branch ? [] : [event.hostNodeId]);
+		for (const index of selected.domUpdates) neededHosts.add(closureView.domUpdates[index].hostNodeId);
+		for (const index of selected.behaviors) neededHosts.add(closureView.behaviors[index].hostNodeId);
+		for (const index of selected.repeats) neededHosts.add(closureView.keyedRepeats[index].parentHostNodeId);
+		for (const index of selected.elementHandles) neededHosts.add(closureView.elementHandles[index].hostNodeId);
+		const selectedBoundaryIds = new Set([...selected.boundaries].map((index) => closureView.asyncBoundaries[index].id));
+		const view = {
+			...input.view,
+			locators: closureView.locators.filter((locator) => neededHosts.has(locator.hostNodeId)),
+			events: branch || selfWakeBoundaries ? [] : [event],
+			domUpdates: closureView.domUpdates.filter((_, index) => selected.domUpdates.has(index)),
+			behaviors: closureView.behaviors.filter((_, index) => selected.behaviors.has(index)),
+			elementHandles: closureView.elementHandles.filter((_, index) => selected.elementHandles.has(index)),
+			keyedRepeats: closureView.keyedRepeats?.filter((_, index) => selected.repeats.has(index)),
+			branches: closureView.branches?.filter((_, index) => selected.branches.has(index)),
+			asyncBoundaries: closureView.asyncBoundaries.filter((boundary) => selectedBoundaryIds.has(boundary.id)).map((boundary) => adoptedBoundaryIds.has(boundary.id) ? completeBoundaries.get(boundary.id) ?? boundary : boundary),
+			...closureView.asyncRunners ? { asyncRunners: Object.fromEntries(Object.entries(closureView.asyncRunners).filter(([graphNodeId]) => graphNodeIds.has(graphNodeId))) } : {}
+		};
+		const graphIds = [...graphNodeIds].sort();
+		return [{
+			id: selfWakeBoundaries ? "self-wake" : branch ? `branch:${branch.id}:${event.eventName}:${hostPath.join(".")}` : `${event.hostNodeId}:${event.eventName}`,
+			hostNodeId: event.hostNodeId,
+			eventName: event.eventName,
+			hostIndex: host?.index ?? -1,
+			hostTagName: host?.tagName ?? "*",
+			...branch ? {
+				branchStartIndex: branch.startAnchor.index,
+				branchEndIndex: branch.endAnchor.index,
+				hostPath
+			} : {},
+			graphNodeIds: graphIds,
+			symbolIds: [...symbolIds].sort(),
+			state: filterState(input.state, new Set(graphIds)),
+			view,
+			...adoptedBoundaryIds.size > 0 ? { adoptsSettledArm: true } : {}
+		}];
+	});
+	const armRendererModuleId = groups.some((group) => group.id === "self-wake") ? triggerGroupVirtualModuleId(input.filename, groups.length) : void 0;
+	return groups.map(({ adoptsSettledArm, ...group }) => adoptsSettledArm && armRendererModuleId ? {
+		...group,
+		armRendererModuleId
+	} : group);
+}
+function settledArmReadGraphNodeIds(input, boundary) {
+	const graphNodeIds = /* @__PURE__ */ new Set();
+	for (const arm of boundaryArmRecordSets(boundary)) collectCompleteArmRecordClosure(arm, graphNodeIds, /* @__PURE__ */ new Set());
+	for (const edge of input.componentEdges ?? []) if (edge.asyncBoundaryId === boundary.id) {
+		for (const prop of edge.props) if (prop.kind === "graph-reference") graphNodeIds.add(prop.graphNodeId);
+	}
+	return [...graphNodeIds];
+}
+function collectSettledBoundaryClosure(input, boundary, graphNodeIds, symbolIds) {
+	if (boundary.updateSymbolId) symbolIds.add(boundary.updateSymbolId);
+	for (const read of boundary.asyncReads) {
+		graphNodeIds.add(read.graphNodeId);
+		if (read.runnerSymbolId) symbolIds.add(read.runnerSymbolId);
+	}
+	for (const arm of boundaryArmRecordSets(boundary)) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
+	const settledEdgeIds = /* @__PURE__ */ new Set();
+	for (const edge of input.componentEdges ?? []) {
+		if (edge.asyncBoundaryId !== boundary.id) continue;
+		settledEdgeIds.add(edge.id);
+		for (const prop of edge.props) if (prop.kind === "graph-reference") graphNodeIds.add(prop.graphNodeId);
+	}
+	for (const row of input.boundRows) if (row.componentEdgePath.some((edgeId) => settledEdgeIds.has(edgeId))) symbolIds.add(row.id);
+}
+function collectSettledArmHostRecordClosure(completeView, boundary, graphNodeIds, symbolIds) {
+	const armHosts = /* @__PURE__ */ new Set();
+	for (const arm of boundaryArmRecordSets(boundary)) for (const locator of arm.locators ?? []) armHosts.add(locator.hostNodeId);
+	if (armHosts.size === 0) return;
+	for (const record of completeView.events) if (armHosts.has(record.hostNodeId)) for (const symbolId of record.symbolIds ?? []) symbolIds.add(symbolId);
+	for (const record of completeView.domUpdates) if (armHosts.has(record.hostNodeId)) {
+		graphNodeIds.add(record.graphNodeId);
+		if (record.symbolId) symbolIds.add(record.symbolId);
+	}
+	for (const record of completeView.behaviors) if (armHosts.has(record.hostNodeId)) {
+		for (const read of record.inputGraphReads ?? []) graphNodeIds.add(read.graphNodeId);
+		if (record.symbolId) symbolIds.add(record.symbolId);
+	}
+	for (const record of completeView.keyedRepeats ?? []) if (armHosts.has(record.parentHostNodeId)) {
+		if (record.collectionGraphNodeId) graphNodeIds.add(record.collectionGraphNodeId);
+		for (const rowEvent of record.rowEvents) for (const symbolId of rowEvent.symbolIds ?? []) symbolIds.add(symbolId);
+	}
+}
+function boundaryArmRecordSets(boundary) {
+	return Array.isArray(boundary.armRecords) ? boundary.armRecords : boundary.armRecords ? [boundary.armRecords] : [];
+}
+function unsettledAsyncBoundaryIndexes(state, view) {
+	const computed = new Map(state.computed.map((record) => [record.graphNodeId, record]));
+	const runners = { ...view.asyncRunners };
+	for (const boundary of view.asyncBoundaries) for (const read of boundary.asyncReads) if (read.runnerSymbolId) runners[read.graphNodeId] ??= read.runnerSymbolId;
+	return view.asyncBoundaries.flatMap((boundary, index) => {
+		const reachable = new Set(boundary.asyncReads.map((read) => read.graphNodeId));
+		for (const graphNodeId of reachable) {
+			const record = computed.get(graphNodeId);
+			if (!record) continue;
+			if (runners[graphNodeId] && record.snapshot?.status !== "fulfilled" && record.snapshot?.status !== "rejected") return [index];
+			for (const dependency of record.dependencies ?? []) reachable.add(dependency.graphNodeId);
+		}
+		return [];
+	});
+}
+function selectViewSubscribers(view, graphNodeIds, symbolIds, selected) {
+	view.domUpdates.forEach((record, index) => {
+		if (!graphNodeIds.has(record.graphNodeId)) return;
+		selected.domUpdates.add(index);
+		if (record.symbolId) symbolIds.add(record.symbolId);
+	});
+	view.behaviors.forEach((record, index) => {
+		if (!(record.inputGraphReads ?? []).some((read) => graphNodeIds.has(read.graphNodeId))) return;
+		selected.behaviors.add(index);
+		if (record.symbolId) symbolIds.add(record.symbolId);
+	});
+	(view.branches ?? []).forEach((record, index) => {
+		if (!(record.testReads ?? []).some((read) => graphNodeIds.has(read.graphNodeId))) return;
+		selected.branches.add(index);
+		if (record.symbolId) symbolIds.add(record.symbolId);
+		for (const arm of record.armRecords ?? []) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
+	});
+	view.asyncBoundaries.forEach((record, index) => {
+		if (!record.asyncReads.some((read) => graphNodeIds.has(read.graphNodeId))) return;
+		selected.boundaries.add(index);
+		if (record.updateSymbolId) symbolIds.add(record.updateSymbolId);
+		for (const read of record.asyncReads) if (read.runnerSymbolId) symbolIds.add(read.runnerSymbolId);
+		const arms = Array.isArray(record.armRecords) ? record.armRecords : record.armRecords ? [record.armRecords] : [];
+		for (const arm of arms) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
+	});
+	(view.keyedRepeats ?? []).forEach((record, index) => {
+		if (!record.collectionGraphNodeId || !graphNodeIds.has(record.collectionGraphNodeId)) return;
+		selected.repeats.add(index);
+		for (const rowEvent of record.rowEvents) for (const symbolId of rowEvent.symbolIds ?? []) symbolIds.add(symbolId);
+	});
+}
+function collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds) {
+	for (const event of arm.events ?? []) for (const symbolId of event.symbolIds ?? []) symbolIds.add(symbolId);
+	for (const update of arm.domUpdates ?? []) {
+		if (typeof update.graphNodeId === "string") graphNodeIds.add(update.graphNodeId);
+		if (typeof update.symbolId === "string") symbolIds.add(update.symbolId);
+	}
+	for (const behavior of arm.behaviors ?? []) {
+		for (const read of behavior.inputGraphReads ?? []) if (typeof read.graphNodeId === "string") graphNodeIds.add(read.graphNodeId);
+		if (typeof behavior.symbolId === "string") symbolIds.add(behavior.symbolId);
+	}
+	for (const repeat of arm.keyedRepeats ?? []) {
+		if (repeat.collectionGraphNodeId) graphNodeIds.add(repeat.collectionGraphNodeId);
+		for (const event of repeat.rowEvents) for (const symbolId of event.symbolIds ?? []) symbolIds.add(symbolId);
+	}
+	for (const branch of arm.branches ?? []) {
+		if (branch.symbolId) symbolIds.add(branch.symbolId);
+		for (const read of branch.testReads ?? []) graphNodeIds.add(read.graphNodeId);
+		for (const nested of branch.armRecords ?? []) collectCompleteArmRecordClosure(nested, graphNodeIds, symbolIds);
+	}
+}
+function closeComputedGraph(graphNodeIds, state) {
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const computed of state.computed) {
+			const dependencies = computed.dependencies ?? [];
+			if (!graphNodeIds.has(computed.graphNodeId) && !dependencies.some((dependency) => graphNodeIds.has(dependency.graphNodeId))) continue;
+			if (!graphNodeIds.has(computed.graphNodeId)) {
+				graphNodeIds.add(computed.graphNodeId);
+				changed = true;
+			}
+			for (const dependency of dependencies) if (!graphNodeIds.has(dependency.graphNodeId)) {
+				graphNodeIds.add(dependency.graphNodeId);
+				changed = true;
+			}
+		}
+	}
+}
+function filterState(state, graphNodeIds) {
+	return {
+		...state,
+		cells: state.cells.filter((cell) => graphNodeIds.has(cell.graphNodeId)),
+		computed: state.computed.filter((computed) => graphNodeIds.has(computed.graphNodeId)),
+		storage: state.storage?.filter((cell) => graphNodeIds.has(cell.graphNodeId)),
+		sharedDefinitions: state.sharedDefinitions?.filter((definition) => definition.graphNodeIds.some((graphNodeId) => graphNodeIds.has(graphNodeId)))
+	};
+}
+function closureSize(graphNodeIds, symbolIds, selected) {
+	return graphNodeIds.size + symbolIds.size + Object.values(selected).reduce((total, records) => total + records.size, 0);
+}
+//#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) {
+	return transformTsrxModuleWithPrerenderWakeClosure(input, false);
+}
+function marklessVirtualModuleSourceFile(moduleId) {
+	const bare = moduleId.startsWith("\0") ? moduleId.slice(1) : moduleId;
+	if (!bare.startsWith("virtual:markless:")) return null;
+	const rest = bare.slice(MARKLESS_VIRTUAL_PREFIX.length);
+	const kindEnd = rest.indexOf(":");
+	if (kindEnd <= 0) return null;
+	const encoded = rest.slice(kindEnd + 1).split(":")[0].replace(/\.css$/, "");
+	if (!encoded) return null;
+	try {
+		return decodeURIComponent(encoded);
+	} catch {
+		return null;
+	}
+}
+async function transformTsrxModuleWithPrerenderWakeClosure(input, linkedChildHasBrowserTriggers) {
+	const encodedFilename = encodeURIComponent(input.filename);
+	const payloadId = `${MARKLESS_VIRTUAL_PREFIX}payload:${encodedFilename}`;
+	const renderDataId = `${MARKLESS_VIRTUAL_PREFIX}render-data:${encodedFilename}`;
+	const resolverId = `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodedFilename}`;
+	const resumeId = resumeVirtualModuleId(input.filename);
+	const prerenderWakeId = prerenderWakeVirtualModuleId(input.filename);
+	const settleId = settleVirtualModuleId(input.filename);
+	const { compiled: compiledForAllClasses, blockingDiagnostics } = await compileWithBlockingDiagnostics(input, resolverId);
+	throwIfBlocked(input, blockingDiagnostics);
+	const runtimeDemandClass = input.runtimeDemandClass ?? "prerender";
+	const compiled = {
+		...compiledForAllClasses,
+		runtimeDemandMap: compiledForAllClasses.runtimeDemandMaps?.[runtimeDemandClass] ?? compiledForAllClasses.runtimeDemandMap
+	};
+	const compilerSymbolRows = compiled.symbolModules.modules.map((module) => ({
+		id: module.symbolId,
+		chunk: symbolVirtualModuleId(input.filename, module.symbolId),
+		exportName: scopedSymbolExportName(input.filename, module.exportName)
+	}));
+	const linkedBoundarySymbols = linkedRenderDataBoundarySymbols({
+		compiled,
+		input,
+		renderDataId,
+		resolverId
+	});
+	const symbolRows = [...compilerSymbolRows, ...linkedBoundarySymbols.map((symbol) => symbol.row)];
+	const behaviorSymbolIds = new Set((compiled.protocolView.behaviors ?? []).flatMap((behavior) => behavior.symbolId ? [behavior.symbolId] : []));
+	const behaviorSymbols = compilerSymbolRows.filter((symbol) => behaviorSymbolIds.has(symbol.id));
+	const importedBoundRows = compiled.boundSymbolResolver.rows.map((row) => row.loaderSymbolId ? {
+		...row,
+		baseSymbolId: row.loaderSymbolId
+	} : row);
+	const boundSymbolDescriptors = perBoundaryBoundSymbolDescriptors(compiled.renderData, importedBoundRows);
+	const resolverSymbols = uniqueSymbolsById([...input.symbols ?? [], ...symbolRows]);
+	const resolverSource = adaptImportedCaptureResolver(emitSymbolResolverModule({
+		buildId: input.buildId,
+		symbols: resolverSymbols,
+		boundSymbols: importedBoundRows
+	}), importedBoundRows.some((row) => row.loaderSymbolId !== void 0));
+	const symbolRoutes = compiled.semanticGraph.componentEdges.flatMap((edge, index) => edge.importSource && !input.artifactChildMaterializations?.[edge.id] ? [{
+		prefix: `c${index}:`,
+		importSource: edge.importSource,
+		componentEdgeId: edge.id
+	}] : []);
+	const executionLogModuleHookMode = input.executionLogModuleHooks === false ? "never" : input.executionLog;
+	const symbolManifestEntries = [...compiled.symbolModules.modules.map((module, index) => ({
+		symbolId: module.symbolId,
+		kind: module.kind,
+		exportName: compilerSymbolRows[index].exportName,
+		virtualModuleId: symbolVirtualModuleId(input.filename, module.symbolId)
+	})), ...linkedBoundarySymbols.map((symbol) => symbol.manifest)];
+	const prerenderTriggerGroups = input.prerenderRecordData && input.prerenderWakeVariant ? planPrerenderTriggerGroups({
+		filename: input.filename,
+		...input.prerenderRecordData,
+		completeView: containerScopedResumeView(compiled.protocolView),
+		triggerGroups: compiled.triggerGroups,
+		symbolResolver: compiled.symbolResolver,
+		boundRows: importedBoundRows,
+		componentEdges: compiled.semanticGraph.componentEdges
+	}) : [];
+	const selfWakeArmRendererId = prerenderTriggerGroups.some((group) => group.id === "self-wake") ? triggerGroupVirtualModuleId(input.filename, prerenderTriggerGroups.length) : void 0;
+	const styleScope = compiled.publicRenderPlan.styleScopes[0];
+	const styleId = styleScope ? `${MARKLESS_VIRTUAL_PREFIX}style:${encodedFilename}.css` : null;
+	const prerenderClosureNeedsWake = needsFullResume(compiled.protocolState, compiled.protocolView, compiled.runtimeDemandMap) || input.prerenderRecords === true && linkedChildHasBrowserTriggers;
+	const emitsPrerenderWakeVariant = input.prerenderWakeVariant === true && compiled.publicRenderModule.renderDataModuleSource !== void 0 && prerenderInterfacesComplete(compiled, input) && prerenderClosureNeedsWake;
+	const emitsPrerenderWakeFacade = input.prerenderWakeFacade === true && input.prerenderWakeVariant === true && compiled.publicRenderModule.renderDataModuleSource !== void 0 && prerenderInterfacesComplete(compiled, input) && prerenderClosureNeedsWake;
+	const manifestOwnsSymbolRoutes = input.prerenderWakeVariant !== true || input.preserveWakeSiblingClaims === true || emitsPrerenderWakeFacade;
+	const manifest = {
+		source: input.filename,
+		captureMetadata: compiled.captureAnalysis,
+		symbolRoutes,
+		payload: { virtualModuleId: payloadId },
+		resolver: { virtualModuleId: emitsPrerenderWakeFacade ? prerenderWakeId : resolverId },
+		symbols: manifestOwnsSymbolRoutes ? symbolManifestEntries : [],
+		runtimeDemandMap: compiled.runtimeDemandMap
+	};
+	const settlePlan = planSettleModule({
+		boundaries: compiled.renderData?.boundaries,
+		asyncRunners: compiled.protocolView.asyncRunners,
+		descriptors: boundSymbolDescriptors,
+		symbols: resolverSymbols
+	});
+	const prerenderBootVariants = input.environment === "server" ? await compilePrerenderInlineResumerSources() : void 0;
+	const prerenderBoot = prerenderBootVariants ? {
+		...prerenderBootVariants,
+		...input.settleModuleUrl && settlePlan ? { settle: {
+			moduleUrl: input.settleModuleUrl,
+			boot: prerenderBootVariants.prerenderSettle,
+			bound: settlePlan.bound
+		} } : {}
+	} : void 0;
+	const linkedClientRenderData = input.environment === "client" && !input.prerenderRecords;
+	const canonicalRenderData = (input.prerenderRecords || linkedClientRenderData) && prerenderInterfacesComplete(compiled, input);
+	const virtualModules = [
+		...compiled.publicRenderModule.renderDataModuleSource ? [{
+			id: renderDataId,
+			type: "render-data",
+			...canonicalRenderData ? { canonicalRenderData: true } : {},
+			source: canonicalRenderData ? prerenderDataModuleSource(compiled, input.importedModuleInterfaces, input.renderDataImportSources, input.artifactChildMaterializations, input.filename) : compiled.publicRenderModule.renderDataModuleSource
+		}] : [],
+		...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,
+			symbolClaims: [...new Set([...resolverSymbols.map((symbol) => symbol.id), ...importedBoundRows.map((symbol) => symbol.id)])]
+		},
+		{
+			id: resumeId,
+			type: "resume",
+			source: emitResumeModule({
+				payloadId,
+				resolverId,
+				payloadState: compiled.payloadScripts.state,
+				payloadView: containerScopedResumeView(compiled.payloadScripts.view),
+				runtimeDemandMap: compiled.runtimeDemandMap,
+				executionLog: input.executionLog,
+				needsFullResume: prerenderClosureNeedsWake,
+				prerenderDataId: input.prerenderRecords && prerenderInterfacesComplete(compiled, input) ? renderDataId : void 0,
+				hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
+				boundSymbolDescriptors,
+				symbols: symbolRows,
+				symbolRoutes
+			})
+		},
+		...emitsPrerenderWakeVariant ? [{
+			id: prerenderWakeId,
+			type: "prerender-wake",
+			source: emitResumeModule({
+				payloadId,
+				resolverId,
+				payloadState: compiled.payloadScripts.state,
+				payloadView: containerScopedResumeView(compiled.payloadScripts.view),
+				runtimeDemandMap: compiled.runtimeDemandMap,
+				executionLog: input.executionLog,
+				needsFullResume: prerenderClosureNeedsWake,
+				prerenderDataId: renderDataId,
+				prerenderTriggerGroups: prerenderTriggerGroups.map((group, index) => ({
+					...group,
+					moduleId: triggerGroupVirtualModuleId(input.filename, index)
+				})),
+				installResumeSummary: true,
+				recordsOnly: true,
+				hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
+				boundSymbolDescriptors,
+				symbols: symbolRows,
+				symbolRoutes
+			})
+		}] : [],
+		...emitsPrerenderWakeVariant && settlePlan ? [{
+			id: settleId,
+			type: "settle",
+			source: emitSettleModule(settlePlan)
+		}] : [],
+		...(input.prerenderWakeVariant ? prerenderTriggerGroups : []).map((group, index) => ({
+			id: triggerGroupVirtualModuleId(input.filename, index),
+			type: "trigger-group",
+			source: emitPrerenderTriggerGroupModule({
+				group,
+				symbols: uniqueSymbolsById([...input.symbols ?? [], ...symbolRows]),
+				boundRows: importedBoundRows,
+				symbolRoutes,
+				armRendererModuleId: group.id === "self-wake" ? selfWakeArmRendererId : void 0
+			})
+		})),
+		...selfWakeArmRendererId ? [{
+			id: selfWakeArmRendererId,
+			type: "trigger-group",
+			source: emitPrerenderBoundaryRendererModule(renderDataId)
+		}] : [],
+		...linkedBoundarySymbols.map((symbol) => symbol.module),
+		...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,
+			dev: input.dev,
+			payloadId,
+			resolverId,
+			renderDataId,
+			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,
+			prerenderBoot,
+			devResumeReexport: input.devResumeReexport === true,
+			needsFullResume: prerenderClosureNeedsWake,
+			prerenderRecords: input.prerenderRecords,
+			directCsr: input.directCsr,
+			resumeModuleUrl: input.resumeModuleUrl,
+			prerenderWakeModuleUrl: input.prerenderWakeModuleUrl,
+			publicRenderModuleSource: compiled.publicRenderModule.moduleSource,
+			publicRenderRootExportName: compiled.publicRenderModule.rootExportName,
+			publicSsrModuleSource: compiled.publicRenderModule.ssrModuleSource,
+			publicRenderSsrExportName: compiled.publicRenderModule.ssrExportName,
+			canonicalRenderData: prerenderInterfacesComplete(compiled, input),
+			hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
+			symbols: symbolRows,
+			behaviorSymbols,
+			symbolRoutes
+		})),
+		map: null,
+		virtualModules,
+		manifest,
+		moduleGraphInterface: compiled.moduleGraphInterface,
+		interfaceHash: moduleInterfaceHash(compiled.moduleGraphInterface),
+		moduleImports: compiled.semanticGraph.moduleImports,
+		artifactChildren: artifactChildCandidates(compiled)
+	};
+}
+function linkedRenderDataBoundarySymbols(input) {
+	if (input.input.environment !== "client" || !input.compiled.publicRenderModule.renderDataModuleSource || !prerenderInterfacesComplete(input.compiled, input.input)) return [];
+	const emittedSymbolIds = new Set(input.compiled.symbolModules.modules.map((module) => module.symbolId));
+	const plannedSymbols = new Map(input.compiled.symbolResolver.symbols.map((symbol) => [symbol.id, symbol]));
+	const routes = input.compiled.semanticGraph.componentEdges.flatMap((edge, index) => edge.importSource && !input.input.artifactChildMaterializations?.[edge.id] ? [{
+		prefix: `c${index}:`,
+		importSource: edge.importSource
+	}] : []);
+	return input.compiled.protocolView.asyncBoundaries.flatMap((boundary, index) => {
+		const symbolId = boundary.updateSymbolId;
+		if (!symbolId || emittedSymbolIds.has(symbolId)) return [];
+		if (plannedSymbols.get(symbolId)?.kind !== "async-boundary-update") return [];
+		const virtualModuleId = symbolVirtualModuleId(input.input.filename, symbolId);
+		const exportName = scopedSymbolExportName(input.input.filename, `marklessLinkedBoundaryUpdate${index}`);
+		return [{
+			row: {
+				id: symbolId,
+				chunk: virtualModuleId,
+				exportName
+			},
+			manifest: {
+				symbolId,
+				kind: "async-boundary-update",
+				exportName,
+				virtualModuleId
+			},
+			module: {
+				id: virtualModuleId,
+				type: "symbol",
+				symbolId,
+				exportName,
+				source: linkedRenderDataBoundarySymbolSource({
+					boundaryId: boundary.id,
+					exportName,
+					renderDataId: input.renderDataId,
+					resolverId: input.resolverId,
+					routes
+				})
+			}
+		}];
+	});
+}
+function linkedRenderDataBoundarySymbolSource(input) {
+	return [
+		`import { marklessPrerenderData } from ${JSON.stringify(input.renderDataId)};`,
+		`import { loadSymbol as marklessLoadLocalSymbol } from ${JSON.stringify(input.resolverId)};`,
+		"import { renderPrerenderBoundary } from '@markless/web/fns/prerender-resume';",
+		"function marklessLoadLinkedSymbol(symbolId) {",
+		...input.routes.flatMap((route) => [
+			`\tif (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
+			`\t\treturn import(${JSON.stringify(linkedRenderDataSymbolRouteSource(route.importSource))}).then((module) => module.loadSymbol(symbolId.slice(${route.prefix.length})));`,
+			"	}"
+		]),
+		"	return marklessLoadLocalSymbol(symbolId);",
+		"}",
+		`export async function ${input.exportName}(context) {`,
+		`\tconst rendered = await renderPrerenderBoundary(marklessPrerenderData, ${JSON.stringify(input.boundaryId)}, context.status, context.graph, marklessLoadLinkedSymbol);`,
+		"	return { ...rendered, arm: context.status === \"rejected\" ? 2 : 0 };",
+		"}"
+	].join("\n");
+}
+function linkedRenderDataSymbolRouteSource(importSource) {
+	return importSource.includes("?") ? `${importSource}&markless-symbols` : `${importSource}?markless-symbols`;
+}
+function prerenderInterfacesComplete(compiled, input) {
+	return compiled.semanticGraph.componentEdges.every((edge) => !edge.importSource || input.artifactChildMaterializations?.[edge.id] !== void 0 || input.importedModuleInterfaces?.[edge.importSource] !== void 0);
+}
+function artifactChildCandidates(compiled) {
+	const definitions = compiled.publicRenderModule.componentDefinitions;
+	const definitionsByEdge = new Map(definitions.flatMap((definition) => (definition.edges ?? []).map((edge) => [edge.id, edge])));
+	return compiled.semanticGraph.componentEdges.flatMap((edge) => {
+		if (!edge.importSource || !edge.importKind) return [];
+		const definition = definitionsByEdge.get(edge.id);
+		return definition ? [{
+			edgeId: edge.id,
+			componentName: edge.childComponentName,
+			importSource: edge.importSource,
+			importKind: edge.importKind,
+			...edge.importedName ? { importedName: edge.importedName } : {},
+			hasChildren: edge.children.childCount > 0,
+			props: definition.props,
+			...definition.projection ? { projection: definition.projection } : {}
+		}] : [];
+	});
+}
+function resolveAuthoredSpecifier(specifier, sourceFilename) {
+	if (!specifier.startsWith(".")) return specifier;
+	if (!isAbsolute(sourceFilename)) throw new Error(`MARKLESS_RENDER_DATA_READER_SPECIFIER_UNRESOLVABLE: ${JSON.stringify(specifier)} needs an absolute module filename, got ${JSON.stringify(sourceFilename)}.`);
+	return resolve(dirname(sourceFilename), specifier);
+}
+function prerenderDataModuleSource(compiled, importedModuleInterfaces, renderDataImportSources, artifactChildMaterializations, sourceFilename) {
+	const importedComponents = /* @__PURE__ */ new Map();
+	for (const edge of compiled.semanticGraph.componentEdges) {
+		if (!edge.importSource || importedComponents.has(edge.childComponentName)) continue;
+		if (artifactChildMaterializations?.[edge.id]) continue;
+		const linked = importedModuleInterfaces?.[edge.importSource];
+		if (!linked) throw new Error(`MARKLESS_PRERENDER_RENDER_DATA_MISSING: Imported child ${JSON.stringify(edge.childComponentName)} from ${JSON.stringify(edge.importSource)} has no linked render-data artifact.`);
+		importedComponents.set(edge.childComponentName, {
+			source: renderDataImportSources?.[edge.importSource] ?? `virtual:markless:render-data:${encodeURIComponent(linked.filename)}`,
+			local: `marklessPrerenderImport${importedComponents.size}`
+		});
+	}
+	const readerImports = /* @__PURE__ */ new Map();
+	const readerDeclarations = /* @__PURE__ */ new Set();
+	const componentEntries = compiled.publicRenderModule.componentDefinitions.map((definition) => {
+		const { residueReaderSource, residueReaderImports, residueReaderDeclarations, ...record } = definition;
+		for (const entry of residueReaderImports ?? []) readerImports.set(entry.line, entry.line.replace(JSON.stringify(entry.source), JSON.stringify(resolveAuthoredSpecifier(entry.source, sourceFilename))));
+		for (const line of residueReaderDeclarations ?? []) readerDeclarations.add(line);
+		const data = JSON.stringify(record);
+		return `${JSON.stringify(String(definition.name))}:${residueReaderSource ? `{...${data},readResidue:${residueReaderSource}}` : data}`;
+	});
+	const preludes = [...readerImports.values(), ...readerDeclarations];
+	return [
+		...[...importedComponents.values()].map((entry) => `import { marklessPrerenderData as ${entry.local} } from ${JSON.stringify(entry.source)};`),
+		...preludes,
+		compiled.publicRenderModule.renderDataModuleSource,
+		`const marklessPrerenderComponents = {${componentEntries.join(",")}};`,
+		"export const marklessPrerenderData = {",
+		`\trootComponentName: ${JSON.stringify(compiled.renderData.root?.componentName ?? null)},`,
+		"	renderData: marklessRenderData,",
+		"	components: marklessPrerenderComponents,",
+		`\timports: {${[...importedComponents].map(([name, entry]) => `${JSON.stringify(name)}:${entry.local}`).join(",")}},`,
+		"};"
+	].join("\n");
+}
+async function compileTsrxModuleLinkArtifact(input) {
+	const compiled = await compileTsrxModule({
+		filename: input.filename,
+		source: input.source,
+		buildId: input.buildId,
+		symbols: []
+	});
+	return {
+		moduleGraphInterface: compiled.moduleGraphInterface,
+		interfaceHash: moduleInterfaceHash(compiled.moduleGraphInterface),
+		moduleImports: compiled.semanticGraph.moduleImports
+	};
+}
+function moduleInterfaceHash(value) {
+	let hash = 2166136261;
+	const source = JSON.stringify(value ?? null);
+	for (let index = 0; index < source.length; index++) {
+		hash ^= source.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return `mgi1-${(hash >>> 0).toString(36)}`;
+}
+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 ?? [],
+		importedModuleInterfaces: input.importedModuleInterfaces,
+		artifactChildMaterializations: input.artifactChildMaterializations,
+		omitAuthoredSource: normalizeExecutionLogMode(input.executionLog) === "never"
+	});
+	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 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;
+	return runtimeDemandMap.payloadRecords.some((record) => RECORD_NEEDS_FULL_RESUME[record.kind](runtimeDemandMap));
+}
+const RECORD_NEEDS_FULL_RESUME = {
+	"async-boundary": () => true,
+	behavior: () => false,
+	branch: () => true,
+	"dom-update": () => false,
+	"element-handle": () => true,
+	[PROTOCOL_EVENT_ACTION_KIND.event]: () => false,
+	[PROTOCOL_EVENT_ACTION_KIND.externalDelegate]: () => false,
+	"keyed-repeat": (runtimeDemandMap) => !recordKindReplaced(runtimeDemandMap, "keyed-repeat")
+};
+function recordKindReplaced(runtimeDemandMap, kind) {
+	return runtimeDemandMap.recordKinds.some((record) => record.kind === kind && record.replaced === true);
+}
+/**
+* What the settle module must import, and what the document must carry to use
+* it. Fails closed: a boundary whose runner symbol or whose bound base symbol
+* is not in this page's symbol rows produces no settle module at all, so the
+* page keeps the self-wake path rather than half a settle.
+*/
+function planSettleModule(input) {
+	const symbolById = new Map(input.symbols.map((symbol) => [symbol.id, symbol]));
+	const runners = [];
+	const derives = [];
+	const bound = {};
+	for (const boundary of input.boundaries ?? []) {
+		const node = boundary.runnerGraphNodeId;
+		if (!node || !boundary.protocolSupported) continue;
+		const runner = symbolById.get(input.asyncRunners?.[node] ?? "");
+		if (!runner) continue;
+		const rows = (input.descriptors?.[boundary.boundaryId] ?? []).map((descriptor) => ({
+			descriptor,
+			symbol: symbolById.get(descriptor.base)
+		}));
+		if (rows.some((row) => !row.symbol)) continue;
+		runners.push({
+			node,
+			symbol: runner
+		});
+		for (const row of rows) {
+			derives.push({
+				id: row.descriptor.id,
+				symbol: row.symbol
+			});
+			bound[boundary.boundaryId] = {
+				...bound[boundary.boundaryId],
+				[row.descriptor.id]: Object.fromEntries(row.descriptor.slots.map((slot) => [`${slot[0]}|${slot[1].join(".")}`, [slot[2], slot[3]]]))
+			};
+		}
+	}
+	return runners.length > 0 ? {
+		runners,
+		derives,
+		bound
+	} : void 0;
+}
+function perBoundaryBoundSymbolDescriptors(renderData, boundRows) {
+	if (boundRows.length === 0) return void 0;
+	const chunks = new Map(renderData.chunks.map((chunk) => [chunk.id, chunk]));
+	const descriptors = {};
+	for (const boundary of renderData.boundaries) {
+		const edges = componentEdgesReachableFrom(chunks, boundary.armChunkIds.try);
+		const rows = boundRows.filter((row) => row.ancestry.some((step) => edges.has(step.componentEdgeId)));
+		if (rows.length === 0) continue;
+		descriptors[boundary.boundaryId] = rows.map((row) => ({
+			id: row.id,
+			base: row.baseSymbolId,
+			slots: row.captureSlots.flatMap((slot) => slot.legacyGraphRead && slot.route.kind === "graph-reference" ? [[
+				slot.legacyGraphRead.graphNodeId,
+				slot.legacyGraphRead.path,
+				slot.route.graphNodeId,
+				slot.route.path
+			]] : [])
+		}));
+	}
+	return Object.keys(descriptors).length > 0 ? descriptors : void 0;
+}
+function componentEdgesReachableFrom(chunks, rootChunkId) {
+	const edges = /* @__PURE__ */ new Set();
+	const pending = [rootChunkId];
+	const visited = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const id = pending.pop();
+		if (visited.has(id)) continue;
+		visited.add(id);
+		for (const slot of chunks.get(id)?.slots ?? []) if (slot.kind === "child-component") {
+			edges.add(slot.componentEdgeId);
+			pending.push(slot.childTemplateId);
+			if (slot.projectionChunkId) pending.push(slot.projectionChunkId);
+		} else if (slot.kind === "repeat") {
+			pending.push(slot.rowTemplateId);
+			if (slot.emptyTemplateId) pending.push(slot.emptyTemplateId);
+		} else if (slot.kind === "branch") pending.push(...slot.armTemplateIds);
+	}
+	return edges;
+}
+//#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$1(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()
+	};
+}
+/**
+* Returns the final chunk routes encoded in generated symbol tables. These
+* routes feed computed import() calls, so bundler dynamic-import metadata and
+* a plain import-expression scan cannot observe them.
+*/
+function scanGeneratedSymbolTableImports(code, chunkFileName) {
+	const imports = /* @__PURE__ */ new Set();
+	for (const match of code.matchAll(SYMBOL_MANIFEST_TUPLE_RE)) for (const specifier of parseStringList(match[2]) ?? []) if (specifier.startsWith(".")) imports.add(resolveChunkSpecifier$1(chunkFileName, specifier));
+	return [...imports];
+}
+/**
+* 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$1(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$1(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$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 collectGeneratedSymbolFiles(chunks) {
+	const symbolFiles = /* @__PURE__ */ new Map();
+	for (const chunk of chunks.values()) {
+		const facadeId = chunk.facadeModuleId ? normalizeVirtualId$2(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$2)) 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$1(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$1(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$2(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$2(virtualId);
+	return [...chunks.values()].find((chunk) => !!chunk.facadeModuleId && normalizeVirtualId$2(chunk.facadeModuleId) === normalized) ?? [...chunks.values()].find((chunk) => chunk.moduleIds.map(normalizeVirtualId$2).includes(normalized));
+}
+function findResolverRouteChunk(chunks, virtualId, symbols) {
+	const normalized = normalizeVirtualId$2(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$2).includes(normalized)) ?? candidates[0];
+}
+function resolveChunkSpecifier$1(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$2);
+}
+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$1(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$1(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$1(importerFileName, targetFileName) {
+	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
+	return value.startsWith(".") ? value : `./${value}`;
+}
+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.moduleIds);
+}
+function normalizeVirtualId$2(id) {
+	return id.startsWith("\0") ? id.slice(1) : id;
+}
+//#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),
+			...mapBundleNames(bundle, scanGeneratedSymbolTableImports(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$1(metadata.bundles);
+	metadata.assets = sortRecord$1(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$1(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/execution-sizes.ts
+const MARKLESS_EXECUTION_SIZES = `${MARKLESS_BUILD_PREFIX}execution-sizes.json`;
+const CONTENT_HASH_MODULE_SPECIFIER = /chunk-[A-Za-z0-9_-]+\.js/g;
+const CONTENT_HASH_PLACEHOLDER = "chunk-________.js";
+function canonicalizeContentHashSpecifiers(source) {
+	return source.replace(CONTENT_HASH_MODULE_SPECIFIER, CONTENT_HASH_PLACEHOLDER);
+}
+async function createExecutionSizesAsset(bundle, metadata, canonPath = (fileName) => fileName, attribution, options = {}) {
+	const entries = {};
+	const sizeByChunk = /* @__PURE__ */ new Map();
+	const chunkSize = async (item, chunk) => {
+		const cached = sizeByChunk.get(chunk);
+		if (cached) return cached;
+		const size = {
+			raw: item.code.length,
+			gzip: await gzipByteLength(canonicalizeContentHashSpecifiers(item.code)),
+			chunk
+		};
+		sizeByChunk.set(chunk, size);
+		return size;
+	};
+	const symbolLogIdsByChunk = /* @__PURE__ */ new Map();
+	for (const module of metadata.modules) for (const symbol of module.symbols) {
+		if (!symbol.fileName) continue;
+		const chunk = symbolLogIdsByChunk.get(symbol.fileName) ?? [];
+		chunk.push(stripResolvedIdMarker(symbol.virtualModuleId));
+		symbolLogIdsByChunk.set(symbol.fileName, chunk);
+	}
+	for (const item of Object.values(bundle)) {
+		if (item.type !== "chunk") continue;
+		const chunk = canonPath(item.fileName);
+		const logIds = new Set([...item.moduleIds.flatMap((id) => chunkModuleLogId(id) ?? []), ...symbolLogIdsByChunk.get(chunk) ?? []]);
+		if (logIds.size === 0) continue;
+		if (logIds.has("virtual:markless:dev-log") && logIds.size > 1) {
+			const cohabitingIds = [...logIds].filter((id) => id !== MARKLESS_EXECUTION_LOG_MODULE_ID).sort();
+			throw new Error(`Markless execution sizes require an isolated dev-log chunk; chunk "${chunk}" also contains logged module ids: ${cohabitingIds.join(", ")}.`);
+		}
+		const size = await chunkSize(item, chunk);
+		for (const id of logIds) entries[id] = id === "virtual:markless:dev-log" ? {
+			...size,
+			instrument: true
+		} : size;
+		const emittedSpecifier = `./${chunk.split("/").pop()}`;
+		entries[emittedSpecifier] ??= size;
+	}
+	const unshipped = {};
+	if (options.executionLogActive === true) {
+		const absorbing = absorbingChunkIndex(bundle);
+		const unmappable = [];
+		for (const required of requiredExecutionLogIds(metadata, options.hookedIds, absorbing)) {
+			if (entries[required.id]) continue;
+			const item = absorbing.get(required.id);
+			if (!item) {
+				if (required.shipped) unmappable.push(required.id);
+				else if (required.hooked) unshipped[required.id] = UNSHIPPED_HOOK_REASON;
+				continue;
+			}
+			const size = await chunkSize(item, canonPath(item.fileName));
+			entries[required.id] = required.id === "virtual:markless:dev-log" ? {
+				...size,
+				instrument: true
+			} : size;
+		}
+		if (unmappable.length > 0) throw new Error(`Markless execution sizes are incomplete: no chunk carries ${unmappable.sort().join(", ")}. Every id this build can log must join build/execution-sizes.json, or the in-page console reports "bytes unknown" for a real execution.`);
+	}
+	return {
+		type: "asset",
+		fileName: MARKLESS_EXECUTION_SIZES,
+		source: JSON.stringify({
+			...sortRecord(entries),
+			...Object.keys(unshipped).length > 0 ? { unshipped: sortRecord(unshipped) } : {},
+			...attribution && Object.keys(attribution).length > 0 ? { attribution: sortNestedRecord(attribution) } : {}
+		})
+	};
+}
+const UNSHIPPED_HOOK_REASON = "hooked at transform time (before chunk assignment exists); no client chunk carries this module, so it can never execute in a browser";
+function requiredExecutionLogIds(metadata, hookedIds = /* @__PURE__ */ new Map(), absorbing = /* @__PURE__ */ new Map()) {
+	const required = /* @__PURE__ */ new Map();
+	const add = (id, shipped, hooked = false) => {
+		const current = required.get(id);
+		if (!current || shipped && !current.shipped) required.set(id, {
+			id,
+			shipped,
+			hooked: hooked || current?.hooked
+		});
+	};
+	for (const [id, moduleId] of hookedIds) add(id, absorbing.has(moduleId), true);
+	add(MARKLESS_EXECUTION_LOG_MODULE_ID, false);
+	for (const id of EXECUTION_LOG_DISPATCH_MODULE_IDS) add(id, false);
+	for (const module of metadata.modules) for (const symbol of module.symbols) add(stripResolvedIdMarker(symbol.virtualModuleId), !!symbol.fileName);
+	return [...required.values()];
+}
+function absorbingChunkIndex(bundle) {
+	const index = /* @__PURE__ */ new Map();
+	for (const item of Object.values(bundle)) {
+		if (item.type !== "chunk") continue;
+		for (const raw of [...item.moduleIds, item.facadeModuleId ?? ""]) {
+			if (!raw) continue;
+			const id = stripResolvedIdMarker(raw);
+			if (!index.has(id)) index.set(id, item);
+			const logId = workspaceModuleLogId(id);
+			if (logId && !index.has(logId)) index.set(logId, item);
+		}
+	}
+	return index;
+}
+function workspaceModuleLogId(path) {
+	const match = path.match(/[/\\]([a-z0-9-]+)[/\\]src[/\\]([^?#]+)\.ts$/);
+	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : null;
+}
+function chunkModuleLogId(id) {
+	const path = stripResolvedIdMarker(id);
+	if (path === "virtual:markless:dev-log") return path;
+	const match = path.match(/[/\\](web|runtime|serializer)[/\\]src[/\\]([^?#]+)\.ts$/);
+	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : null;
+}
+function stripResolvedIdMarker(id) {
+	return id.startsWith("\0") ? id.slice(1) : id;
+}
+async function gzipByteLength(code) {
+	const encoded = new TextEncoder().encode(code);
+	const reader = new ReadableStream({ start(controller) {
+		controller.enqueue(encoded);
+		controller.close();
+	} }).pipeThrough(new CompressionStream("gzip")).getReader();
+	let total = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		total += value.byteLength;
+	}
+	return total;
+}
+function sortRecord(record) {
+	const next = {};
+	for (const key of Object.keys(record).sort()) next[key] = record[key];
+	return next;
+}
+function sortNestedRecord(record) {
+	const next = {};
+	for (const key of Object.keys(record).sort()) next[key] = sortRecord({ ...record[key] });
+	return next;
+}
+//#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(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(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(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(bundle) {
+	const chunks = /* @__PURE__ */ new Map();
+	for (const output of Object.values(bundle)) if (isGeneratedChunk(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$1(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(chunk.fileName, specifier);
+			const rewrite = rewrites.get(importedFileName);
+			if (!rewrite) return match;
+			if (!rewrite.target.exports.includes(exportName)) return match;
+			const nextSpecifier = relativeChunkSpecifier(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(chunk.fileName, specifier);
+			const rewrite = rewrites.get(importedFileName);
+			if (!rewrite) return match;
+			if (rewrite.initExports.length > 0 && (!parameter || !exportName)) return match;
+			const nextSpecifier = relativeChunkSpecifier(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(importerFileName, specifier) {
+	return normalize(join(dirname(importerFileName), specifier));
+}
+function relativeChunkSpecifier(importerFileName, targetFileName) {
+	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
+	return value.startsWith(".") ? value : `./${value}`;
+}
+function isGeneratedAsyncChunk(chunk) {
+	return chunk.moduleIds.some((id) => {
+		return normalizeVirtualId$1(id).startsWith("virtual:markless:") || TSRX_SOURCE_FILE$1.test(id);
+	});
+}
+function deleteBundleChunk(bundle, fileName) {
+	for (const [key, output] of Object.entries(bundle)) if (isGeneratedChunk(output) && output.fileName === fileName) delete bundle[key];
+}
+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.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$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/module-metadata-registry.ts
+/**
+* Capture data follows authored source identity. Symbol claims follow the exact
+* emitted module identity that owns the corresponding loadSymbol route.
+*/
+var ModuleMetadataRegistry = class {
+	#captureManifestsBySource = /* @__PURE__ */ new Map();
+	#symbolClaimsByEmittedModule = /* @__PURE__ */ new Map();
+	#sourceClaimPublications = /* @__PURE__ */ new Map();
+	clear() {
+		this.#captureManifestsBySource.clear();
+		this.#symbolClaimsByEmittedModule.clear();
+		this.#sourceClaimPublications.clear();
+	}
+	recordCaptureMetadata(source, manifest) {
+		if (manifest.captureMetadata) this.#captureManifestsBySource.set(source, manifest);
+		else this.#captureManifestsBySource.delete(source);
+	}
+	captureMetadataForSource(source) {
+		return this.#captureManifestsBySource.get(source)?.captureMetadata;
+	}
+	deleteCaptureMetadata(source) {
+		this.#captureManifestsBySource.delete(source);
+	}
+	recordSymbolClaims(emittedModule, manifest) {
+		this.#symbolClaimsByEmittedModule.set(emittedModule, manifest);
+	}
+	deleteSymbolClaims(emittedModule) {
+		this.#symbolClaimsByEmittedModule.delete(emittedModule);
+	}
+	hasSymbolClaims(emittedModule) {
+		return this.#symbolClaimsByEmittedModule.has(emittedModule);
+	}
+	beginSourceSymbolClaims(source, emittedModule) {
+		const publication = this.#sourceClaimPublications.get(source) ?? {
+			active: 0,
+			expected: /* @__PURE__ */ new Set(),
+			finalized: /* @__PURE__ */ new Set(),
+			pending: /* @__PURE__ */ new Set(),
+			revision: 0,
+			sealed: false,
+			waiters: []
+		};
+		publication.sealed = false;
+		publication.finalized.delete(emittedModule);
+		if (publication.expected.has(emittedModule)) publication.pending.add(emittedModule);
+		publication.active += 1;
+		publication.revision += 1;
+		this.#sourceClaimPublications.set(source, publication);
+	}
+	expectSourceSymbolClaims(source, emittedModules) {
+		const publication = this.#sourceClaimPublications.get(source) ?? {
+			active: 0,
+			expected: /* @__PURE__ */ new Set(),
+			finalized: /* @__PURE__ */ new Set(),
+			pending: /* @__PURE__ */ new Set(),
+			revision: 0,
+			sealed: false,
+			waiters: []
+		};
+		for (const emittedModule of emittedModules) {
+			publication.expected.add(emittedModule);
+			if (!publication.finalized.has(emittedModule)) publication.pending.add(emittedModule);
+		}
+		publication.sealed = false;
+		publication.revision += 1;
+		this.#sourceClaimPublications.set(source, publication);
+	}
+	finishSourceSymbolClaims(source, emittedModule) {
+		const publication = this.#sourceClaimPublications.get(source);
+		if (!publication || publication.active === 0) throw new Error(`MARKLESS_SOURCE_SYMBOL_CLAIMS_FINAL_WITHOUT_START: Source ${JSON.stringify(source)} published final claims without an active emitted variant.`);
+		publication.active -= 1;
+		publication.finalized.add(emittedModule);
+		publication.pending.delete(emittedModule);
+		publication.revision += 1;
+		if (publication.active !== 0 || publication.pending.size !== 0) return;
+		for (const resolve of publication.waiters.splice(0)) resolve();
+	}
+	async sealSourceSymbolClaims(source) {
+		const publication = this.#sourceClaimPublications.get(source);
+		if (!publication || publication.sealed) return;
+		for (;;) {
+			while (publication.active > 0 || publication.pending.size > 0) await new Promise((resolve) => publication.waiters.push(resolve));
+			const revision = publication.revision;
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			if (publication.revision === revision && publication.active === 0 && publication.pending.size === 0) break;
+		}
+		publication.sealed = true;
+	}
+	symbolClaimManifests() {
+		return this.#symbolClaimsByEmittedModule.values();
+	}
+	symbolClaimMap() {
+		return this.#symbolClaimsByEmittedModule;
+	}
+	/** Combine sibling emitted-module claims by symbol identity; contradictions stay fail-closed. */
+	sourceSymbolClaims(source, resolverId) {
+		const publication = this.#sourceClaimPublications.get(source);
+		if (publication && (publication.active > 0 || publication.pending.size > 0)) throw new Error(`MARKLESS_SOURCE_SYMBOL_CLAIMS_UNSEALED: Source ${JSON.stringify(source)} claims were consumed before final publication completed.`);
+		const candidates = [...this.#symbolClaimsByEmittedModule.values()].filter((manifest) => manifest.resolver.virtualModuleId === resolverId && manifest.symbols.length > 0).sort((left, right) => left.source.localeCompare(right.source));
+		const selected = candidates[0];
+		if (!selected) return void 0;
+		const symbols = /* @__PURE__ */ new Map();
+		for (const candidate of candidates) for (const symbol of candidate.symbols) {
+			const existing = symbols.get(symbol.symbolId);
+			if (!existing) {
+				symbols.set(symbol.symbolId, {
+					owner: candidate.source,
+					symbol
+				});
+				continue;
+			}
+			if (JSON.stringify(existing.symbol) !== JSON.stringify(symbol)) throw new Error(`MARKLESS_SOURCE_SYMBOL_CLAIMS_DIVERGED: Source ${JSON.stringify(source)} has incompatible emitted symbol claims in ${JSON.stringify(existing.owner)} and ${JSON.stringify(candidate.source)}.`);
+		}
+		return {
+			...selected,
+			symbols: [...symbols.values()].map(({ symbol }) => symbol)
+		};
+	}
+	emittedSymbolClaimMap(emittedModules) {
+		const emitted = new Set(emittedModules);
+		return new Map([...this.#symbolClaimsByEmittedModule].filter(([owner]) => emitted.has(owner)));
+	}
+};
+//#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 MARKLESS_RENDER_DATA_SOURCE_QUERY_RE = /[?&]markless-render-data(?:[&#]|$)/;
+const MARKLESS_REACHED_FROM_SOURCE_QUERY = "markless-reached-from";
+const MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE = /[?&]markless-prerender-wake(?:[&#]|$)/;
+const MARKLESS_ROUTE_SOURCE_QUERY_RE = /[?&]markless-route(?:[&#]|$)/;
+const RESUME_VIRTUAL_ID_RE = /^virtual:markless:resume:([^:]+)$/;
+const PRERENDER_WAKE_VIRTUAL_ID_RE = /^virtual:markless:prerender-wake:([^:]+)$/;
+const SETTLE_VIRTUAL_ID_RE = /^virtual:markless:settle:([^:]+)$/;
+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 moduleMetadata = new ModuleMetadataRegistry();
+	const prerenderWakeCapabilities = /* @__PURE__ */ new Map();
+	const moduleLinkArtifacts = /* @__PURE__ */ new Map();
+	const linkedTransformCache = /* @__PURE__ */ new Map();
+	const importedChildren = /* @__PURE__ */ new Map();
+	const importedChildSources = /* @__PURE__ */ new Set();
+	const emittedClientResolverSources = /* @__PURE__ */ new Set();
+	const transformVirtualModules = /* @__PURE__ */ new Map();
+	const virtualModuleOwners = /* @__PURE__ */ new Map();
+	const clientSymbolEntrySources = /* @__PURE__ */ new Set();
+	const prerenderWakeSources = /* @__PURE__ */ new Set();
+	const clientRouteArtifactSources = /* @__PURE__ */ new Set();
+	const clientRouteArtifactMaterializations = /* @__PURE__ */ new Map();
+	const transformedClientPrimarySources = /* @__PURE__ */ new Set();
+	const executionLogEstimatedSizes = /* @__PURE__ */ new Map();
+	const executionLogEmittedIds = /* @__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;
+	}
+	function invalidateAllGeneratedModules(parent, currentEnvironment) {
+		const changedSource = pathname(parent);
+		moduleLinkArtifacts.delete(changedSource);
+		moduleMetadata.deleteCaptureMetadata(changedSource);
+		moduleMetadata.deleteSymbolClaims(changedSource);
+		prerenderWakeCapabilities.delete(changedSource);
+		prerenderWakeSources.delete(changedSource);
+		for (const [key, cached] of linkedTransformCache) {
+			if (cached.source !== changedSource) continue;
+			moduleMetadata.deleteSymbolClaims(cached.manifestSource);
+			linkedTransformCache.delete(key);
+		}
+		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];
+	}
+	async function invalidateEditedGeneratedModules(parent, currentEnvironment, nextSource) {
+		const changedSource = pathname(parent);
+		const cachedEntries = [...linkedTransformCache].filter(([key, cached]) => cached.source === changedSource && (!currentEnvironment || key.startsWith(`${currentEnvironment}\0`)));
+		if (cachedEntries.length === 0) return invalidateAllGeneratedModules(parent, currentEnvironment);
+		const nextEntries = await Promise.all(cachedEntries.map(async ([key, cached]) => {
+			const nextInput = {
+				...cached.input,
+				source: nextSource
+			};
+			return [
+				key,
+				cached,
+				nextInput,
+				await transformTsrxModuleWithPrerenderWakeClosure(nextInput, cached.linkedChildHasBrowserTriggers)
+			];
+		}));
+		if (nextEntries.some(([, cached, , next]) => !isRenderDataOnlyTransformChange(cached.result, next))) return invalidateAllGeneratedModules(parent, currentEnvironment);
+		const renderDataIds = /* @__PURE__ */ new Set();
+		for (const [key, cached, nextInput, next] of nextEntries) {
+			linkedTransformCache.set(key, {
+				...cached,
+				code: nextSource,
+				input: nextInput,
+				result: next
+			});
+			moduleLinkArtifacts.set(changedSource, {
+				moduleGraphInterface: next.moduleGraphInterface,
+				interfaceHash: next.interfaceHash,
+				moduleImports: next.moduleImports
+			});
+			moduleMetadata.recordCaptureMetadata(changedSource, next.manifest);
+			const symbolClaim = emittedSymbolClaim(moduleMetadata, changedSource, cached.manifestSource, next.manifest, next.virtualModules);
+			moduleMetadata.recordSymbolClaims(symbolClaim.owner, isRenderDataSourceRequest(cached.manifestSource) ? renderDataClaimManifest(next.manifest, cached.manifestSource) : symbolClaim.manifest);
+			prerenderWakeCapabilities.set(changedSource, manifestHasBrowserTriggers(next.manifest) || cached.linkedChildHasBrowserTriggers);
+			for (const module of next.virtualModules) {
+				if (module.type !== "render-data") continue;
+				virtualModules.set(module.id, module);
+				renderDataIds.add(resolveVirtualId(module.id));
+			}
+		}
+		return [...renderDataIds];
+	}
+	const regeneratingVirtualModules = /* @__PURE__ */ new Set();
+	async function virtualModuleForRequest(normalizedId, currentEnvironment) {
+		const registered = virtualModules.get(normalizedId);
+		if (registered || internalOptions.dev !== true) return registered;
+		const source = marklessVirtualModuleSourceFile(normalizedId);
+		if (!source || !TSRX_SOURCE_FILE.test(source) || regeneratingVirtualModules.has(normalizedId)) return;
+		regeneratingVirtualModules.add(normalizedId);
+		try {
+			internalOptions.devServer?.invalidateModule?.(source, currentEnvironment);
+			await internalOptions.devServer?.transformRequest(source, currentEnvironment);
+		} finally {
+			regeneratingVirtualModules.delete(normalizedId);
+		}
+		return virtualModules.get(normalizedId);
+	}
+	const recoveringChildMetadata = /* @__PURE__ */ new Set();
+	async function recoverImportedChildMetadata(child, currentEnvironment) {
+		if (!TSRX_SOURCE_FILE.test(child.source) || moduleMetadata.captureMetadataForSource(child.source) !== void 0 || recoveringChildMetadata.has(child.source)) return;
+		recoveringChildMetadata.add(child.source);
+		try {
+			internalOptions.devServer?.invalidateModule?.(child.source, currentEnvironment);
+			await internalOptions.devServer?.transformRequest(child.source, currentEnvironment);
+		} finally {
+			recoveringChildMetadata.delete(child.source);
+		}
+	}
+	const plugin = {
+		api: { invalidateGeneratedModules(parent, currentEnvironment, nextSource) {
+			if (nextSource !== void 0) return invalidateEditedGeneratedModules(parent, currentEnvironment, nextSource);
+			return invalidateAllGeneratedModules(parent, currentEnvironment);
+		} },
+		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();
+			clientRouteArtifactSources.clear();
+			clientRouteArtifactMaterializations.clear();
+			transformedClientPrimarySources.clear();
+			virtualModules.clear();
+			moduleMetadata.clear();
+			moduleLinkArtifacts.clear();
+			linkedTransformCache.clear();
+			importedChildren.clear();
+			importedChildSources.clear();
+			emittedClientResolverSources.clear();
+			transformVirtualModules.clear();
+			virtualModuleOwners.clear();
+			executionLogEstimatedSizes.clear();
+			executionLogEmittedIds.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 = await virtualModuleForRequest(normalized, getEnvironment(this));
+			if (virtualModule) {
+				const directQuery = virtualModule.type === "style" && /(?:[?&])direct(?:[=&]|$)/.test(source) ? "?direct" : "";
+				return {
+					id: `${resolveVirtualId(normalized)}${directQuery}`,
+					moduleSideEffects: true
+				};
+			}
+			const missingSymbolSource = symbolVirtualModuleSourceFile(normalized);
+			if (missingSymbolSource && importedChildSources.has(missingSymbolSource)) throw new Error(`MARKLESS_CHILD_SYMBOL_MISSING: Linked child ${JSON.stringify(missingSymbolSource)} does not provide requested symbol module ${JSON.stringify(normalized)}. Rebuild the child with the current Markless compiler and clear any stale build cache.`);
+			const symbolSource = sourceForSymbolVirtualImporter(importer);
+			if (symbolSource && isRelativeImport(source)) return await this.resolve(source, symbolSource, { skipSelf: true });
+			const triggerGroupSource = sourceForTriggerGroupVirtualImporter(importer);
+			if (triggerGroupSource && isRelativeImport(source)) return await this.resolve(source, triggerGroupSource, { skipSelf: true });
+			const resumeSource = sourceForResumeVirtualImporter(importer) ?? sourceForPrerenderWakeVirtualImporter(importer);
+			if (resumeSource && isRelativeImport(source)) return await this.resolve(source, resumeSource, { skipSelf: true });
+			return null;
+		},
+		async 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(moduleMetadata.symbolClaimMap().values(), getRoot(), importedChildren.values()) : void 0,
+					sizesUrl: internalOptions.dev === true ? void 0 : internalOptions.publicPath?.(MARKLESS_EXECUTION_SIZES) ?? `/${MARKLESS_EXECUTION_SIZES}`
+				});
+			}
+			const normalizedId = normalizeVirtualId(id);
+			const resolverSource = resolverVirtualModuleSourceFile(normalizedId);
+			if (resolverSource && getEnvironment(this) === "client" && internalOptions.dev !== true && internalOptions.prerenderWakeChannel === true && typeof this.getModuleInfo === "function") {
+				const queryClaimSources = [
+					withQuery(resolverSource, { "markless-resume": null }),
+					withQuery(resolverSource, { "markless-prerender-wake": null }),
+					withQuery(resolverSource, { "markless-symbols": null })
+				];
+				moduleMetadata.expectSourceSymbolClaims(resolverSource, queryClaimSources.filter((source) => this.getModuleInfo(source) != null));
+				await moduleMetadata.sealSourceSymbolClaims(resolverSource);
+			}
+			const module = await virtualModuleForRequest(normalizedId, getEnvironment(this));
+			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 && internalOptions.prerender === true && normalizeExecutionLogMode(internalOptions.executionLog) !== "never" && this.getModuleInfo(id)?.isEntry === true) return {
+					code: `${code}\nglobalThis.__mxLoadLog ||= () => import(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)});\nglobalThis.__mxLoadLog().then(log => log.logMarklessRenderSummary());`,
+					map: null
+				};
+				if (currentEnvironment === "client" && normalizeExecutionLogMode(internalOptions.executionLog) !== "never" && isMarklessRuntimeModule(id)) {
+					executionLogEstimatedSizes.set(executionLogRuntimeModuleId(id), code.length);
+					executionLogEmittedIds.set(executionLogRuntimeModuleId(id), pathname(id));
+					return {
+						code: injectExecutionLogModuleHook(code, executionLogRuntimeModuleId(id), internalOptions.executionLog),
+						map: null
+					};
+				}
+				return null;
+			}
+			if (virtualId.startsWith("virtual:markless:")) return null;
+			const source = pathname(id);
+			const renderDataRequest = isRenderDataSourceRequest(id);
+			const prerenderWakeRequest = isPrerenderWakeSourceRequest(id);
+			const clientRouteArtifact = MARKLESS_ROUTE_SOURCE_QUERY_RE.test(id);
+			const materializedRenderDataReach = currentEnvironment === "client" && renderDataRequest ? materializedRenderDataReachRoot(id, source, clientRouteArtifactMaterializations) : void 0;
+			if (currentEnvironment === "client" && prerenderWakeRequest) {
+				clientSymbolEntrySources.add(source);
+				prerenderWakeSources.add(source);
+			}
+			const ssrPrerenderArtifacts = currentEnvironment === "client" && (internalOptions.prerenderWakeChannel === true || prerenderWakeSources.size > 0);
+			const prerenderRecords = currentEnvironment === "client" && (internalOptions.prerender === true || internalOptions.prerenderWakeChannel === true || materializedRenderDataReach !== void 0 || prerenderWakeRequest || ssrPrerenderArtifacts);
+			const transformInput = {
+				filename: source,
+				source: code,
+				dev: internalOptions.dev === true || currentEnvironment === "client" && clientRouteArtifactSources.has(source),
+				buildId: internalOptions.buildId,
+				executionLog: normalizeExecutionLogMode(internalOptions.executionLog),
+				executionLogModuleHooks: currentEnvironment === "client" && normalizeExecutionLogMode(internalOptions.executionLog) !== "never",
+				inlineResumerDebug: internalOptions.inlineResumerDebug === true,
+				prerenderRecords,
+				directCsr: currentEnvironment === "client" && internalOptions.emitResumeModules !== true && internalOptions.prerender !== true && !renderDataRequest && !prerenderWakeRequest && !isResumeSourceRequest(id) && !isSymbolOnlySourceRequest(id) && !clientRouteArtifact,
+				runtimeDemandClass: currentEnvironment === "client" && internalOptions.emitResumeModules === true && !prerenderRecords && !clientRouteArtifactSources.has(source) ? "plain-ssr" : "prerender",
+				prerenderWakeVariant: internalOptions.prerenderWakeChannel === true && (prerenderWakeRequest || ssrPrerenderArtifacts && clientSymbolEntrySources.has(source)),
+				prerenderWakeFacade: prerenderWakeRequest,
+				preserveWakeSiblingClaims: currentEnvironment === "client" && (isResumeSourceRequest(id) || isSymbolOnlySourceRequest(id)),
+				environment: currentEnvironment,
+				clientOutput: currentEnvironment === "client" && (clientSymbolEntrySources.has(source) && internalOptions.prerender !== true && !clientRouteArtifactSources.has(source) && isClientPrimarySourceRequest(id) && isModuleEntry(this, id) || isSymbolOnlySourceRequest(id)) ? "symbols-only" : void 0,
+				resumeModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? devBrowserSourceModuleUrl(source, getRoot(), internalOptions.publicPath) : currentEnvironment === "server" ? internalOptions.productionResumeModuleUrls?.get(source) : void 0,
+				prerenderWakeModuleUrl: currentEnvironment === "server" ? internalOptions.productionPrerenderWakeModuleUrls?.get(source) : void 0,
+				settleModuleUrl: currentEnvironment === "server" ? internalOptions.productionSettleModuleUrls?.get(source) : 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",
+				prerenderRecordData: currentEnvironment === "client" ? input.prerenderRecordsBySource?.get(source) : void 0
+			};
+			const manifestSource = currentEnvironment === "client" && !isClientPrimarySourceRequest(id) ? id : source;
+			const publishesClientClaims = currentEnvironment === "client" && !renderDataRequest && !clientRouteArtifact;
+			if (publishesClientClaims) moduleMetadata.beginSourceSymbolClaims(source, manifestSource);
+			const cacheKey = [
+				currentEnvironment,
+				manifestSource,
+				transformInput.clientOutput ?? "full",
+				isResumeSourceRequest(id) ? "resume" : prerenderWakeRequest ? "prerender-wake" : renderDataRequest ? "render-data" : "source"
+			].join("\0");
+			const cached = linkedTransformCache.get(cacheKey);
+			let linkedTransformResult;
+			let linkedTransformInput = transformInput;
+			let reusedLinkedTransform = false;
+			if (cached?.code === code) {
+				const cachedImports = await resolveImportedModuleInterfaces.call(this, manifestSource, cached.result.moduleImports);
+				await forceImportedModules.call(this, cachedImports, moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
+				if (cached.importedInterfaceHashes === importedInterfaceHashSignature(cachedImports, moduleLinkArtifacts) && cached.importedSymbolClaims === importedSymbolClaimSignature(cachedImports, moduleMetadata)) {
+					linkedTransformResult = cached.result;
+					linkedTransformInput = cached.input;
+					reusedLinkedTransform = true;
+				}
+			}
+			if (linkedTransformResult === void 0) try {
+				linkedTransformResult = await transformTsrxModule(transformInput);
+			} catch (error) {
+				const provisional = await compileTsrxModuleLinkArtifact(transformInput);
+				moduleLinkArtifacts.set(source, provisional);
+				const provisionalImports = await resolveImportedModuleInterfaces.call(this, manifestSource, provisional.moduleImports);
+				if (provisionalImports.length === 0) throw error;
+				await forceImportedModules.call(this, provisionalImports, moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
+				linkedTransformInput = {
+					...transformInput,
+					importedModuleInterfaces: importedModuleInterfaces(provisionalImports, moduleLinkArtifacts)
+				};
+				linkedTransformResult = await transformTsrxModule(linkedTransformInput);
+			}
+			let transformed = linkedTransformResult;
+			if (currentEnvironment === "client" && clientRouteArtifact) {
+				const artifactChildMaterializations = await materializeArtifactChildren.call(this, source, getRoot(), transformed.artifactChildren);
+				if (Object.keys(artifactChildMaterializations).length > 0) clientRouteArtifactMaterializations.set(source, artifactChildMaterializations);
+				registerClientRouteArtifactSource(source);
+				return {
+					code: clientRouteArtifactReference(source),
+					map: null
+				};
+			}
+			if (!reusedLinkedTransform) {
+				const pageRoot = currentEnvironment === "client" && !isSymbolOnlySourceRequest(id) && isModuleEntry(this, id);
+				const artifactChildMaterializations = currentEnvironment === "client" && clientRouteArtifactMaterializations.has(source) ? clientRouteArtifactMaterializations.get(source) : pageRoot || materializedRenderDataReach !== void 0 ? await materializeArtifactChildren.call(this, source, getRoot(), transformed.artifactChildren) : {};
+				if (Object.keys(artifactChildMaterializations).length > 0) {
+					linkedTransformInput = {
+						...linkedTransformInput,
+						artifactChildMaterializations
+					};
+					transformed = await transformTsrxModuleWithPrerenderWakeClosure(linkedTransformInput, false);
+				}
+			}
+			if (!renderDataRequest) registerTransformArtifacts({
+				owner: cacheKey,
+				source,
+				manifestSource,
+				result: transformed,
+				virtualModules,
+				moduleMetadata,
+				moduleLinkArtifacts,
+				transformVirtualModules,
+				virtualModuleOwners,
+				executionLogEstimatedSizes,
+				executionLogEmittedIds,
+				dev,
+				environment: currentEnvironment,
+				finalPublication: false,
+				tracksSourceClaimPublication: false,
+				updateDevPrerenderHashes: internalOptions.updateDevPrerenderHashes
+			});
+			else {
+				moduleMetadata.recordCaptureMetadata(source, transformed.manifest);
+				moduleMetadata.recordSymbolClaims(manifestSource, renderDataClaimManifest(transformed.manifest, manifestSource));
+				moduleLinkArtifacts.set(source, {
+					interfaceHash: transformed.interfaceHash,
+					moduleGraphInterface: transformed.moduleGraphInterface,
+					moduleImports: transformed.moduleImports
+				});
+			}
+			const resolvedInterfaceImports = await resolveImportedModuleInterfaces.call(this, manifestSource, transformed.moduleImports);
+			const resolvedChildren = await resolveImportedChildren.call(this, manifestSource, transformed.manifest);
+			for (const child of resolvedChildren) {
+				importedChildren.set(importedChildKey(child), child);
+				importedChildSources.add(child.source);
+			}
+			await forceImportedModules.call(this, uniqueImportedModules([...resolvedInterfaceImports, ...resolvedChildren]), moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
+			for (const child of resolvedChildren) if (internalOptions.dev === true) {
+				await recoverImportedChildMetadata(child, currentEnvironment);
+				validateImportedChild(child, moduleMetadata, transformed.manifest);
+			}
+			const linkedChildHasBrowserTriggers = linkedChildrenHaveBrowserTriggers(resolvedChildren, moduleMetadata, prerenderWakeCapabilities);
+			if (!reusedLinkedTransform && (resolvedChildren.length > 0 || resolvedInterfaceImports.length > 0)) {
+				const symbols = importedSymbolInputs(resolvedChildren, moduleMetadata);
+				const renderDataImportSources = materializedRenderDataReach ? Object.fromEntries(resolvedInterfaceImports.map((imported) => [imported.specifier, materializedReachedRenderDataSource(imported.source, materializedRenderDataReach)])) : void 0;
+				linkedTransformInput = {
+					...linkedTransformInput,
+					symbols,
+					importedModuleInterfaces: importedModuleInterfaces(resolvedInterfaceImports, moduleLinkArtifacts),
+					...renderDataImportSources ? { renderDataImportSources } : {}
+				};
+				transformed = await transformTsrxModuleWithPrerenderWakeClosure(linkedTransformInput, linkedChildHasBrowserTriggers);
+			}
+			prerenderWakeCapabilities.set(source, manifestHasBrowserTriggers(transformed.manifest) || linkedChildHasBrowserTriggers);
+			if (publishesClientClaims && !isClientPrimarySourceRequest(id) && internalOptions.prerenderWakeChannel === true && typeof this.getModuleInfo === "function") {
+				const aggregateInput = {
+					...linkedTransformInput,
+					clientOutput: void 0,
+					prerenderWakeFacade: false,
+					prerenderWakeVariant: false
+				};
+				let aggregate = await transformTsrxModuleWithPrerenderWakeClosure(aggregateInput, linkedChildHasBrowserTriggers);
+				const aggregateChildren = await resolveImportedChildren.call(this, source, aggregate.manifest);
+				await forceImportedModules.call(this, aggregateChildren, moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
+				let aggregateSymbols = importedSymbolInputs(aggregateChildren, moduleMetadata);
+				for (let attempt = 0; importedClaimsMissing(aggregateChildren, aggregateSymbols, moduleMetadata); attempt += 1) {
+					if (attempt === 9) throw new Error(`MARKLESS_IMPORTED_SYMBOL_CLAIMS_UNREADY: Source ${JSON.stringify(source)} could not seal imported symbol claims after final publications.`);
+					await new Promise((resolve) => setTimeout(resolve, 0));
+					for (const child of aggregateChildren) await moduleMetadata.sealSourceSymbolClaims(child.source);
+					aggregateSymbols = importedSymbolInputs(aggregateChildren, moduleMetadata);
+				}
+				aggregate = await transformTsrxModuleWithPrerenderWakeClosure({
+					...aggregateInput,
+					symbols: aggregateSymbols
+				}, linkedChildHasBrowserTriggers);
+				const resolver = aggregate.virtualModules.find((module) => module.type === "resolver");
+				if (resolver) transformed = {
+					...transformed,
+					virtualModules: transformed.virtualModules.map((module) => module.type === "resolver" ? resolver : module)
+				};
+			}
+			if (!renderDataRequest) registerTransformArtifacts({
+				owner: cacheKey,
+				source,
+				manifestSource,
+				result: transformed,
+				virtualModules,
+				moduleMetadata,
+				moduleLinkArtifacts,
+				transformVirtualModules,
+				virtualModuleOwners,
+				executionLogEstimatedSizes,
+				executionLogEmittedIds,
+				dev,
+				environment: currentEnvironment,
+				finalPublication: true,
+				tracksSourceClaimPublication: publishesClientClaims,
+				replaceOwnedArtifacts: true,
+				updateDevPrerenderHashes: internalOptions.updateDevPrerenderHashes
+			});
+			else {
+				moduleMetadata.recordCaptureMetadata(source, transformed.manifest);
+				moduleMetadata.recordSymbolClaims(manifestSource, renderDataClaimManifest(transformed.manifest, manifestSource));
+			}
+			linkedTransformCache.set(cacheKey, {
+				source,
+				manifestSource,
+				code,
+				importedInterfaceHashes: importedInterfaceHashSignature(resolvedInterfaceImports, moduleLinkArtifacts),
+				importedSymbolClaims: importedSymbolClaimSignature(uniqueImportedModules([...resolvedInterfaceImports, ...resolvedChildren]), moduleMetadata),
+				input: linkedTransformInput,
+				result: transformed,
+				linkedChildHasBrowserTriggers
+			});
+			if (currentEnvironment === "client" && isClientPrimarySourceRequest(id)) transformedClientPrimarySources.add(source);
+			if (currentEnvironment === "client" && renderDataRequest) {
+				const renderDataModule = transformed.virtualModules.find((module) => module.type === "render-data");
+				if (renderDataModule) {
+					const styleModules = transformed.virtualModules.filter((module) => module.type === "style");
+					registerRenderDataStyles({
+						owner: cacheKey,
+						source,
+						modules: styleModules,
+						virtualModules,
+						transformVirtualModules,
+						virtualModuleOwners,
+						dev
+					});
+					return {
+						code: [...styleModules.map((module) => `import ${JSON.stringify(module.id)};`), renderDataModule.source].join("\n"),
+						map: null
+					};
+				}
+			}
+			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" && prerenderWakeRequest) {
+				const wakeModule = transformed.virtualModules.find((module) => module.type === "prerender-wake");
+				return wakeModule ? {
+					code: `export { resumeContainerEvent } from ${JSON.stringify(wakeModule.id)};`,
+					map: null
+				} : {
+					code: [
+						"export async function resumeContainerEvent() {",
+						"	throw new Error('MARKLESS_PRERENDER_WAKE_ROUTE_INELIGIBLE');",
+						"}"
+					].join("\n"),
+					map: null
+				};
+			}
+			if (currentEnvironment === "client" && !internalOptions.dev) for (const module of transformed.virtualModules.filter((item) => {
+				if (item.type === "symbol") return true;
+				if (item.type === "trigger-group") return true;
+				if (item.type === "settle") return clientSymbolEntrySources.has(source);
+				if (item.type === "resolver") return (importedChildSources.has(source) || (transformed.manifest.captureMetadata?.boundResolverRows?.length ?? 0) > 0) && !emittedClientResolverSources.has(source);
+				return (item.type === "resume" || item.type === "prerender-wake") && 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, moduleMetadata);
+				if (getEnvironment(this) !== "client") return;
+				recordProductionResumeModuleUrls(bundle, internalOptions.productionResumeModuleUrls, internalOptions.publicPath);
+				if (internalOptions.prerenderWakeChannel === true) {
+					recordProductionPrerenderWakeModuleUrls(bundle, internalOptions.productionPrerenderWakeModuleUrls, internalOptions.publicPath);
+					recordProductionSettleModuleUrls(bundle, internalOptions.productionSettleModuleUrls ??= /* @__PURE__ */ new Map(), internalOptions.publicPath);
+				}
+				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 emittedSymbolClaims = moduleMetadata.emittedSymbolClaimMap(emittedBundleModuleIds(manifestBundle));
+				const attributionClaims = [...moduleMetadata.symbolClaimManifests()];
+				const tableIntegrity = verifyGeneratedSymbolTableRoutes(manifestBundle, emittedSymbolClaims.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, emittedSymbolClaims.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,
+					wakeChunks: internalOptions.prerender || internalOptions.prerenderWakeChannel === true ? productionWakeModuleChunks(bundle) : void 0,
+					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(attributionClaims, getRoot(), importedChildren.values()) : void 0, {
+					executionLogActive: executionLogInjection !== null,
+					hookedIds: executionLogEmittedIds
+				}));
+				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])))
+				});
+			}
+		}
+	};
+	function registerClientRouteArtifactSource(source) {
+		if (clientRouteArtifactSources.has(source)) return;
+		if (transformedClientPrimarySources.has(source)) {
+			if (internalOptions.dev !== true) throw new Error(`MARKLESS_ROUTE_ARTIFACT_REGISTERED_LATE: Client route artifact ${JSON.stringify(source)} was registered after its primary module transformed. Register every production route artifact before transformation begins.`);
+			invalidateAllGeneratedModules(source, "client");
+			transformedClientPrimarySources.delete(source);
+			internalOptions.devServer?.invalidateModule?.(source, "client");
+		}
+		clientRouteArtifactSources.add(source);
+	}
+	return plugin;
+}
+async function materializeArtifactChildren(parent, appRoot, candidates) {
+	const materialized = {};
+	const loaded = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		if (TSRX_SOURCE_FILE.test(candidate.importSource)) continue;
+		const resolved = await this.resolve(candidate.importSource, parent, { skipSelf: true });
+		const id = typeof resolved === "string" ? resolved : resolved?.id;
+		if (!id) continue;
+		const source = pathname(id);
+		if (!appRoot || !isAbsolute(source) || !existsSync(source) || !statSync(source).isFile() || isInsideRoot(source, appRoot)) continue;
+		let module = loaded.get(source);
+		if (!module) {
+			module = await import(pathToFileURL(source).href);
+			loaded.set(source, module);
+		}
+		const component = candidate.importKind === "default" ? module.default : candidate.importKind === "namespace" ? module : module[candidate.importedName ?? candidate.componentName];
+		const renderSsr = component?.renderSsr;
+		if (typeof renderSsr !== "function") continue;
+		const underivable = candidate.props.find((prop) => prop.kind !== "serializable");
+		if (underivable || candidate.hasChildren && !candidate.projection) {
+			const prop = underivable?.name ?? "children";
+			throw new Error(`MARKLESS_ARTIFACT_CHILD_PROP_NOT_BUILD_KNOWN: <${candidate.componentName}> prop ${JSON.stringify(prop)} must be a build-known static value. Runtime component execution is not a fallback.`);
+		}
+		const props = Object.fromEntries(candidate.props.map((prop) => [prop.name, prop.value]));
+		if (candidate.projection) props.children = candidate.projection.markup;
+		const output = await renderSsr.call(component, props);
+		if (!output || typeof output !== "object" || typeof output.html !== "string") throw new Error(`MARKLESS_ARTIFACT_CHILD_RENDER_INVALID: <${candidate.componentName}> renderSsr must return static HTML.`);
+		const result = output;
+		materialized[candidate.edgeId] = {
+			html: result.html,
+			elementCount: typeof result.elementCount === "number" ? result.elementCount : 0,
+			...result.state ? { state: result.state } : {},
+			...result.view ? { view: result.view } : {},
+			...result.coordinates ? { coordinates: result.coordinates } : {},
+			...result.structure ? { structure: result.structure } : {},
+			...Array.isArray(result.structureTokens) ? { structureTokens: result.structureTokens } : {}
+		};
+	}
+	return materialized;
+}
+function isInsideRoot(source, root) {
+	const path = relative(root, source);
+	return path === "" || !isAbsolute(path) && path !== ".." && !path.startsWith("../");
+}
+function isModuleEntry(context, id) {
+	try {
+		return context.getModuleInfo?.(id)?.isEntry === true;
+	} catch {
+		return false;
+	}
+}
+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
+		};
+	}));
+}
+async function resolveImportedModuleInterfaces(parent, moduleImports) {
+	return await Promise.all(moduleImports.filter((moduleImport) => TSRX_SOURCE_FILE.test(moduleImport.source)).map(async (moduleImport) => {
+		const resolvedImport = await this.resolve(moduleImport.source, parent, { skipSelf: true });
+		const resolvedId = typeof resolvedImport === "string" ? resolvedImport : resolvedImport && "id" in resolvedImport ? String(resolvedImport.id) : fallbackImportedSource(parent, moduleImport.source);
+		return {
+			parent,
+			specifier: moduleImport.source,
+			source: pathname(resolvedId)
+		};
+	}));
+}
+async function forceImportedModules(imports, artifacts, metadata, options, environment) {
+	for (const imported of imports) {
+		if (!artifacts.has(imported.source)) {
+			if (options.dev === true) await options.devServer?.transformRequest(imported.source, environment);
+			else if (typeof this.load === "function") await this.load({ id: imported.source });
+		}
+		const captureMetadata = metadata.captureMetadataForSource(imported.source);
+		if (environment !== "client") continue;
+		if (!captureMetadata?.extractedSymbols.length) {
+			await metadata.sealSourceSymbolClaims(imported.source);
+			continue;
+		}
+		const wakeSource = withQuery(imported.source, { "markless-prerender-wake": null });
+		const completeWakeVariants = options.prerenderWakeChannel === true;
+		const claimSources = [
+			...completeWakeVariants ? [imported.source] : [],
+			...completeWakeVariants ? [withQuery(imported.source, { "markless-resume": null })] : [],
+			...completeWakeVariants ? [wakeSource] : [],
+			withQuery(imported.source, { "markless-symbols": null })
+		];
+		if (typeof this.getModuleInfo === "function") metadata.expectSourceSymbolClaims(imported.source, claimSources);
+		if (options.dev === true) await Promise.all(claimSources.map((source) => options.devServer?.transformRequest(source, environment)));
+		else if (typeof this.load === "function") await Promise.all(claimSources.map((id) => this.load?.({ id })));
+		await metadata.sealSourceSymbolClaims(imported.source);
+	}
+}
+function importedModuleInterfaces(imports, artifacts) {
+	return Object.fromEntries(imports.flatMap((imported) => {
+		const artifact = artifacts.get(imported.source);
+		return artifact ? [[imported.specifier, artifact.moduleGraphInterface]] : [];
+	}));
+}
+function uniqueImportedModules(imports) {
+	return [...new Map(imports.map((imported) => [`${imported.parent}\0${imported.specifier}\0${imported.source}`, imported])).values()];
+}
+function importedSymbolInputs(children, metadata) {
+	return children.flatMap((child) => {
+		const captureMetadata = metadata.captureMetadataForSource(child.source);
+		const claimManifest = sourceSymbolManifest(metadata, child.source);
+		if (!captureMetadata || !claimManifest || !child.componentEdgeId) return [];
+		return claimManifest.symbols.flatMap((symbol) => {
+			const captureSymbol = 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 importedClaimsMissing(children, symbols, metadata) {
+	return children.some((child) => {
+		return metadata.captureMetadataForSource(child.source)?.extractedSymbols.some((symbol) => symbol.captureSlots.some((slot) => slot.propName !== void 0)) === true && !symbols.some((symbol) => symbol.componentEdgeId === child.componentEdgeId);
+	});
+}
+function linkedChildrenHaveBrowserTriggers(children, metadata, capabilities) {
+	return children.some((child) => {
+		const manifest = sourceSymbolManifest(metadata, child.source);
+		return manifest !== void 0 && manifestHasBrowserTriggers(manifest) || capabilities.get(child.source) === true;
+	});
+}
+function sourceSymbolManifest(metadata, source) {
+	const resolverId = `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodeURIComponent(source)}`;
+	return metadata.sourceSymbolClaims(source, resolverId);
+}
+function manifestHasBrowserTriggers(manifest) {
+	return manifest.symbols.some((symbol) => symbol.kind === "event-handler" || symbol.kind === "behavior");
+}
+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, metadata, parentManifest) {
+	const parentMetadata = parentManifest?.captureMetadata ?? metadata.captureMetadataForSource(pathname(child.parent));
+	const childMetadata = metadata.captureMetadataForSource(child.source);
+	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 canonicalExecutionAttributionSource(source) {
+	return source.split("?")[0].split("#")[0];
+}
+function canonicalExecutionAttributionNodes(manifests) {
+	const routesBySource = /* @__PURE__ */ new Map();
+	const sorted = [...manifests].sort((left, right) => left.source.localeCompare(right.source));
+	for (const manifest of sorted) {
+		const source = canonicalExecutionAttributionSource(manifest.source);
+		const routes = routesBySource.get(source) ?? /* @__PURE__ */ new Map();
+		for (const route of manifest.symbolRoutes ?? []) if (!routes.has(route.prefix)) routes.set(route.prefix, route.importSource);
+		routesBySource.set(source, routes);
+	}
+	return new Map([...routesBySource].map(([source, routes]) => [source, {
+		source,
+		symbolRoutes: [...routes].map(([prefix, importSource]) => ({
+			prefix,
+			importSource
+		}))
+	}]));
+}
+function executionAttributionRoots(nodes, childrenByRoute) {
+	const children = /* @__PURE__ */ new Set();
+	for (const node of nodes.values()) for (const route of node.symbolRoutes) {
+		const child = resolvedRouteSource(node.source, route.importSource, childrenByRoute);
+		if (nodes.has(child)) children.add(child);
+	}
+	return [...nodes.keys()].filter((source) => !children.has(source));
+}
+function executionAttributionTables(manifests, root, children) {
+	const nodes = canonicalExecutionAttributionNodes(manifests);
+	const childrenByRoute = new Map([...children].map((child) => [routeKey(canonicalExecutionAttributionSource(child.parent), child.specifier), canonicalExecutionAttributionSource(child.source)]).sort((left, right) => left[0].localeCompare(right[0]) || left[1].localeCompare(right[1])));
+	return Object.fromEntries(executionAttributionRoots(nodes, childrenByRoute).sort().map((source) => [executionAttributionRouteKey(source, root), flattenExecutionAttributionScopes(source, nodes, childrenByRoute)]));
+}
+function executionAttributionRouteKey(source, root) {
+	const prefix = root ? `${root.replace(/[/\\]+$/, "")}/` : "";
+	return (prefix && source.startsWith(prefix) ? source.slice(prefix.length) : source).replace(/^[/\\]+/, "");
+}
+function flattenExecutionAttributionScopes(root, nodes, childrenByRoute) {
+	const scopes = {};
+	const visit = (source, scope, seen) => {
+		if (seen.has(source)) return;
+		scopes[scope] = encodedSymbolSource(source);
+		const manifest = nodes.get(source);
+		for (const route of manifest?.symbolRoutes ?? []) {
+			const child = resolvedRouteSource(source, route.importSource, childrenByRoute);
+			if (!nodes.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();
+	const renderDataHashes = /* @__PURE__ */ new Map();
+	for (const module of input.result.virtualModules) {
+		if (input.finalPublication === false && module.type === "resolver") continue;
+		const isClientSymbol = input.environment === "client" && module.type === "symbol";
+		const stored = isClientSymbol ? {
+			...module,
+			source: requalifyExecutionLogModuleHook(module.source, module.id)
+		} : module;
+		const current = input.virtualModules.get(module.id);
+		if (module.type === "resolver" && current?.type === "resolver") {
+			const currentClaims = new Set(current.symbolClaims ?? []);
+			const nextClaims = new Set(module.symbolClaims ?? []);
+			const currentContainsNext = [...nextClaims].every((claim) => currentClaims.has(claim));
+			const nextContainsCurrent = [...currentClaims].every((claim) => nextClaims.has(claim));
+			if (currentContainsNext && !nextContainsCurrent) continue;
+			if (!currentContainsNext && !nextContainsCurrent) throw new Error(`MARKLESS_RESOLVER_CLAIMS_DIVERGED: Resolver ${JSON.stringify(module.id)} has incompatible final claim sets.`);
+		}
+		if (module.type !== "render-data" || current?.type !== "render-data" || current.canonicalRenderData !== true || module.canonicalRenderData === true) input.virtualModules.set(module.id, stored);
+		ids.add(module.id);
+		const owners = input.virtualModuleOwners.get(module.id) ?? /* @__PURE__ */ new Set();
+		owners.add(input.owner);
+		input.virtualModuleOwners.set(module.id, owners);
+		if (module.type === "render-data") renderDataHashes.set(resolveVirtualId(module.id), renderDataHash(module.source));
+		if (isClientSymbol) {
+			input.executionLogEstimatedSizes.set(module.id, stored.source.length);
+			if (hasExecutionLogModuleHook(stored.source)) input.executionLogEmittedIds.set(module.id, module.id);
+		}
+	}
+	input.moduleMetadata.recordCaptureMetadata(input.source, input.result.manifest);
+	if (input.finalPublication !== false) {
+		const symbolClaim = emittedSymbolClaim(input.moduleMetadata, input.source, input.manifestSource, input.result.manifest, input.result.virtualModules);
+		input.moduleMetadata.recordSymbolClaims(symbolClaim.owner, symbolClaim.manifest);
+		if (input.tracksSourceClaimPublication === true) input.moduleMetadata.finishSourceSymbolClaims(input.source, input.manifestSource);
+	}
+	input.moduleLinkArtifacts.set(input.source, {
+		moduleGraphInterface: input.result.moduleGraphInterface,
+		interfaceHash: input.result.interfaceHash,
+		moduleImports: input.result.moduleImports
+	});
+	const previouslyOwned = input.transformVirtualModules.get(input.owner) ?? /* @__PURE__ */ new Set();
+	if (input.replaceOwnedArtifacts === true) {
+		for (const staleId of previouslyOwned) {
+			if (ids.has(staleId)) continue;
+			const owners = input.virtualModuleOwners.get(staleId);
+			owners?.delete(input.owner);
+			if (!owners || owners.size === 0) {
+				input.virtualModuleOwners.delete(staleId);
+				input.virtualModules.delete(staleId);
+			}
+		}
+		input.transformVirtualModules.set(input.owner, ids);
+	} else input.transformVirtualModules.set(input.owner, new Set([...previouslyOwned, ...ids]));
+	input.dev.record(input.source, ids, input.environment);
+	if (renderDataHashes.size > 0) input.updateDevPrerenderHashes?.(renderDataHashes);
+}
+function replaceClaimsWithPrerenderWakeOwner(metadata, source) {
+	for (const emittedModule of metadata.symbolClaimMap().keys()) if (pathname(emittedModule) === source && (emittedModule === source || isResumeSourceRequest(emittedModule))) metadata.deleteSymbolClaims(emittedModule);
+}
+function emittedSymbolClaim(metadata, source, emittedModule, manifest, virtualModules) {
+	const claim = manifestForSource(manifest, emittedModule);
+	if (isPrerenderWakeSourceRequest(emittedModule) && manifest.symbols.length > 0) {
+		replaceClaimsWithPrerenderWakeOwner(metadata, source);
+		const resolver = virtualModules.find((module) => module.type === "resolver");
+		if (!resolver) throw new Error("MARKLESS_PRERENDER_WAKE_RESOLVER_MISSING");
+		return {
+			owner: resolver.id,
+			manifest: {
+				...manifestForSource(manifest, source),
+				resolver: { virtualModuleId: resolver.id }
+			}
+		};
+	}
+	return {
+		owner: emittedModule,
+		manifest: metadata.hasSymbolClaims(manifest.resolver.virtualModuleId) && (emittedModule === source || isResumeSourceRequest(emittedModule)) ? {
+			...claim,
+			symbols: []
+		} : claim
+	};
+}
+function registerRenderDataStyles(input) {
+	if (input.modules.length === 0) return;
+	const ids = new Set(input.transformVirtualModules.get(input.owner) ?? []);
+	for (const module of input.modules) {
+		input.virtualModules.set(module.id, module);
+		ids.add(module.id);
+		const owners = input.virtualModuleOwners.get(module.id) ?? /* @__PURE__ */ new Set();
+		owners.add(input.owner);
+		input.virtualModuleOwners.set(module.id, owners);
+	}
+	input.transformVirtualModules.set(input.owner, ids);
+	input.dev.record(input.source, input.modules.map((module) => module.id), "client");
+}
+function manifestForSource(manifest, source) {
+	return manifest.source === source ? manifest : {
+		...manifest,
+		source
+	};
+}
+function renderDataClaimManifest(manifest, source) {
+	return {
+		...manifestForSource(manifest, source),
+		symbols: []
+	};
+}
+function renderDataHash(source) {
+	let hash = 2166136261;
+	for (let index = 0; index < source.length; index += 1) {
+		hash ^= source.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return `mrd1-${(hash >>> 0).toString(36)}`;
+}
+function importedInterfaceHashSignature(imports, artifacts) {
+	return imports.map((imported) => [
+		imported.specifier,
+		imported.source,
+		artifacts.get(imported.source)?.interfaceHash ?? "missing"
+	].map(encodeURIComponent).join(":")).sort().join("|");
+}
+function importedSymbolClaimSignature(imports, metadata) {
+	return [...new Set(imports.map((imported) => imported.source))].sort().map((source) => JSON.stringify([source, sourceSymbolManifest(metadata, source)?.symbols ?? []])).join("|");
+}
+function isRenderDataOnlyTransformChange(previous, next) {
+	if (previous.interfaceHash !== next.interfaceHash || previous.code !== next.code) return false;
+	if (JSON.stringify(previous.moduleImports) !== JSON.stringify(next.moduleImports)) return false;
+	const withoutRenderData = (result) => result.virtualModules.filter((module) => module.type !== "render-data");
+	if (JSON.stringify(withoutRenderData(previous)) !== JSON.stringify(withoutRenderData(next))) return false;
+	return JSON.stringify(previous.manifest) === JSON.stringify(next.manifest);
+}
+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 isRenderDataSourceRequest(id) {
+	return MARKLESS_RENDER_DATA_SOURCE_QUERY_RE.test(id);
+}
+function materializedRenderDataReachRoot(id, source, materializations) {
+	if (materializations.has(source)) return source;
+	return new URLSearchParams(parsePath(id).search).get(MARKLESS_REACHED_FROM_SOURCE_QUERY) ?? void 0;
+}
+function materializedReachedRenderDataSource(source, routeRoot) {
+	return withQuery(source, {
+		"markless-render-data": null,
+		[MARKLESS_REACHED_FROM_SOURCE_QUERY]: routeRoot
+	});
+}
+function isPrerenderWakeSourceRequest(id) {
+	return MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE.test(id);
+}
+function isClientPrimarySourceRequest(id) {
+	return !(MARKLESS_SYMBOL_SOURCE_QUERY_RE.test(id) || MARKLESS_RESUME_SOURCE_QUERY_RE.test(id) || MARKLESS_RENDER_DATA_SOURCE_QUERY_RE.test(id) || MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE.test(id) || MARKLESS_ROUTE_SOURCE_QUERY_RE.test(id));
+}
+function clientRouteArtifactReference(source) {
+	const symbolSource = source.includes("?") ? `${source}&markless-symbols` : `${source}?markless-symbols`;
+	const renderDataSource = source.includes("?") ? `${source}&markless-render-data` : `${source}?markless-render-data`;
+	return [
+		`const [symbolModule, renderDataModule] = await Promise.all([import(${JSON.stringify(symbolSource)}), import(${JSON.stringify(renderDataSource)})]);`,
+		"const marklessRouteArtifact = {",
+		"	renderData: renderDataModule.marklessPrerenderData,",
+		"	loadSymbol: symbolModule.loadSymbol,",
+		"};",
+		"export default marklessRouteArtifact;"
+	].join("\n");
+}
+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 resolverVirtualModuleSourceFile(id) {
+	const prefix = `${MARKLESS_VIRTUAL_PREFIX}resolver:`;
+	return id.startsWith(prefix) ? decodeURIComponent(id.slice(prefix.length)) : null;
+}
+function sourceForTriggerGroupVirtualImporter(importer) {
+	if (!importer) return null;
+	return triggerGroupVirtualModuleSourceFile(normalizeVirtualId(importer));
+}
+function sourceForPrerenderWakeVirtualImporter(importer) {
+	if (!importer) return null;
+	const match = normalizeVirtualId(importer).match(PRERENDER_WAKE_VIRTUAL_ID_RE);
+	return match?.[1] ? decodeURIComponent(match[1]) : null;
+}
+function sourceForSettleVirtualImporter(importer) {
+	if (!importer) return null;
+	const match = normalizeVirtualId(importer).match(SETTLE_VIRTUAL_ID_RE);
+	return match?.[1] ? decodeURIComponent(match[1]) : null;
+}
+function recordProductionSettleModuleUrls(bundle, urls, publicPath) {
+	for (const output of Object.values(bundle)) {
+		if (!output || typeof output !== "object") continue;
+		const chunk = output;
+		if (chunk.type !== "chunk" || typeof chunk.facadeModuleId !== "string" || typeof chunk.fileName !== "string") continue;
+		const source = sourceForSettleVirtualImporter(chunk.facadeModuleId);
+		if (source) urls.set(source, publicPath?.(chunk.fileName) ?? `/${chunk.fileName}`);
+	}
+}
+function recordProductionResumeModuleUrls(bundle, urls, publicPath) {
+	if (!urls) return;
+	for (const output of Object.values(bundle)) {
+		if (!output || typeof output !== "object") continue;
+		const chunk = output;
+		if (chunk.type !== "chunk" || typeof chunk.facadeModuleId !== "string" || typeof chunk.fileName !== "string") continue;
+		const source = sourceForResumeVirtualImporter(chunk.facadeModuleId);
+		if (source) urls.set(source, publicPath?.(chunk.fileName) ?? `/${chunk.fileName}`);
+	}
+}
+function recordProductionPrerenderWakeModuleUrls(bundle, urls, publicPath) {
+	if (!urls) return;
+	for (const output of Object.values(bundle)) {
+		if (!output || typeof output !== "object") continue;
+		const chunk = output;
+		if (chunk.type !== "chunk" || typeof chunk.facadeModuleId !== "string" || typeof chunk.fileName !== "string") continue;
+		const source = sourceForPrerenderWakeVirtualImporter(chunk.facadeModuleId);
+		if (source) urls.set(source, publicPath?.(chunk.fileName) ?? `/${chunk.fileName}`);
+	}
+}
+function productionWakeModuleChunks(bundle) {
+	const chunks = [];
+	for (const output of Object.values(bundle)) {
+		if (!output || typeof output !== "object") continue;
+		const chunk = output;
+		if (chunk.type === "chunk" && typeof chunk.facadeModuleId === "string" && typeof chunk.fileName === "string" && (sourceForResumeVirtualImporter(chunk.facadeModuleId) || sourceForPrerenderWakeVirtualImporter(chunk.facadeModuleId))) chunks.push(stripBuildPrefix(chunk.fileName));
+	}
+	return chunks;
+}
+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 emittedBundleModuleIds(bundle) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const output of Object.values(bundle)) {
+		if (!output || typeof output !== "object") continue;
+		const chunk = output;
+		if (chunk.type !== "chunk") continue;
+		if (typeof chunk.facadeModuleId === "string") ids.add(normalizeVirtualId(chunk.facadeModuleId));
+		if (Array.isArray(chunk.moduleIds)) {
+			for (const id of chunk.moduleIds) if (typeof id === "string") ids.add(normalizeVirtualId(id));
+		}
+	}
+	return ids;
+}
+function resolveVirtualId(id) {
+	if (id.startsWith("\0")) return id;
+	return `\0${id}`;
+}
+function pathname(id) {
+	return parsePath(id).pathname;
+}
+//#endregion
+export { createBuildMetadata as a, collectHeadLinkInjections as c, outputDefaults as d, convertManifestToBundleGraph as f, marklessServer as i, MARKLESS_BUILD_PREFIX as l, marklessClient as n, preflightTsrxModuleDiagnostics as o, createPreloadGraphAdder as p, marklessLib as r, transformTsrxModule as s, createMarklessRolldownPlugin as t, MARKLESS_BUNDLE_GRAPH as u };