@markless/bundler 0.8.0 → 0.10.0

package/dist/planned-landing-BHy22Yf5.js

@@ -0,0 +1,2291 @@
+import { c as createCompileErrorPayload, s as MarklessCompileError } from "./dev-error-BEduK_R3.js";
+import { $ as EXECUTION_LOG_CHUNK_MODULE_PATTERN, A as emitSourceModule, B as symbolVirtualModuleSourceFile, C as MARKLESS_VIRTUAL_PREFIX, D as emitOverlayLoaderInstall, E as demandsOverlay, F as resumeVirtualModuleId, G as sharedInlineSourcesModuleId, H as emitSymbolRouteTable, I as rewriteSymbolModuleExport, J as compilePrerenderInlineResumerSources, L as scopedSymbolExportName, M as payloadModule, N as prerenderWakeVirtualModuleId, O as emitResumeModule, R as settleVirtualModuleId, _ as sourceForModuleId, ct as normalizeExecutionLogMode, k as emitSettleModule, ot as injectExecutionLogModuleHook, q as compileInlineResumerSources, z as symbolVirtualModuleId } from "./route-pack-groups-ByQmKKom.js";
+import { artifactChildCandidates, collectTsrxModuleDiagnostics, compileTsrxModule, componentEdgeSymbolRoutes, emitSymbolResolverModule, importedNestedRepeats, importedRowBranchMints, importedRowComponentMints, importedRowSlotReaders, importedRowTemplateMints, importedSymbolRoutes, linkedRenderDataBoundarySymbols, moduleInterfaceHash, parseJavaScriptModule, prerenderInterfacesComplete, propsDeciding, rowsDecidedBy } from "@markless/compiler";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, normalize, resolve } from "pathe";
+import { joinURL, parsePath, withQuery, withoutLeadingSlash } from "ufo";
+import { parseSync, transformSync } from "rolldown/experimental";
+import { PROTOCOL_EVENT_ACTION_KIND, PROTOCOL_IDLE_EVENT_NAME, PROTOCOL_PROP_GRAPH_NODE_PREFIX, createStorageSeedMetadataFromGraphNodeId, jsonSourceWithNonFiniteNumbers, protocolEventActionKind } from "@markless/serializer";
+import { fileURLToPath } from "node:url";
+//#region src/build/preload-plan.ts
+const DEFAULT_MIN_PROBABILITY = 0;
+const JAVASCRIPT_MODULE_RE = /\.(?:mjs|js)(?:[?#].*)?$/;
+const PRIORITY_RANK = {
+	high: 2,
+	auto: 1,
+	low: 0
+};
+function planModulePreloadUrls(input) {
+	return planModulePreloads(input).map((preload) => preload.href);
+}
+function planModulePreloads(input) {
+	const minProbability = input.minProbability ?? DEFAULT_MIN_PROBABILITY;
+	const maxPreloads = input.maxPreloads ?? Number.POSITIVE_INFINITY;
+	const graph = parseBundleGraph(input.bundleGraph);
+	const planned = /* @__PURE__ */ new Map();
+	const bestVisitByNode = /* @__PURE__ */ new Map();
+	let order = 0;
+	const addModule = (name, probability, priority, fetchPriority) => {
+		if (!isPreloadableModuleName(name)) return;
+		const href = preloadHref(input.base, name);
+		const existing = planned.get(href);
+		const nextRank = PRIORITY_RANK[priority];
+		const existingRank = existing ? PRIORITY_RANK[existing.priority] : -1;
+		if (existing && (existingRank > nextRank || existingRank === nextRank && existing.probability >= probability)) return;
+		planned.set(href, {
+			fetchPriority,
+			href,
+			name,
+			order: existing?.order ?? order++,
+			priority,
+			probability
+		});
+	};
+	const visit = (name, probability, priority, fetchPriority, seen, suppressed = false, suppressRootOnly = false) => {
+		if (probability < minProbability || planned.size >= maxPreloads) return;
+		if (!suppressed) {
+			const priorityRank = PRIORITY_RANK[priority];
+			const previousBest = bestVisitByNode.get(name);
+			if (previousBest && (previousBest.priorityRank > priorityRank || previousBest.priorityRank === priorityRank && previousBest.probability >= probability)) return;
+			bestVisitByNode.set(name, {
+				priorityRank,
+				probability
+			});
+		}
+		if (seen.has(name)) return;
+		const nextSeen = new Set(seen);
+		nextSeen.add(name);
+		const record = graph.get(name);
+		if (!record) {
+			if (!suppressed) addModule(name, probability, priority, fetchPriority);
+			return;
+		}
+		for (const dep of record.deps.filter((item) => item.kind === "static")) visit(dep.name, probability * dep.probability, priority, fetchPriority, nextSeen, suppressed && !suppressRootOnly);
+		if (!suppressed) addModule(name, probability, priority, fetchPriority);
+		for (const dep of record.deps.filter((item) => item.kind === "dynamic")) {
+			if (input.lazyChunks?.has(dep.name)) continue;
+			const edgeProbability = JAVASCRIPT_MODULE_RE.test(name) ? dep.probability : 1;
+			visit(dep.name, probability * edgeProbability, priority, fetchPriority, nextSeen, false);
+		}
+	};
+	for (const root of input.roots) {
+		const normalized = normalizeRoot(root);
+		visit(normalized.name, 1, normalized.priority, normalized.fetchPriority, /* @__PURE__ */ new Set(), normalized.edges === "dynamic-only" || normalized.edges === "dependencies-only", normalized.edges === "dependencies-only");
+	}
+	return [...planned.values()].sort((left, right) => {
+		const priority = PRIORITY_RANK[right.priority] - PRIORITY_RANK[left.priority];
+		if (priority !== 0) return priority;
+		return left.order - right.order;
+	}).slice(0, maxPreloads).map(({ order: _order, ...preload }) => preload);
+}
+function parseBundleGraph(graph) {
+	const records = /* @__PURE__ */ new Map();
+	if (!graph) return records;
+	let index = 0;
+	while (index < graph.length) {
+		const name = graph[index++];
+		if (typeof name !== "string") continue;
+		const deps = [];
+		let probability = 1;
+		let kind = "static";
+		while (typeof graph[index] === "number") {
+			const marker = graph[index++];
+			if (marker < 0) {
+				probability = -marker / 10;
+				kind = "dynamic";
+				continue;
+			}
+			const dep = graph[marker];
+			if (typeof dep === "string") deps.push({
+				name: dep,
+				kind,
+				probability
+			});
+		}
+		records.set(name, {
+			name,
+			deps
+		});
+	}
+	return records;
+}
+function preloadHref(base, name) {
+	if (!base || /^(?:[a-z]+:)?\/\//i.test(name)) return name;
+	return joinURL(base, name);
+}
+function isPreloadableModuleName(name) {
+	return JAVASCRIPT_MODULE_RE.test(name) || isViteDevModuleUrl(name);
+}
+function isViteDevModuleUrl(name) {
+	return (name.startsWith("/") || name.startsWith("@id/")) && /(?:^|[?&])import(?:[&#]|$)/.test(name);
+}
+function normalizeRoot(root) {
+	if (typeof root === "string") return {
+		name: root,
+		priority: "auto",
+		fetchPriority: "auto"
+	};
+	const priority = root.priority ?? "auto";
+	return {
+		name: root.name,
+		priority,
+		edges: root.edges,
+		fetchPriority: root.fetchPriority ?? priorityToFetchPriority(priority)
+	};
+}
+function priorityToFetchPriority(priority) {
+	if (priority === "auto") return "auto";
+	return priority;
+}
+//#endregion
+//#region src/optimized-deps.ts
+const NESTED_DEPENDENCY = " > ";
+const RUNTIME_FUNCTIONS_PREFIX = "@markless/web/fns/";
+function optimizedDepsToInclude(specifiers, resolution) {
+	const root = resolve(resolution.root ?? "");
+	const preserveSymlinks = resolution.resolve?.preserveSymlinks === true;
+	const alias = resolution.resolve?.alias;
+	return specifiers.filter((specifier) => !servedFromSource(applyAlias(specifier.split(NESTED_DEPENDENCY)[0], alias), root, preserveSymlinks));
+}
+function includeOptimizedDeps(config, specifiers) {
+	const bundled = optimizedDepsToInclude(specifiers, config);
+	if (bundled.length === 0) return;
+	const optimizeDeps = config.optimizeDeps ??= {};
+	const include = optimizeDeps.include ?? [];
+	optimizeDeps.include = [...include, ...bundled.filter((specifier) => !include.includes(specifier))];
+}
+function runtimeFunctionSpecifiers(webEntry = import.meta.resolve?.("@markless/web")) {
+	if (!webEntry?.startsWith("file://")) return [];
+	let files;
+	try {
+		files = readdirSync(join(dirname(fileURLToPath(webEntry)), "fns"));
+	} catch {
+		return [];
+	}
+	return files.filter((file) => file.endsWith(".js")).map((file) => `@markless/core${NESTED_DEPENDENCY}${RUNTIME_FUNCTIONS_PREFIX}${file.slice(0, -3)}`);
+}
+function excludeSourceShippedDeps(config) {
+	const appManifest = nearestManifest(resolve(config.root ?? ""));
+	if (!appManifest) return;
+	const shipsSource = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (names, from) => {
+		for (const name of names) {
+			const directory = installedPackage(name, from);
+			if (directory === void 0 || seen.has(directory)) continue;
+			seen.add(directory);
+			const manifest = readManifest(join(directory, "package.json"));
+			if (manifest?.publishConfig?.marklessShipsSource !== true) continue;
+			if (!shipsSource.includes(name)) shipsSource.push(name);
+			visit(Object.keys(manifest.dependencies ?? {}), realpathOf(directory));
+		}
+	};
+	visit([...Object.keys(appManifest.manifest.dependencies ?? {}), ...Object.keys(appManifest.manifest.devDependencies ?? {})], appManifest.directory);
+	if (shipsSource.length === 0) return;
+	const optimizeDeps = config.optimizeDeps ??= {};
+	const exclude = optimizeDeps.exclude ?? [];
+	optimizeDeps.exclude = [...exclude, ...shipsSource.filter((name) => !exclude.includes(name))];
+}
+function readManifest(path) {
+	try {
+		return JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return;
+	}
+}
+function nearestManifest(root) {
+	for (let directory = root;; directory = dirname(directory)) {
+		const manifest = existsSync(join(directory, "package.json")) ? readManifest(join(directory, "package.json")) : void 0;
+		if (manifest) return {
+			directory,
+			manifest
+		};
+		if (dirname(directory) === directory) return void 0;
+	}
+}
+function applyAlias(specifier, alias) {
+	if (!alias) return specifier;
+	const entries = Array.isArray(alias) ? alias : Object.entries(alias).map(([find, replacement]) => ({
+		find,
+		replacement
+	}));
+	for (const { find, replacement } of entries) if (typeof find === "string") {
+		if (specifier === find || specifier.startsWith(`${find}/`)) return replacement + specifier.slice(find.length);
+	} else if (find.test(specifier)) return specifier.replace(find, replacement);
+	return specifier;
+}
+function servedFromSource(id, root, preserveSymlinks) {
+	const path = isAbsolute(id) || id.startsWith(".") ? resolve(root, id) : installedPackage(id, root);
+	if (path === void 0) return false;
+	return !`${preserveSymlinks ? normalize(path) : realpathOf(path)}/`.includes("/node_modules/");
+}
+function installedPackage(specifier, root) {
+	const segments = specifier.split("/");
+	const name = specifier.startsWith("@") ? segments.slice(0, 2).join("/") : segments[0];
+	for (let directory = root;; directory = dirname(directory)) {
+		const entry = join(directory, "node_modules", name);
+		if (existsSync(entry)) return entry;
+		if (dirname(directory) === directory) return void 0;
+	}
+}
+function realpathOf(path) {
+	try {
+		return normalize(realpathSync(path));
+	} catch {
+		return normalize(path);
+	}
+}
+const MARKLESS_BUILD_PREFIX = `build/`;
+const MARKLESS_BUNDLE_GRAPH = `${MARKLESS_BUILD_PREFIX}bundle-graph.json`;
+const MARKLESS_EXECUTION_SIZES = `${MARKLESS_BUILD_PREFIX}execution-sizes.json`;
+const MARKLESS_EXECUTION_DEMAND = `${MARKLESS_BUILD_PREFIX}execution-demand.json`;
+const MARKLESS_INTERACTION_CLOSURES = `${MARKLESS_BUILD_PREFIX}interaction-closures.json`;
+const MARKLESS_BYTE_ATTRIBUTION = `${MARKLESS_BUILD_PREFIX}byte-attribution.json`;
+const MARKLESS_SERVER_CHUNK_MAX_BYTES = 4194304;
+const MARKLESS_BUILD_METADATA_FILES = [
+	MARKLESS_BUNDLE_GRAPH,
+	MARKLESS_EXECUTION_SIZES,
+	MARKLESS_EXECUTION_DEMAND,
+	MARKLESS_INTERACTION_CLOSURES,
+	MARKLESS_BYTE_ATTRIBUTION
+];
+const MARKLESS_PUBLIC_BUILD_METADATA_FILES = [MARKLESS_EXECUTION_SIZES];
+const WEB_RUNTIME_CAPABILITY_GROUPS = [
+	{
+		name: "markless-direct-renderer",
+		test: fileBasenamePattern("direct")
+	},
+	{
+		name: "markless-resume-branches",
+		test: fileBasenamePattern("resume-branches", "resume-arm-records-lazy")
+	},
+	{
+		name: "markless-resume-behaviors",
+		test: fileBasenamePattern("resume-behaviors")
+	},
+	{
+		name: "markless-resume-repeats",
+		test: fileBasenamePattern("resume-keyed-repeats", "resume-keyed-repeats-lazy", "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", "resume-census")
+	},
+	{
+		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", "payload-resume-lazy")
+	},
+	{
+		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-client-lazy", "value-decode-extensions")
+	},
+	{
+		name: "markless-payload-leaves",
+		test: fileBasenamePattern("payload", "payload-document")
+	},
+	{
+		name: "markless-dev-log",
+		test: EXECUTION_LOG_CHUNK_MODULE_PATTERN
+	},
+	{
+		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[/\\]/
+}];
+const MARKLESS_SERVER_COMPILED_GROUP = {
+	name: "markless-server",
+	minShareCount: 2,
+	test: /\.tsrx(?:[?#]|$)|^\0?virtual:markless:/,
+	entriesAware: true,
+	maxSize: MARKLESS_SERVER_CHUNK_MAX_BYTES
+};
+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";
+		const splitting = marklessCodeSplitting(next.codeSplitting);
+		next.codeSplitting = {
+			...splitting,
+			groups: [...splitting.groups, MARKLESS_SERVER_COMPILED_GROUP]
+		};
+		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/render-data-literals.ts
+const factored = /* @__PURE__ */ new Map();
+const FACTORED_LIMIT = 512;
+function factorRenderDataLiterals(records, declarations) {
+	if (records.length < 2) return {
+		records: [...records],
+		factories: []
+	};
+	const key = JSON.stringify([declarations, records]);
+	let result = factored.get(key);
+	if (result) factored.delete(key);
+	else {
+		result = factorUncached(records, declarations);
+		if (factored.size >= FACTORED_LIMIT) factored.delete(factored.keys().next().value);
+	}
+	factored.set(key, result);
+	return {
+		records: [...result.records],
+		factories: [...result.factories]
+	};
+}
+function factorUncached(records, declarations) {
+	const unchanged = {
+		records: [...records],
+		factories: []
+	};
+	const reserved = /* @__PURE__ */ new Set();
+	const visit = (value) => {
+		if (!value || typeof value !== "object") return;
+		if (value.type === "Identifier") reserved.add(String(value.name));
+		for (const child of Object.values(value)) if (Array.isArray(child)) child.forEach(visit);
+		else if (child && typeof child === "object") visit(child);
+	};
+	const groups = /* @__PURE__ */ new Map();
+	const parsed = /* @__PURE__ */ new Map();
+	const prefix = "const data=";
+	try {
+		if (declarations.includes("\\")) visit(parseJavaScriptModule(declarations));
+		else for (const name of declarations.match(FACTORY_NAME) ?? []) reserved.add(name);
+		records.forEach((source, record) => {
+			let sites = parsed.get(source);
+			sites ??= scannedLiteralSites(source);
+			if (!sites) {
+				const literal = parseJavaScriptModule(prefix + source + ";").body[0]?.declarations[0]?.init;
+				sites = literal?.type === "ObjectExpression" ? literal.properties.flatMap((property) => {
+					if (property.type !== "Property" || property.computed || !["state", "view"].includes(String(property.key.value)) || !["ObjectExpression", "ArrayExpression"].includes(property.value.type)) return [];
+					const start = property.value.start - 11, end = property.value.end - 11;
+					return [{
+						start,
+						end,
+						source: source.slice(start, end)
+					}];
+				}) : [];
+				parsed.set(source, sites);
+			}
+			for (const site of sites) {
+				let group = groups.get(site.source);
+				if (!group) groups.set(site.source, group = []);
+				group.push({
+					...site,
+					record
+				});
+			}
+		});
+	} catch {
+		return unchanged;
+	}
+	const replacements = /* @__PURE__ */ new Map();
+	const factories = [];
+	const bytes = (source) => new TextEncoder().encode(source).length;
+	let index = 0;
+	for (const [literal, sites] of groups) {
+		if (sites.length < 2) continue;
+		let name;
+		do
+			name = `marklessRenderLiteral${index++}`;
+		while (reserved.has(name));
+		const replacement = `${name}()`, factory = `function ${name}(){return ${literal}}`;
+		if (bytes(factory) + 1 + sites.length * bytes(replacement) >= sites.length * bytes(literal)) continue;
+		factories.push(factory);
+		reserved.add(name);
+		for (const site of sites) {
+			let entries = replacements.get(site.record);
+			if (!entries) replacements.set(site.record, entries = []);
+			entries.push({
+				...site,
+				replacement
+			});
+		}
+	}
+	return {
+		factories,
+		records: records.map((source, index) => {
+			for (const site of (replacements.get(index) ?? []).sort((a, b) => b.start - a.start)) source = source.slice(0, site.start) + site.replacement + source.slice(site.end);
+			return source;
+		})
+	};
+}
+const FACTORY_NAME = /marklessRenderLiteral\d+/g;
+function scannedLiteralSites(source) {
+	let cursor = skipSpace(source, 0);
+	if (source[cursor] !== "{") return void 0;
+	const sites = [];
+	cursor = skipSpace(source, cursor + 1);
+	if (source[cursor] === "}") return skipSpace(source, cursor + 1) === source.length ? sites : void 0;
+	for (;;) {
+		if (source[cursor] !== "\"") return void 0;
+		const keyEnd = stringEnd(source, cursor);
+		if (keyEnd < 0) return void 0;
+		const key = JSON.parse(source.slice(cursor, keyEnd));
+		cursor = skipSpace(source, keyEnd);
+		if (source[cursor] !== ":") return void 0;
+		const start = skipSpace(source, cursor + 1);
+		const end = valueEnd(source, start);
+		if (end < 0 || end === start) return void 0;
+		if ((key === "state" || key === "view") && (source[start] === "{" || source[start] === "[")) sites.push({
+			start,
+			end,
+			source: source.slice(start, end)
+		});
+		cursor = skipSpace(source, end);
+		if (source[cursor] === ",") {
+			cursor = skipSpace(source, cursor + 1);
+			continue;
+		}
+		if (source[cursor] !== "}") return void 0;
+		return skipSpace(source, cursor + 1) === source.length ? sites : void 0;
+	}
+}
+function skipSpace(source, from) {
+	let cursor = from;
+	while (cursor < source.length && JSON_SPACE.has(source[cursor])) cursor++;
+	return cursor;
+}
+const JSON_SPACE = /* @__PURE__ */ new Set([
+	" ",
+	"	",
+	"\n",
+	"\r"
+]);
+function stringEnd(source, start) {
+	for (let cursor = start + 1; cursor < source.length; cursor++) {
+		const char = source[cursor];
+		if (char === "\\") cursor++;
+		else if (char === "\"") return cursor + 1;
+	}
+	return -1;
+}
+function valueEnd(source, start) {
+	let depth = 0;
+	for (let cursor = start; cursor < source.length; cursor++) {
+		const char = source[cursor];
+		if (char === "\"") {
+			const end = stringEnd(source, cursor);
+			if (end < 0) return -1;
+			if (depth === 0) return end;
+			cursor = end - 1;
+		} else if (char === "{" || char === "[") depth++;
+		else if (char === "}" || char === "]") {
+			if (depth === 0) return cursor;
+			if (--depth === 0) return cursor + 1;
+		} else if (depth === 0 && (char === "," || JSON_SPACE.has(char))) return cursor;
+	}
+	return depth === 0 ? source.length : -1;
+}
+//#endregion
+//#region src/served-render-data.ts
+const MARKLESS_SERVED_RENDER_DATA_QUERY = "markless-served";
+/** The served spelling of a render-data source request. */
+function servedRenderDataSourceReference(source) {
+	return withQuery(source, { [MARKLESS_SERVED_RENDER_DATA_QUERY]: null });
+}
+function isServedRenderDataRequest(id) {
+	return new URLSearchParams(parsePath(id).search).has(MARKLESS_SERVED_RENDER_DATA_QUERY);
+}
+//#endregion
+//#region src/prop-flow.ts
+function modulePropFlow(compiled, diagnostics) {
+	const graph = compiled.semanticGraph;
+	return {
+		components: (graph.components ?? []).map((component) => ({
+			name: component.name,
+			...component.exportName ? { exportName: component.exportName } : {}
+		})),
+		decided: diagnostics.flatMap((diagnostic) => diagnostic.decidedByProps && diagnostic.suppressed !== true ? [{
+			code: diagnostic.code,
+			componentName: diagnostic.decidedByProps.componentName,
+			props: diagnostic.decidedByProps.props,
+			message: diagnostic.message
+		}] : []),
+		edges: (graph.componentEdges ?? []).map((edge) => {
+			const spread = edge.props.find((prop) => prop.kind === "spread");
+			return {
+				id: edge.id,
+				parentComponentName: edge.parentComponentName,
+				childComponentName: edge.childComponentName,
+				...edge.importSource ? { importSource: edge.importSource } : {},
+				...edge.importedName ? { importedName: edge.importedName } : {},
+				props: Object.fromEntries(edge.props.flatMap((prop) => prop.kind === "spread" ? [] : [[prop.name, passedProp(prop, graph, edge.keyedRepeatScopeIds)]])),
+				...spread ? { spread: passedProp(spread, graph, edge.keyedRepeatScopeIds) } : {}
+			};
+		})
+	};
+}
+function passedProp(prop, graph, repeatIds = []) {
+	const row = rowValue(prop, graph, repeatIds);
+	if (row !== void 0) return !row ? {
+		kind: "changing",
+		source: prop.source
+	} : row.length === 0 ? { kind: "fixed" } : {
+		kind: "forwarded",
+		props: row,
+		source: prop.source
+	};
+	switch (prop.kind) {
+		case "serializable":
+		case "callback":
+		case "element-handle-id": return { kind: "fixed" };
+		case "opaque": return prop.buildTimeValue ? { kind: "fixed" } : {
+			kind: "unknown",
+			source: prop.source
+		};
+		case "graph-reference":
+		case "spread": {
+			if (prop.kind === "graph-reference" && prop.graphBindingKind === "element") return { kind: "fixed" };
+			if (prop.kind === "spread" && prop.graphNodeId.startsWith(PROTOCOL_PROP_GRAPH_NODE_PREFIX)) return {
+				kind: "forwarded",
+				props: [],
+				source: prop.source
+			};
+			const deciding = propsDeciding(prop.graphNodeId, prop.path, graph);
+			if (!deciding) return {
+				kind: "changing",
+				source: prop.source
+			};
+			return deciding.length === 0 ? { kind: "fixed" } : {
+				kind: "forwarded",
+				props: deciding,
+				source: prop.source
+			};
+		}
+		default: return {
+			kind: "unknown",
+			source: prop.source ?? ""
+		};
+	}
+}
+function rowValue(prop, graph, repeatIds) {
+	if (prop.kind !== "opaque" || prop.buildTimeValue) return void 0;
+	const root = /^[A-Za-z_$][\w$]*/.exec(prop.source)?.[0];
+	if (!root || !/^[A-Za-z_$][\w$]*(?:(?:\?\.|\.)[A-Za-z_$][\w$]*)*$/.test(prop.source)) return void 0;
+	for (const id of [...repeatIds].reverse()) {
+		const repeat = graph.keyedRepeats.find((candidate) => candidate.id === id);
+		if (repeat && (repeat.itemName === root || repeat.indexName === root)) return rowsDecidedBy(repeat, graph);
+	}
+}
+var PropFlowRegistry = class {
+	#modules = /* @__PURE__ */ new Map();
+	record(source, flow, childSources) {
+		this.#modules.set(source, {
+			flow,
+			childSources
+		});
+	}
+	clear() {
+		this.#modules.clear();
+	}
+	/** One message per prop-decided @if some caller can change, or whose caller the build cannot see. */
+	refusals() {
+		const refusals = [];
+		for (const [source, { flow }] of this.#modules) for (const decided of flow.decided) for (const prop of decided.props) {
+			const reason = this.#changes(source, decided.componentName, prop, /* @__PURE__ */ new Set());
+			if (reason) refusals.push(refusalMessage(decided, source, prop, reason));
+		}
+		return refusals;
+	}
+	#changes(source, componentName, prop, seen) {
+		const key = `${source}\0${componentName}\0${prop}`;
+		if (seen.has(key)) return void 0;
+		seen.add(key);
+		for (const [callerSource, { flow, childSources }] of this.#modules) for (const edge of flow.edges) {
+			if (!this.#targets(callerSource, edge, childSources, source, componentName)) continue;
+			const passed = edge.props[prop] ?? edge.spread;
+			if (!passed || passed.kind === "fixed") continue;
+			const where = `<${edge.parentComponentName}> in ${callerSource}`;
+			if (passed.kind === "changing") return `${where} passes it \`${passed.source}\`, which changes.`;
+			if (passed.kind === "unknown") return `${where} passes it \`${passed.source}\`, which the build cannot prove never changes.`;
+			for (const forwarded of passed.props.length > 0 ? passed.props : [prop]) {
+				const deeper = this.#changes(callerSource, edge.parentComponentName, forwarded, seen);
+				if (deeper) return `${where} hands it its own prop \`${forwarded}\`; ${deeper}`;
+			}
+		}
+	}
+	#targets(callerSource, edge, childSources, source, componentName) {
+		if (!edge.importSource) return callerSource === source && edge.childComponentName === componentName;
+		if (childSources.get(edge.id) !== source) return false;
+		const target = this.#modules.get(source);
+		const exportName = edge.importedName ?? "default";
+		return target?.flow.components.some((component) => component.name === componentName && (component.exportName === exportName || exportName !== "default" && component.name === exportName)) ?? false;
+	}
+};
+function refusalMessage(decided, source, prop, reason) {
+	const at = `${source}: <${decided.componentName}>: ${decided.message}`;
+	switch (decided.code) {
+		case "MARKLESS_BRANCH_ARM_UPDATE_UNSUPPORTED": return `MARKLESS_BRANCH_ARM_UPDATE_UNSUPPORTED: ${at} Its test reads the prop \`${prop}\`, and ${reason} Pass \`${prop}\` a value that does not change, or show the content outside the @if and hide it with an attribute.`;
+		case "MARKLESS_KEYED_REPEAT_ROW_MINT_UNSUPPORTED": return `MARKLESS_KEYED_REPEAT_ROW_MINT_UNSUPPORTED: ${at} The list comes from the prop \`${prop}\`, and ${reason} Pass \`${prop}\` a value that does not change, or keep the row to markup the browser can build.`;
+		case "MARKLESS_ROW_BRANCH_FLIP_UNSUPPORTED": return `MARKLESS_ROW_BRANCH_FLIP_UNSUPPORTED: ${at} The rows come from the prop \`${prop}\`, and ${reason} Pass \`${prop}\` a value that does not change, or keep the row to markup the browser can build.`;
+		case "MARKLESS_TEMPLATE_EXPRESSION_STATIC": return `MARKLESS_TEMPLATE_EXPRESSION_STATIC: ${at} It holds only while the prop \`${prop}\` never changes, and ${reason} Pass \`${prop}\` a value that does not change, or read a plain value from the prop.`;
+		default: return `${decided.code}: ${at} It holds only while the prop \`${prop}\` never changes, and ${reason} Pass \`${prop}\` a value that does not change.`;
+	}
+}
+//#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]] : []));",
+		"	let lastCallback = Promise.resolve();",
+		"	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 = lastCallback.then(() => capture.invoke(slot.slotId, args));",
+		"				lastCallback = pending.catch(() => {});",
+		"				pendingCallbacks.push(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,
+		literalImports: input.literalImports,
+		bundlerVisibleImports: input.literalImports
+	});
+	const routes = (input.symbolRoutes ?? []).map((route) => route.boundSymbols ? {
+		...route,
+		boundSymbols: Object.fromEntries(Object.entries(route.boundSymbols).filter(([, rowId]) => ids.has(rowId)))
+	} : route);
+	if (routes.length > 0) {
+		source = source.replaceAll("loadSymbol(", "marklessLoadLocalSymbol(");
+		source += "\n" + emitSymbolRouteTable({
+			routes: routes.map((route) => "importSource" in route ? {
+				...route,
+				importSource: symbolRouteImportSource(route.importSource)
+			} : route),
+			functionName: "loadSymbol",
+			fallbackName: "marklessLoadLocalSymbol",
+			reboundName: "marklessLoadSymbolRebound",
+			exported: true
+		});
+	}
+	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 WeakMap();",
+		"export async function prepareBoundaryArm(boundaryId, status, graph, loadSymbol) {",
+		"	const rendered = await renderPrerenderBoundary(marklessPrerenderData, boundaryId, status, graph, loadSymbol);",
+		"	if (!marklessPreparedBoundaryArms.has(graph)) marklessPreparedBoundaryArms.set(graph, new Map());",
+		"	marklessPreparedBoundaryArms.get(graph).set(`${boundaryId}:${status}`, rendered);",
+		"}",
+		"export function renderBoundaryArm(boundaryId, status, graph) {",
+		"	const key = `${boundaryId}:${status}`;",
+		"	const prepared = marklessPreparedBoundaryArms.get(graph);",
+		"	const rendered = prepared?.get(key);",
+		"	if (!rendered) throw new Error(`Markless prerender arm ${key} was not prepared.`);",
+		"	prepared.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;
+		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();
+		const escalatedHostNodeIds = /* @__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);
+				});
+				if ("elementHandleReads" in symbol) for (const read of symbol.elementHandleReads ?? []) closureView.elementHandles.forEach((handle, index) => {
+					if (handle.handleId === read.handleId || handle.name === read.handleName) selected.elementHandles.add(index);
+				});
+			}
+			closeComputedGraph(graphNodeIds, input.state);
+			for (const computed of input.state.computed) if (computed.deriveSymbolId && graphNodeIds.has(computed.graphNodeId)) symbolIds.add(computed.deriveSymbolId);
+			for (const graphNodeId of graphNodeIds) {
+				const runnerSymbolId = closureView.asyncRunners?.[graphNodeId];
+				if (runnerSymbolId) symbolIds.add(runnerSymbolId);
+			}
+			selectViewSubscribers(closureView, graphNodeIds, symbolIds, selected);
+			const escalatedBranchIds = /* @__PURE__ */ new Set();
+			for (const index of selected.branches) {
+				const record = closureView.branches?.[index];
+				if (record?.escalates) escalatedBranchIds.add(record.id);
+			}
+			for (const index of selected.boundaries) {
+				const served = closureView.asyncBoundaries[index];
+				for (const arm of boundaryArmRecordSets(completeBoundaries.get(served.id) ?? served)) collectEscalatedArmBranchIds(arm, escalatedBranchIds);
+			}
+			for (const branchId of escalatedBranchIds) collectEscalatedBranchClosure(input, branchId, graphNodeIds, symbolIds, escalatedHostNodeIds);
+			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;
+		}
+		dropEscalatedHostRecords(closureView, selected, escalatedHostNodeIds);
+		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 dropEscalatedHostRecords(view, selected, hostNodeIds) {
+	if (hostNodeIds.size === 0) return;
+	const drop = (indexes, hostOf) => {
+		for (const index of indexes) if (hostNodeIds.has(hostOf(index) ?? "")) indexes.delete(index);
+	};
+	drop(selected.domUpdates, (index) => view.domUpdates[index]?.hostNodeId);
+	drop(selected.behaviors, (index) => view.behaviors[index]?.hostNodeId);
+	drop(selected.elementHandles, (index) => view.elementHandles[index]?.hostNodeId);
+	drop(selected.repeats, (index) => view.keyedRepeats?.[index]?.parentHostNodeId);
+}
+function collectEscalatedArmBranchIds(arm, branchIds) {
+	for (const branch of arm.branches ?? []) {
+		if (!branch.symbolId && (branch.testReads?.length ?? 0) > 0) branchIds.add(branch.id);
+		for (const nested of branch.armRecords ?? []) collectEscalatedArmBranchIds(nested, branchIds);
+	}
+}
+function collectEscalatedBranchClosure(input, branchSiteId, graphNodeIds, symbolIds, hostNodeIds) {
+	const renderData = input.renderData;
+	const branch = renderData?.branches.find((candidate) => candidate.branchSiteId === branchSiteId);
+	if (!renderData || !branch) return;
+	const chunks = new Map(renderData.chunks.map((chunk) => [chunk.id, chunk]));
+	const edgeIds = /* @__PURE__ */ new Set();
+	const walked = /* @__PURE__ */ new Set();
+	const walk = (chunkId) => {
+		if (!chunkId || walked.has(chunkId)) return;
+		walked.add(chunkId);
+		const chunk = chunks.get(chunkId);
+		if (!chunk) return;
+		for (const host of chunk.hosts) hostNodeIds.add(host.hostNodeId);
+		for (const slot of chunk.slots) if (slot.kind === "child-component") {
+			edgeIds.add(slot.componentEdgeId);
+			walk(slot.childTemplateId);
+			walk(slot.projectionChunkId);
+		} else if (slot.kind === "branch") for (const armId of slot.armTemplateIds) walk(armId);
+		else if (slot.kind === "repeat") {
+			walk(slot.rowTemplateId);
+			walk(slot.emptyTemplateId);
+		} else if (slot.kind === "async") {
+			walk(slot.armTemplateIds.try);
+			walk(slot.armTemplateIds.pending);
+			walk(slot.armTemplateIds.catch);
+		} else if (slot.kind === "dynamic-host") walk(slot.childChunkId);
+		else if ("residue" in slot && slot.residue.kind === "graph-read") graphNodeIds.add(slot.residue.graphNodeId);
+	};
+	for (const armId of branch.armChunkIds) walk(armId);
+	for (const symbol of input.symbolResolver.symbols) if (symbol.kind === "dom-update" && hostNodeIds.has(symbol.hostNodeId)) graphNodeIds.add(symbol.graphNodeId);
+	for (const symbol of input.symbolResolver.symbols) if ("hostNodeId" in symbol && hostNodeIds.has(symbol.hostNodeId) || symbol.kind === "callback-prop" && edgeIds.has(symbol.componentEdgeId) || (symbol.kind === "state-initializer" || symbol.kind === "sync-computed-derive" || symbol.kind === "async-computed-runner") && graphNodeIds.has(symbol.graphNodeId)) symbolIds.add(symbol.id);
+	for (const row of input.boundRows) if (row.componentEdgePath.some((edgeId) => edgeIds.has(edgeId))) symbolIds.add(row.id);
+}
+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/build/symbol-bundles.ts
+const SYMBOL_BUNDLE_VIRTUAL_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}symbol-bundle:`;
+function symbolBundleVirtualModuleId(filename, index) {
+	return `${SYMBOL_BUNDLE_VIRTUAL_PREFIX}${encodeURIComponent(filename)}:${index}`;
+}
+function emitSymbolBundleModule(symbolModuleIds) {
+	return `${symbolModuleIds.map((id) => `export * from ${JSON.stringify(id)};`).join("\n")}\n`;
+}
+/**
+* Partitions this module's symbol chunks by the set of interactions that wake
+* them. A partition of one stays on its own module id: bundling it would only
+* add a re-export hop.
+*
+* The interaction list is one module's local view, so it cannot name a symbol
+* another module's host node wakes (a callback prop) or one that several writes
+* wake (a dom update). Unnamed means the owning set is unknown, never that it is
+* empty, so unnamed symbols stay on their own chunks.
+*/
+function planSymbolBundles(input) {
+	if (input.symbols.length < 2) return [];
+	const owners = /* @__PURE__ */ new Map();
+	for (const interaction of input.interactions) for (const symbolId of interaction.symbolIds) {
+		const current = owners.get(symbolId);
+		if (current) current.push(interaction.id);
+		else owners.set(symbolId, [interaction.id]);
+	}
+	const partitions = /* @__PURE__ */ new Map();
+	for (const symbol of input.symbols) {
+		const claimed = owners.get(symbol.symbolId);
+		if (!claimed) continue;
+		const key = [...new Set(claimed)].sort().join(" ");
+		const current = partitions.get(key);
+		if (current) current.push(symbol.moduleId);
+		else partitions.set(key, [symbol.moduleId]);
+	}
+	return [...partitions.entries()].filter(([, moduleIds]) => moduleIds.length > 1).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, moduleIds], index) => ({
+		key,
+		id: symbolBundleVirtualModuleId(input.filename, index),
+		symbolModuleIds: [...moduleIds].sort()
+	}));
+}
+//#endregion
+//#region src/transform.ts
+const STRIPPED_CODE_LIMIT = 4096;
+const strippedCode = /* @__PURE__ */ new Map();
+let persistentStrippedCode;
+function usePersistentStrippedCode(memo) {
+	persistentStrippedCode = memo;
+}
+async function stripEmittedTypes(code, moduleId, onlyRemoveTypeImports = false) {
+	const key = `${onlyRemoveTypeImports ? 1 : 0}${code}`;
+	const cached = strippedCode.get(key) ?? persistentStrippedCode?.get(key);
+	if (cached !== void 0) {
+		strippedCode.delete(key);
+		strippedCode.set(key, cached);
+		return cached;
+	}
+	const stripped = await stripEmittedTypesUncached(code, moduleId, onlyRemoveTypeImports);
+	persistentStrippedCode?.set(key, stripped);
+	strippedCode.set(key, stripped);
+	if (strippedCode.size > STRIPPED_CODE_LIMIT) {
+		const oldest = strippedCode.keys().next();
+		if (!oldest.done) strippedCode.delete(oldest.value);
+	}
+	return stripped;
+}
+async function stripEmittedTypesUncached(code, moduleId, onlyRemoveTypeImports) {
+	let out;
+	try {
+		out = transformSync("markless-emitted.ts", code, onlyRemoveTypeImports ? { typescript: { onlyRemoveTypeImports: true } } : void 0);
+	} catch (error) {
+		throw typeStripError(moduleId, error instanceof Error ? error.message : String(error));
+	}
+	const errors = out.errors ?? [];
+	if (errors.length > 0 || !out.code) throw typeStripError(moduleId, errors.map((error) => error.message).join("; ") || "oxc produced no output.");
+	return out.code;
+}
+async function stripEmittedTypesFromFragment(code, moduleId, onlyRemoveTypeImports = false) {
+	if (!await fragmentCarriesTypeScript(code)) return code;
+	return (await stripEmittedTypes(code, moduleId, onlyRemoveTypeImports)).trim();
+}
+async function stripEmittedTypesFromExpression(source, moduleId) {
+	const stripped = await stripEmittedTypesFromFragment(source, moduleId);
+	return stripped.endsWith(";") ? stripped.slice(0, -1).trimEnd() : stripped;
+}
+const fragmentVerdicts = /* @__PURE__ */ new Map();
+const FRAGMENT_VERDICT_LIMIT = 4096;
+async function fragmentCarriesTypeScript(code) {
+	const known = fragmentVerdicts.get(code);
+	if (known !== void 0) return known;
+	const stored = persistentStrippedCode?.get(`t${code}`);
+	const verdict = stored === void 0 ? await fragmentCarriesTypeScriptUncached(code) : stored === "true";
+	if (stored === void 0) persistentStrippedCode?.set(`t${code}`, String(verdict));
+	if (fragmentVerdicts.size >= FRAGMENT_VERDICT_LIMIT) fragmentVerdicts.delete(fragmentVerdicts.keys().next().value);
+	fragmentVerdicts.set(code, verdict);
+	return verdict;
+}
+async function fragmentCarriesTypeScriptUncached(code) {
+	try {
+		const parsed = parseSync("markless-emitted.ts", code, { lang: "ts" });
+		if ((parsed.errors?.length ?? 0) > 0) return true;
+		return carriesTypeScript(parsed.program);
+	} catch {
+		return true;
+	}
+}
+const TYPESCRIPT_FLAGS = [
+	"declare",
+	"abstract",
+	"definite",
+	"override",
+	"accessibility"
+];
+function carriesTypeScript(node) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some((child) => carriesTypeScript(child));
+	const record = node;
+	if (typeof record.type === "string" && record.type.startsWith("TS")) return true;
+	if (record.importKind === "type" || record.exportKind === "type") return true;
+	if (TYPESCRIPT_FLAGS.some((flag) => record[flag])) return true;
+	if (record.readonly === true) return true;
+	if (Array.isArray(record.implements) && record.implements.length > 0) return true;
+	for (const [key, value] of Object.entries(record)) {
+		if (key === "type" || key === "loc" || key === "range" || key === "parent") continue;
+		if (carriesTypeScript(value)) return true;
+	}
+	return false;
+}
+function typeStripError(moduleId, message) {
+	return new MarklessCompileError(createCompileErrorPayload({
+		filename: moduleId,
+		source: "",
+		diagnostics: [],
+		details: `MARKLESS_TYPE_STRIP_FAILED: ${moduleId} could not have its TypeScript syntax stripped. ${message}`
+	}));
+}
+async function transformTsrxModule(input) {
+	return transformTsrxModuleWithPrerenderWakeClosure(input, false);
+}
+function servedRenderDataId(encodedModuleId) {
+	return `${MARKLESS_VIRTUAL_PREFIX}render-data-served:${encodedModuleId}`;
+}
+function servedRenderDataEntryId(encodedModuleId) {
+	return `${MARKLESS_VIRTUAL_PREFIX}render-data-served-entry:${encodedModuleId}`;
+}
+function clientRenderDataEntryId(encodedModuleId) {
+	return `${MARKLESS_VIRTUAL_PREFIX}${CLIENT_RENDER_DATA_ENTRY_KIND}:${encodedModuleId}`;
+}
+const CLIENT_RENDER_DATA_ENTRY_KIND = "render-data-csr-entry";
+function servedRenderDataReference(reference) {
+	const canonical = `${MARKLESS_VIRTUAL_PREFIX}render-data:`;
+	return reference.startsWith(canonical) ? servedRenderDataId(reference.slice(canonical.length)) : servedRenderDataSourceReference(reference);
+}
+function marklessVirtualModuleSourceFile(moduleId, root) {
+	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 sourceForModuleId(decodeURIComponent(encoded), root);
+	} catch {
+		return null;
+	}
+}
+async function transformTsrxModuleWithPrerenderWakeClosure(input, linkedChildHasBrowserTriggers) {
+	const encodedFilename = encodeURIComponent(input.filename);
+	const encodedModuleId = encodeURIComponent(input.moduleId ?? input.filename);
+	const payloadId = `${MARKLESS_VIRTUAL_PREFIX}payload:${encodedModuleId}`;
+	const renderDataId = `${MARKLESS_VIRTUAL_PREFIX}render-data:${encodedModuleId}`;
+	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 servedScalarPlans = input.servedScalarPlans === true && runtimeDemandClass === "prerender" && !input.prerenderRecords ? compiledForAllClasses.runtimeDemandMaps?.["plain-ssr"] : void 0;
+	const classDemandMap = compiledForAllClasses.runtimeDemandMaps?.[runtimeDemandClass] ?? compiledForAllClasses.runtimeDemandMap;
+	const compiled = {
+		...compiledForAllClasses,
+		runtimeDemandMap: servedScalarPlans ? withServedScalarDemand(classDemandMap, servedScalarPlans) : classDemandMap
+	};
+	const compilerSymbolRows = compiled.symbolModules.modules.map((module) => ({
+		id: module.symbolId,
+		chunk: symbolVirtualModuleId(input.filename, module.symbolId),
+		exportName: scopedSymbolExportName(input.moduleId ?? input.filename, module.exportName)
+	}));
+	const linkedBoundarySymbols = linkedRenderDataBoundarySymbols(linkedSymbolInput(compiled, input, renderDataId, resolverId, input.environment === "client"));
+	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({
+		literalImports: input.experimentalNativePacking,
+		resolverId: input.experimentalNativePacking ? `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodedModuleId}` : void 0,
+		buildId: input.buildId,
+		symbols: resolverSymbols,
+		boundSymbols: importedBoundRows
+	}), importedBoundRows.some((row) => row.loaderSymbolId !== void 0));
+	const symbolRoutes = componentEdgeSymbolRoutes(compiled, input.artifactChildMaterializations);
+	const closurePlanRoutes = symbolRoutes.filter((route) => !("importSource" in route) || answersClosurePlans("selfRecursive" in route && route.selfRecursive ? compiled.moduleGraphInterface : input.importedModuleInterfaces?.[route.importSource]));
+	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,
+		renderData: compiled.renderData
+	}) : [];
+	const selfWakeArmRendererId = prerenderTriggerGroups.some((group) => group.id === "self-wake") ? triggerGroupVirtualModuleId(input.filename, prerenderTriggerGroups.length) : void 0;
+	const symbolBundles = !input.experimentalNativePacking && symbolRows.length > 8 ? planSymbolBundles({
+		filename: input.filename,
+		symbols: compiled.symbolModules.modules.filter((module) => module.kind !== "sync-computed-derive").map((module) => ({
+			symbolId: module.symbolId,
+			moduleId: symbolVirtualModuleId(input.filename, module.symbolId)
+		})),
+		interactions: prerenderTriggerGroups.length > 0 ? prerenderTriggerGroups : compiled.triggerGroups.groups
+	}) : [];
+	const styleCss = compiled.publicRenderPlan.styleScopes.map((scope) => scope.cssText).join("\n");
+	const styleId = compiled.publicRenderPlan.styleScopes.length > 0 ? `${MARKLESS_VIRTUAL_PREFIX}style:${encodedModuleId}.css` : null;
+	const rosterDerivation = compiled.moduleGraphInterface.render.components.some((component) => component.rosterDerivation === true);
+	const storageCells = compiled.moduleGraphInterface.render.components.some((component) => component.storageCells === true);
+	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: importedSymbolRoutes(symbolRoutes),
+		payload: { virtualModuleId: payloadId },
+		resolver: { virtualModuleId: emitsPrerenderWakeFacade ? prerenderWakeId : resolverId },
+		symbols: manifestOwnsSymbolRoutes ? symbolManifestEntries : [],
+		runtimeDemandMap: compiled.runtimeDemandMap,
+		...input.directCsr === true && compiled.publicRenderModule.moduleSource ? { directCsr: true } : {}
+	};
+	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 lazyRenderDataId = canonicalRenderData && compiled.publicRenderModule.renderDataModuleSource ? `${MARKLESS_VIRTUAL_PREFIX}render-data-entry:${encodedModuleId}` : void 0;
+	const servedRenderData = linkedClientRenderData && lazyRenderDataId ? compiled.publicRenderModule.servedRenderData : void 0;
+	const virtualModules = [
+		...compiled.publicRenderModule.renderDataModuleSource ? [{
+			id: renderDataId,
+			type: "render-data",
+			...canonicalRenderData ? { canonicalRenderData: true } : {},
+			source: canonicalRenderData ? await prerenderDataModuleSource(compiled, input.environment, input.importedModuleInterfaces, input.renderDataImportSources, input.artifactChildMaterializations, input.filename, input.moduleId ?? input.filename) : compiled.publicRenderModule.renderDataModuleSource
+		}] : [],
+		...lazyRenderDataId ? [{
+			id: lazyRenderDataId,
+			type: "render-data-entry",
+			source: `export * from ${JSON.stringify(renderDataId)};`
+		}] : [],
+		...servedRenderData ? [
+			{
+				id: servedRenderDataId(encodedModuleId),
+				type: "render-data-served",
+				canonicalRenderData: true,
+				source: await prerenderDataModuleSource(compiled, input.environment, input.importedModuleInterfaces, input.renderDataImportSources, input.artifactChildMaterializations, input.filename, input.moduleId ?? input.filename, servedRenderData)
+			},
+			{
+				id: servedRenderDataEntryId(encodedModuleId),
+				type: "render-data-entry",
+				source: `export * from ${JSON.stringify(servedRenderDataId(encodedModuleId))};`
+			},
+			{
+				id: clientRenderDataEntryId(encodedModuleId),
+				type: "render-data-entry",
+				source: `export * from ${JSON.stringify(renderDataId)};`
+			}
+		] : [],
+		...styleId ? [{
+			id: styleId,
+			type: "style",
+			source: styleCss
+		}] : [],
+		{
+			id: payloadId,
+			type: "payload",
+			source: payloadModule({
+				...compiled.payloadScripts,
+				runtimeDemandMap: compiled.runtimeDemandMap
+			})
+		},
+		{
+			id: resolverId,
+			type: "resolver",
+			source: resolverSource,
+			symbolClaims: [.../* @__PURE__ */ 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),
+				hasIdleEvents: viewHasIdleEvents(compiled.payloadScripts.view),
+				streamsArms: authorsPendingArm(compiled.semanticGraph.markup),
+				runtimeDemandMap: compiled.runtimeDemandMap,
+				servedScalarPlans,
+				executionLog: input.executionLog,
+				needsFullResume: prerenderClosureNeedsWake,
+				prerenderDataId: input.prerenderRecords && prerenderInterfacesComplete(compiled, input) ? renderDataId : void 0,
+				lazyRenderDataId,
+				...servedRenderData ? { servedRenderDataId: servedRenderDataEntryId(encodedModuleId) } : {},
+				renderDataId: canonicalRenderData && compiled.publicRenderModule.renderDataModuleSource ? renderDataId : void 0,
+				linkedRowSlotReaders: importedRowSlotReaders(input.importedModuleInterfaces),
+				linkedRowComponents: importedRowComponentMints(input.importedModuleInterfaces),
+				linkedRowTemplates: importedRowTemplateMints(input.importedModuleInterfaces),
+				linkedNestedRepeats: importedNestedRepeats(input.importedModuleInterfaces),
+				linkedRowBranches: importedRowBranchMints(input.importedModuleInterfaces),
+				rosterDerivation,
+				storageCells,
+				hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
+				boundSymbolDescriptors,
+				symbols: symbolRows,
+				symbolRoutes,
+				closurePlanRoutes
+			})
+		},
+		...emitsPrerenderWakeVariant ? [{
+			id: prerenderWakeId,
+			type: "prerender-wake",
+			source: emitResumeModule({
+				payloadId,
+				resolverId,
+				payloadState: compiled.payloadScripts.state,
+				payloadView: containerScopedResumeView(compiled.payloadScripts.view),
+				hasIdleEvents: viewHasIdleEvents(compiled.payloadScripts.view),
+				runtimeDemandMap: compiled.runtimeDemandMap,
+				executionLog: input.executionLog,
+				needsFullResume: prerenderClosureNeedsWake,
+				prerenderDataId: renderDataId,
+				lazyRenderDataId,
+				prerenderTriggerGroups: prerenderTriggerGroups.map((group, index) => ({
+					...group,
+					moduleId: triggerGroupVirtualModuleId(input.filename, index)
+				})),
+				rosterDerivation,
+				storageCells,
+				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,
+				literalImports: input.experimentalNativePacking
+			})
+		})),
+		...selfWakeArmRendererId ? [{
+			id: selfWakeArmRendererId,
+			type: "trigger-group",
+			source: emitPrerenderBoundaryRendererModule(renderDataId)
+		}] : [],
+		...symbolBundles.map((bundle) => ({
+			id: bundle.id,
+			type: "symbol-bundle",
+			source: emitSymbolBundleModule(bundle.symbolModuleIds),
+			bundledSymbolModuleIds: bundle.symbolModuleIds
+		})),
+		...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), symbolVirtualModuleId(input.filename, module.symbolId)), `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 styleModuleIds = [.../* @__PURE__ */ new Set([...styleId ? [styleId] : [], ...input.linkedStyleModuleIds ?? []])];
+	const styleModuleUrl = input.styleModuleUrl;
+	const headInjections = [...input.headInjections ?? [], ...styleModuleUrl ? styleModuleIds.map((id) => ({
+		tag: "link",
+		location: "head",
+		attributes: {
+			rel: "stylesheet",
+			href: styleModuleUrl(id)
+		}
+	})) : []];
+	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",
+			linkedRowSlotReaders: importedRowSlotReaders(input.importedModuleInterfaces),
+			linkedRowComponents: importedRowComponentMints(input.importedModuleInterfaces),
+			linkedRowTemplates: importedRowTemplateMints(input.importedModuleInterfaces),
+			linkedNestedRepeats: importedNestedRepeats(input.importedModuleInterfaces),
+			linkedRowBranches: importedRowBranchMints(input.importedModuleInterfaces),
+			clientOutput: input.clientOutput ?? "full",
+			executionLog: input.executionLog,
+			headInjections: headInjections.length > 0 ? headInjections : void 0,
+			storageSeeds: storageSeeds.length > 0 ? storageSeeds : void 0,
+			inlineResumerSources,
+			prerenderBoot,
+			...input.environment === "server" ? { sharedInlineSourcesModuleId: sharedInlineSourcesModuleId({
+				debug: input.inlineResumerDebug === true,
+				executionLog: input.executionLog ?? "never"
+			}) } : {},
+			devResumeReexport: input.devResumeReexport === true,
+			needsFullResume: prerenderClosureNeedsWake,
+			prerenderRecords: input.prerenderRecords,
+			directCsr: input.directCsr,
+			hasComputedState: compiled.payloadScripts.state.computed.length > 0,
+			hasOverlayMarks: compiled.runtimeDemandMap.payloadRecords.some((record) => record.kind === "overlay"),
+			hasIdleEvents: viewHasIdleEvents(compiled.payloadScripts.view),
+			runtimeDemandMap: compiled.runtimeDemandMap,
+			resumeModuleUrl: input.resumeModuleUrl,
+			scalarActions: input.includeScalarActionPlans ? compiled.runtimeDemandMaps?.["plain-ssr"].actions : void 0,
+			closureActions: (servedScalarPlans ?? (runtimeDemandClass === "plain-ssr" ? classDemandMap : void 0))?.actions,
+			prerenderWakeModuleUrl: input.prerenderWakeModuleUrl,
+			publicRenderModuleSource: compiled.publicRenderModule.moduleSource,
+			publicRenderRootExportName: compiled.publicRenderModule.rootExportName,
+			publicSsrModuleSource: compiled.publicRenderModule.ssrModuleSource,
+			publicRenderSsrExportName: compiled.publicRenderModule.ssrExportName,
+			publicRenderSsrComponentExports: compiled.publicRenderModule.ssrComponentExports,
+			canonicalRenderData: prerenderInterfacesComplete(compiled, input),
+			...servedRenderData && input.serverRenderedPages && !input.dev ? { lazyFullRenderDataId: clientRenderDataEntryId(encodedModuleId) } : {},
+			sharedDefinitionExports: compiled.moduleGraphInterface?.sharedDefinitions?.map((published) => published.exportName),
+			hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
+			symbols: symbolRows,
+			behaviorSymbols,
+			symbolRoutes,
+			closurePlanRoutes
+		}), input.filename),
+		map: null,
+		virtualModules,
+		manifest,
+		moduleGraphInterface: compiled.moduleGraphInterface,
+		interfaceHash: moduleInterfaceHash(compiled.moduleGraphInterface),
+		moduleImports: compiled.semanticGraph.moduleImports,
+		artifactChildren: artifactChildCandidates(compiled),
+		propFlow: modulePropFlow(compiled, moduleDiagnostics(compiled)),
+		importedConstantRequests: compiled.semanticGraph.componentEdges.flatMap((edge) => edge.props.flatMap((prop) => "importedConstants" in prop ? prop.importedConstants ?? [] : []))
+	};
+}
+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 renderDataInitializerSymbolId(definition, initial, initializerSymbolIds) {
+	if (initial.value.kind !== "symbol-function") return void 0;
+	const symbolId = initial.value.symbolId;
+	if (definition.initializerResidues?.[symbolId] || !initializerSymbolIds.has(symbolId)) return void 0;
+	return symbolId;
+}
+function initializerModuleSymbolIds(compiled) {
+	return new Set(compiled.symbolModules.modules.filter((module) => module.kind === "state-initializer" || module.kind === "sync-computed-derive").map((module) => module.symbolId));
+}
+const UNEVALUATED_DEFINITION_FIELDS = [
+	"state",
+	"stateCellIndexes",
+	"stateComputedIndexes",
+	"stateSharedSeedIndexes",
+	"servedComputedIndexes",
+	"view",
+	"initialValues",
+	"initialValueKinds",
+	"initializerResidues",
+	"stateGraphNodeIds"
+];
+function servedDefinition(record, served, rootsWidget) {
+	const { chunks: _chunks, ...rest } = record;
+	const seeds = Object.values(record.initialValueKinds ?? {}).includes("shared-seed");
+	if (served.evaluatedComponents.includes(String(record.name)) || rootsWidget === true || seeds) return rest;
+	return Object.fromEntries(Object.entries(rest).filter(([field]) => !UNEVALUATED_DEFINITION_FIELDS.includes(field)));
+}
+async function prerenderDataModuleSource(compiled, environment, importedModuleInterfaces, renderDataImportSources, artifactChildMaterializations, sourceFilename, moduleId, served) {
+	const importedComponents = /* @__PURE__ */ new Map();
+	const browserRenderedChildren = served ? new Set(compiled.semanticGraph.componentEdges.flatMap((edge) => served.browserRenderedEdgeIds.includes(edge.id) ? [edge.childComponentName] : [])) : void 0;
+	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.`);
+		const full = renderDataImportSources?.[edge.importSource] ?? `virtual:markless:render-data:${encodeURIComponent(linked.moduleId ?? linked.filename)}`;
+		importedComponents.set(edge.childComponentName, {
+			source: browserRenderedChildren && !browserRenderedChildren.has(edge.childComponentName) ? servedRenderDataReference(full) : full,
+			local: `marklessPrerenderImport${importedComponents.size}`
+		});
+	}
+	const renderDataId = `${MARKLESS_VIRTUAL_PREFIX}render-data:${encodeURIComponent(moduleId)}`;
+	const readerImports = /* @__PURE__ */ new Map();
+	const readerDeclarations = /* @__PURE__ */ new Map();
+	const initializerImports = /* @__PURE__ */ new Map();
+	const initializerSymbolIds = initializerModuleSymbolIds(compiled);
+	const initializerModules = new Map(compiled.symbolModules.modules.filter((module) => initializerSymbolIds.has(module.symbolId)).map((module) => [module.symbolId, module]));
+	const componentEntries = [];
+	let qualifiesRows = false;
+	for (const definition of compiled.publicRenderModule.componentDefinitions) {
+		const { residueReaderSource, residueReaderImports, residueReaderDeclarations, rootsWidget, projectsIntoRows, ...record } = definition;
+		const readerSource = served ? served.readers[String(definition.name)] : residueReaderSource;
+		const initializers = /* @__PURE__ */ new Map();
+		const initialized = !served || served.browserRenderedComponents.includes(String(definition.name));
+		for (const initial of initialized ? record.initialValues ?? [] : []) {
+			const symbolId = renderDataInitializerSymbolId(record, initial, initializerSymbolIds);
+			if (!symbolId) continue;
+			const module = initializerModules.get(symbolId);
+			let imported = initializerImports.get(symbolId);
+			if (!imported) {
+				const local = `marklessRenderInitializer${initializerImports.size}`;
+				imported = {
+					local,
+					line: `import { ${scopedSymbolExportName(moduleId, module.exportName)} as ${local} } from ${JSON.stringify(symbolVirtualModuleId(sourceFilename, symbolId))};`
+				};
+				initializerImports.set(symbolId, imported);
+			}
+			initializers.set(symbolId, imported.local);
+		}
+		for (const entry of (served ? served.imports : residueReaderImports) ?? []) {
+			if (readerImports.has(entry.line)) continue;
+			const rebound = entry.line.replace(JSON.stringify(entry.source), JSON.stringify(resolveAuthoredSpecifier(entry.source, sourceFilename)));
+			readerImports.set(entry.line, await stripEmittedTypesFromFragment(rebound, `${renderDataId}:reader-import`, true));
+		}
+		for (const line of (served ? served.declarations : residueReaderDeclarations) ?? []) {
+			if (readerDeclarations.has(line)) continue;
+			readerDeclarations.set(line, await stripEmittedTypesFromFragment(line, `${renderDataId}:reader-declaration`));
+		}
+		const data = jsonSourceWithNonFiniteNumbers(served ? servedDefinition(record, served, rootsWidget) : record) ?? "undefined";
+		const reader = readerSource ? await stripEmittedTypesFromExpression(readerSource, `${renderDataId}:reader:${String(definition.name)}`) : void 0;
+		if (projectsIntoRows) qualifiesRows = true;
+		const functions = [
+			...reader ? [`readResidue:${reader}`] : [],
+			...projectsIntoRows ? ["rowHosts:marklessRowHosts"] : [],
+			...initializers.size ? [`initializers:{${[...initializers].map(([id, local]) => `${JSON.stringify(id)}:${local}`).join(",")}}`] : []
+		];
+		componentEntries.push({
+			name: JSON.stringify(String(definition.name)),
+			data,
+			functions
+		});
+	}
+	const preludes = [...initializerImports.values()].map((entry) => entry.line).concat([...readerImports.values(), ...readerDeclarations.values()]);
+	const factored = factorRenderDataLiterals(componentEntries.map((entry) => entry.data), preludes.concat(componentEntries.map((entry) => `const marklessLiteralReaderScope = {${entry.functions.join(",")}};`)).join("\n"));
+	const seedsShared = compiled.publicRenderModule.componentDefinitions.some((definition) => {
+		const record = definition;
+		return record.rootsWidget === true || Object.values(record.initialValueKinds ?? {}).includes("shared-seed");
+	});
+	return [
+		...environment === "client" && demandsOverlay(compiled.runtimeDemandMap) ? [emitOverlayLoaderInstall()] : [],
+		...seedsShared ? ["import { installMarklessSharedSeedPass } from '@markless/web/fns/shared-seed';", "installMarklessSharedSeedPass();"] : [],
+		...[...importedComponents.values()].map((entry) => `import { marklessPrerenderData as ${entry.local} } from ${JSON.stringify(entry.source)};`),
+		...qualifiesRows ? ["import { marklessRowHosts } from '@markless/web/fns/row-qualified-view';"] : [],
+		...preludes,
+		served ? served.renderDataModuleSource : compiled.publicRenderModule.renderDataModuleSource,
+		...factored.factories,
+		`const marklessPrerenderComponents = {${componentEntries.map((entry, index) => `${entry.name}:${entry.functions.length ? `{...${factored.records[index]},${entry.functions.join(",")}}` : factored.records[index]}`).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 preflightTsrxModuleDiagnostics(input) {
+	const { blockingDiagnostics } = await compileWithBlockingDiagnostics(input, `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodeURIComponent(input.filename)}`);
+	throwIfBlocked(input, blockingDiagnostics);
+}
+function linkedSymbolInput(compiled, input, renderDataId, resolverId, clientLink) {
+	return {
+		compiled,
+		link: input,
+		clientLink,
+		renderDataId,
+		resolverId,
+		symbolModuleId: (symbolId) => symbolVirtualModuleId(input.filename, symbolId),
+		boundaryExportName: (index) => scopedSymbolExportName(input.moduleId ?? input.filename, `marklessLinkedBoundaryUpdate${index}`),
+		branchExportName: (index) => scopedSymbolExportName(input.moduleId ?? input.filename, `marklessLinkedBranchUpdate${index}`)
+	};
+}
+function fulfilledEscalationSymbolIds(compiled, input, resolverId) {
+	if ((compiled.symbolModules.armEscalationCandidates ?? []).length === 0) return /* @__PURE__ */ new Set();
+	const renderDataId = `${MARKLESS_VIRTUAL_PREFIX}render-data:${encodeURIComponent(input.moduleId ?? input.filename)}`;
+	return new Set(linkedRenderDataBoundarySymbols(linkedSymbolInput(compiled, input, renderDataId, resolverId, true)).flatMap((symbol) => symbol.manifest.kind === "branch-update" ? [symbol.row.id] : []));
+}
+/** The compiler input a transform compiles; anything else that only needs a module's interface asks for the same one. */
+function transformCompileInput(input) {
+	return {
+		filename: input.filename,
+		moduleId: input.moduleId,
+		source: input.source,
+		...input.serverOnlyProps?.length ? { serverOnlyProps: input.serverOnlyProps } : {},
+		...input.routeRoot ? { routeRoot: true } : {},
+		buildId: input.buildId,
+		resolverId: `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodeURIComponent(input.filename)}`,
+		symbols: input.symbols ?? [],
+		importedModuleInterfaces: input.importedModuleInterfaces,
+		importedModuleConstants: input.importedModuleConstants,
+		artifactChildMaterializations: input.artifactChildMaterializations,
+		omitAuthoredSource: normalizeExecutionLogMode(input.executionLog) === "never"
+	};
+}
+async function compileWithBlockingDiagnostics(input, resolverId) {
+	const compiled = await compileTsrxModule(transformCompileInput(input));
+	const fulfilled = fulfilledEscalationSymbolIds(compiled, input, resolverId);
+	return {
+		compiled,
+		blockingDiagnostics: moduleDiagnostics(compiled).filter((diagnostic) => diagnostic.severity === "error" && !(diagnostic.code === "MARKLESS_BRANCH_ARM_UPDATE_UNSUPPORTED" && typeof diagnostic.symbolId === "string" && fulfilled.has(diagnostic.symbolId)))
+	};
+}
+const diagnosticsByCompile = /* @__PURE__ */ new WeakMap();
+function moduleDiagnostics(compiled) {
+	let diagnostics = diagnosticsByCompile.get(compiled);
+	if (!diagnostics) diagnosticsByCompile.set(compiled, diagnostics = collectTsrxModuleDiagnostics(compiled));
+	return diagnostics;
+}
+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 answersClosurePlans(moduleInterface) {
+	return !!moduleInterface?.render.components.some((component) => component.closureActions);
+}
+function withServedScalarDemand(map, served) {
+	const planned = served.actions.filter((action) => action.plan?.kind === "scalar" || action.plan?.kind === "closure");
+	if (planned.length === 0) return map;
+	const union = (left, right) => [.../* @__PURE__ */ new Set([...left, ...right])].sort();
+	const servedRecords = new Map(served.payloadRecords.map((record) => [record.recordId, record]));
+	const plannedRecordIds = new Set(planned.flatMap((action) => action.payloadRecordIds));
+	return {
+		...map,
+		payloadRecords: map.payloadRecords.map((record) => {
+			const lean = plannedRecordIds.has(record.recordId) ? servedRecords.get(record.recordId) : void 0;
+			return lean ? {
+				...record,
+				runtimeModuleIds: union(record.runtimeModuleIds, lean.runtimeModuleIds)
+			} : record;
+		}),
+		actions: map.actions.map((action) => {
+			const lean = planned.find((candidate) => candidate.hostNodeId === action.hostNodeId && candidate.eventName === action.eventName && candidate.recordKind === action.recordKind);
+			if (!lean) return action;
+			return {
+				...action,
+				runtimeModuleIds: union(action.runtimeModuleIds, lean.runtimeModuleIds),
+				...lean.firstUse ? { firstUse: lean.firstUse } : {},
+				...lean.plan?.kind === "closure" ? { plan: lean.plan } : {}
+			};
+		})
+	};
+}
+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"),
+	overlay: () => true
+};
+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) 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;
+}
+function viewHasIdleEvents(view) {
+	return [
+		view,
+		...(view.branches ?? []).flatMap((branch) => [...branch.armRecords ?? [], ...branch.servedArmRecords ? [branch.servedArmRecords] : []]),
+		...view.asyncBoundaries.flatMap((boundary) => boundary.armRecords && !Array.isArray(boundary.armRecords) ? [boundary.armRecords] : [])
+	].some((set) => (set.events ?? []).some((event) => event.eventName === PROTOCOL_IDLE_EVENT_NAME) || (set.keyedRepeats ?? []).some((repeat) => repeat.rowEvents.some((event) => event.eventName === PROTOCOL_IDLE_EVENT_NAME)));
+}
+function authorsPendingArm(markup) {
+	return markup.chunks.some((chunk) => chunk.slots.some((slot) => slot.kind === "async" && slot.armTemplateIds.pending !== void 0));
+}
+//#endregion
+//#region src/virtual-ids.ts
+const TSRX_SOURCE_FILE = /\.tsrx(?:[?#].*)?$/;
+/** A request that exports its file as a string or URL (`?raw`, `?url`, `?inline`), never runs it. */
+const STRING_EXPORT_QUERY = /[?&](?:raw|url|inline)(?:&|=|$)/;
+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_REACHED_FROM_ROUTE = "route";
+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;
+function stripBuildPrefix(fileName) {
+	return fileName.startsWith("build/") ? 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 isScalarPlanSourceRequest(id) {
+	return isSymbolOnlySourceRequest(id) && new URLSearchParams(parsePath(id).search).has("markless-scalar-plans");
+}
+function isResumeSourceRequest(id) {
+	return MARKLESS_RESUME_SOURCE_QUERY_RE.test(id);
+}
+function isRenderDataSourceRequest(id) {
+	return MARKLESS_RENDER_DATA_SOURCE_QUERY_RE.test(id);
+}
+function renderDataReachedFromQuery(id) {
+	return new URLSearchParams(parsePath(id).search).get(MARKLESS_REACHED_FROM_SOURCE_QUERY) ?? void 0;
+}
+/** The full render data a server-rendered app's client render loads on demand; no resume reaches it. */
+function isClientRenderDataEntry(id) {
+	return normalizeVirtualId(id).startsWith(`${MARKLESS_VIRTUAL_PREFIX}${CLIENT_RENDER_DATA_ENTRY_KIND}:`);
+}
+function isRouteNavigationSourceRequest(id) {
+	return MARKLESS_ROUTE_SOURCE_QUERY_RE.test(id) || isRenderDataSourceRequest(id) && renderDataReachedFromQuery(id) === void 0 && !isServedRenderDataRequest(id);
+}
+function materializedReachedRenderDataSource(source) {
+	return withQuery(source, {
+		"markless-render-data": null,
+		[MARKLESS_REACHED_FROM_SOURCE_QUERY]: MARKLESS_REACHED_FROM_ROUTE
+	});
+}
+function sharedReachedRenderDataRequest(id) {
+	if (!isRenderDataSourceRequest(id)) return void 0;
+	const reachedFrom = renderDataReachedFromQuery(id);
+	return reachedFrom === void 0 || reachedFrom === MARKLESS_REACHED_FROM_ROUTE ? void 0 : withQuery(id, { [MARKLESS_REACHED_FROM_SOURCE_QUERY]: MARKLESS_REACHED_FROM_ROUTE });
+}
+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 isRelativeImport(source) {
+	return source.startsWith("./") || source.startsWith("../");
+}
+function isCompilerStatefulModuleId(id) {
+	const bare = id.startsWith("\0") ? id.slice(1) : id;
+	return TSRX_SOURCE_FILE.test(bare) || bare.startsWith("virtual:markless:") || /[?&]markless-[a-z-]+(?:[=&#]|$)/.test(bare);
+}
+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("?");
+	const segments = (queryIndex === -1 ? bare : bare.slice(0, queryIndex)).slice(MARKLESS_VIRTUAL_PREFIX.length).split(":").map((segment) => {
+		try {
+			return encodeURIComponent(decodeURIComponent(segment));
+		} catch {
+			return segment;
+		}
+	});
+	return `${MARKLESS_VIRTUAL_PREFIX}${segments.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;
+}
+const CLIENT_ONLY_SOURCE_QUERY_KEYS = /* @__PURE__ */ new Set([
+	"markless-render-data",
+	"markless-reached-from",
+	MARKLESS_SERVED_RENDER_DATA_QUERY,
+	"markless-symbols",
+	"markless-scalar-plans"
+]);
+function serverSharedSourceRequest(id, environment) {
+	if (environment !== "server") return void 0;
+	const { pathname: path, search } = parsePath(id);
+	if (!search || !TSRX_SOURCE_FILE.test(path)) return void 0;
+	const keys = [...new URLSearchParams(search).keys()];
+	return keys.length > 0 && keys.every((key) => CLIENT_ONLY_SOURCE_QUERY_KEYS.has(key)) ? path : void 0;
+}
+//#endregion
+//#region src/build/planned-landing.ts
+const MARKLESS_INTERACTION_CLOSURES_ASSET = MARKLESS_INTERACTION_CLOSURES;
+function plannedLandingFiles(bundle) {
+	const asset = bundle[MARKLESS_INTERACTION_CLOSURES_ASSET];
+	if (asset?.type !== "asset" || asset.source === void 0) return void 0;
+	const parsed = JSON.parse(typeof asset.source === "string" ? asset.source : new TextDecoder().decode(asset.source));
+	const planned = /* @__PURE__ */ new Map();
+	for (const route of parsed.routes) if (!route.fallback && route.files) planned.set(route.route, new Set(route.files.firstUse));
+	return planned;
+}
+//#endregion
+export { MARKLESS_INTERACTION_CLOSURES as $, sharedReachedRenderDataRequest as A, stripEmittedTypes as B, materializedReachedRenderDataSource as C, resolveVirtualId as D, renderDataReachedFromQuery as E, sourceForTriggerGroupVirtualImporter as F, PropFlowRegistry as G, transformTsrxModule as H, stripBuildPrefix as I, MARKLESS_BUILD_PREFIX as J, isServedRenderDataRequest as K, virtualModuleSourceForLoad as L, sourceForResumeVirtualImporter as M, sourceForSettleVirtualImporter as N, resolverVirtualModuleSourceFile as O, sourceForSymbolVirtualImporter as P, MARKLESS_EXECUTION_SIZES as Q, marklessVirtualModuleSourceFile as R, isSymbolOnlySourceRequest as S, pathname as T, transformTsrxModuleWithPrerenderWakeClosure as U, transformCompileInput as V, usePersistentStrippedCode as W, MARKLESS_BYTE_ATTRIBUTION as X, MARKLESS_BUNDLE_GRAPH as Y, MARKLESS_EXECUTION_DEMAND as Z, isRelativeImport as _, TSRX_SOURCE_FILE as a, optimizedDepsToInclude as at, isRouteNavigationSourceRequest as b, devBrowserSourceModuleUrl as c, planModulePreloads as ct, executionLogRuntimeModuleId as d, MARKLESS_PUBLIC_BUILD_METADATA_FILES as et, isClientPrimarySourceRequest as f, isPrerenderWakeSourceRequest as g, isMarklessRuntimeModule as h, STRING_EXPORT_QUERY as i, includeOptimizedDeps as it, sourceForPrerenderWakeVirtualImporter as j, serverSharedSourceRequest as k, devBrowserVirtualModuleUrl as l, isCompilerStatefulModuleId as m, plannedLandingFiles as n, RUNTIME_FUNCTIONS_PREFIX as nt, clientRouteArtifactReference as o, runtimeFunctionSpecifiers as ot, isClientRenderDataEntry as p, MARKLESS_BUILD_METADATA_FILES as q, MARKLESS_ROUTE_SOURCE_QUERY_RE as r, excludeSourceShippedDeps as rt, clientSymbolEntries as s, planModulePreloadUrls as st, MARKLESS_INTERACTION_CLOSURES_ASSET as t, outputDefaults as tt, emittedBundleModuleIds as u, isRenderDataSourceRequest as v, normalizeVirtualId as w, isScalarPlanSourceRequest as x, isResumeSourceRequest as y, preflightTsrxModuleDiagnostics as z };