@markless/bundler 0.3.3 → 0.5.0

package/dist/route-pack-groups-BpefyjrE.js

@@ -0,0 +1,2707 @@
+import { joinURL, parsePath, withQuery, withoutLeadingSlash } from "ufo";
+import { MARKLESS_COMPONENT_PART_BRAND } from "@markless/web/render-to-string";
+import { ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, protocolEventActionKind } from "@markless/serializer";
+import { isAbsolute, resolve } from "pathe";
+import { emitSymbolResolverModule } from "@markless/compiler";
+//#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/execution-log.ts
+const MARKLESS_EXECUTION_LOG_MODULE_ID = "virtual:markless:dev-log";
+const MARKLESS_EXECUTION_LOG_GLOBAL = "__mxLog";
+const EXECUTION_LOG_CHUNK_MODULE_PATTERN = /virtual:markless:dev-log|[/\\]web[/\\]src[/\\]dev-log\.ts(?:[?#].*)?$/;
+function isExecutionLogChunk(chunk) {
+	return !!chunk.moduleIds?.length && chunk.moduleIds.every((id) => EXECUTION_LOG_CHUNK_MODULE_PATTERN.test(id));
+}
+const EXECUTION_LOG_DISPATCH_MODULE_IDS = ["web:render-csr", "web:resume-events"];
+const MARKLESS_EXECUTION_LEDGER_GLOBAL = "__marklessExecutionLedger";
+const MARKLESS_EXECUTION_LEDGER_INIT = "{ unit: 'chunk-raw-bytes', load: { app: 0, framework: 0, instrument: 0, inline: 0, modules: [] }, total: { app: 0, framework: 0, instrument: 0, inline: 0 }, turns: [], incomplete: null }";
+const EXECUTION_LOG_GESTURE_EVENTS = [
+	"pointerdown",
+	"touchstart",
+	"keydown"
+];
+const EXECUTION_LOG_FRAMEWORK_ID_PATTERN = "/^(?:web|runtime|serializer|router|core|analyzer):/";
+function normalizeExecutionLogMode(mode) {
+	return mode ?? "auto";
+}
+function injectExecutionLogModuleHook(source, moduleId, mode) {
+	if (normalizeExecutionLogMode(mode) === "never") return source;
+	return `globalThis.__mxLog?.add(${JSON.stringify(moduleId)});\n${source}`;
+}
+const EXECUTION_LOG_HOOK_LINE = /^globalThis\.__mxLog\?\.add\("(?:[^"\\]|\\.)*"\);\n/;
+function hasExecutionLogModuleHook(source) {
+	return EXECUTION_LOG_HOOK_LINE.test(source);
+}
+function requalifyExecutionLogModuleHook(source, moduleId) {
+	if (!EXECUTION_LOG_HOOK_LINE.test(source)) return source;
+	return source.replace(EXECUTION_LOG_HOOK_LINE, `globalThis.__mxLog?.add(${JSON.stringify(moduleId)});\n`);
+}
+function executionLogVirtualModuleSource(options = {}) {
+	if (!options.moduleSizes) return executionLogVirtualModuleSourceWithOwnSize(options, null);
+	return executionLogVirtualModuleSourceWithOwnSize(options, executionLogVirtualModuleSourceWithOwnSize(options, 0).length);
+}
+function executionLogVirtualModuleSourceWithOwnSize(options, ownRawSize) {
+	const moduleSizes = options.moduleSizes ? Object.fromEntries([...[...options.moduleSizes].map(([id, raw]) => [id, {
+		raw,
+		estimated: true
+	}]), [MARKLESS_EXECUTION_LOG_MODULE_ID, {
+		raw: ownRawSize ?? 0,
+		estimated: true,
+		instrument: true
+	}]]) : null;
+	return `
+globalThis.__mxLog?.add(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)});
+const marklessDefaultModuleSizes = ${JSON.stringify(moduleSizes)};
+const marklessDefaultAttribution = ${JSON.stringify(options.attribution ?? null)};
+const marklessSizesUrl = ${JSON.stringify(options.sizesUrl ?? null)};
+let marklessSizesPromise;
+let marklessAttribution;
+let marklessInstallPromise;
+let marklessRenderSummaryTurn;
+function modules(log) { return log ? [...log] : []; }
+function sizeRecord(input) { return !input ? undefined : typeof input === 'number' ? { raw: input, estimated: true } : input; }
+function normalizeSizes(input) { if (!input) return undefined; const map = new Map(); for (const id of Object.keys(input)) if (id !== 'attribution' && id !== 'unshipped') map.set(id, sizeRecord(input[id])); return map; }
+async function loadModuleSizes(input) {
+	if (input.moduleSizes) return normalizeSizes(input.moduleSizes);
+	if (marklessDefaultModuleSizes) { marklessAttribution = marklessDefaultAttribution; return normalizeSizes(marklessDefaultModuleSizes); }
+	if (!marklessSizesUrl) return undefined;
+	marklessSizesPromise ||= fetch(marklessSizesUrl).then((response) => response.ok ? response.json() : undefined).then((payload) => { marklessAttribution = payload && payload.attribution; return normalizeSizes(payload); }).catch(() => undefined);
+	return marklessSizesPromise;
+}
+function symbolParts(id) { const match = /^virtual:markless:symbol:([^:]+):([^:]+)$/.exec(id); if (!match) return null; try { return { source: decodeURIComponent(match[1]), symbolId: decodeURIComponent(match[2]) }; } catch { return null; } }
+function baseSymbolId(id) { if (!id.startsWith('bound:')) return null; const separator = id.indexOf(':', 'bound:'.length); if (separator < 0) return null; try { return decodeURIComponent(id.slice('bound:'.length, separator)); } catch { return null; } }
+function routeFile() { const text = document.querySelector?.('script[type="@markless/core/route"]')?.textContent; if (!text) return null; try { const value = JSON.parse(text).file; return typeof value === 'string' ? value : null; } catch { return null; } }
+// Attribution tables are keyed by the bare path this lookup can name: the
+// document's route file, or — for a routeless page — the build's single root,
+// which is the only page it can be.
+function attributionScopes(tables) { if (!tables) return undefined; const route = routeFile(); if (route) { if (route.includes('..') || route.includes('\\\\')) return undefined; const canonical = route.replace(/^\\/+/, ''); return Object.prototype.hasOwnProperty.call(tables, canonical) ? tables[canonical] : undefined; } const roots = Object.keys(tables); return roots.length === 1 ? tables[roots[0]] : undefined; }
+// A handler renders inside one component but is owned by whichever component
+// created the closure — a prop-passed onClick renders at the child's scope and
+// belongs to the parent. The owner is therefore somewhere on the host's render
+// ancestry, so once the host's OWN scope is one the table names, the chain is
+// walked outward and the first scope holding exactly one candidate wins. Never a
+// guess: a host in a scope the table does not name is refused outright, a scope
+// with zero or several candidates is skipped, and an id nobody owns uniquely
+// stays unmapped.
+function scopeChain(scope) { const chain = []; for (let current = scope; ; ) { chain.push(current); if (!current) return chain; const next = current.replace(/c\\d+:$/, ''); if (next === current) return chain; current = next; } }
+function qualifySymbolIds(ids, hostNodeId, sizes, tables) { const scopes = attributionScopes(tables); if (!scopes) return ids; const host = /^((?:c\\d+:)*)[^:]+$/.exec(hostNodeId); const hostScope = host && host[1]; return ids.map((id) => { const own = /^((?:c\\d+:)+)(.*)$/.exec(id); const scope = own ? own[1] : hostScope; if (scope === null || scope === undefined || !Object.prototype.hasOwnProperty.call(scopes, scope)) return id; const local = own ? own[2] : id; const base = baseSymbolId(local); const sizeSymbolId = base || local; if (!sizeSymbolId.startsWith('symbol:')) return id; for (const candidate of scopeChain(scope)) { if (!Object.prototype.hasOwnProperty.call(scopes, candidate)) continue; const matches = [...(sizes?.keys() || [])].filter((key) => { const match = /^virtual:markless:symbol:([^:]+):([^:]+)$/.exec(key); if (!match || match[1] !== scopes[candidate]) return false; try { return decodeURIComponent(match[2]) === sizeSymbolId; } catch { return false; } }); if (matches.length !== 1) continue; if (!base) return matches[0]; const match = /^virtual:markless:symbol:([^:]+):/.exec(matches[0]); return match ? 'virtual:markless:symbol:' + match[1] + ':' + encodeURIComponent(local) : id; } return id; }); }
+function canonicalId(id, sizes) {
+	if (!sizes || sizes.has(id)) return id;
+	const qualified = symbolParts(id); const local = qualified ? qualified.symbolId : id.replace(/^(?:c\\d+:)+/, ''); const sizeSymbolId = baseSymbolId(local) || local;
+	if (!sizeSymbolId.startsWith('symbol:')) return id;
+	const matches = [...sizes.keys()].filter((key) => { const parts = symbolParts(key); return !!parts && parts.symbolId === sizeSymbolId && (!qualified || parts.source === qualified.source); });
+	return matches.length === 1 ? matches[0] : id;
+}
+function displayId(id) { const parts = symbolParts(id); return parts ? parts.symbolId + ' (' + (parts.source.split('/').pop() || parts.source) + ')' : id; }
+function displayObservedId(id, sizes) { const parts = symbolParts(id); return displayId(baseSymbolId(parts ? parts.symbolId : id) ? id : canonicalId(id, sizes)); }
+function accounting(items, sizes) {
+	const ids = [...new Set(items.map((id) => canonicalId(id, sizes)))];
+	if (!sizes) return { appBytes: ids.length ? null : 0, instrumentBytes: 0, appModules: ids.length, instrumentModules: 0, estimated: { app: false, instrument: false }, unmappedIds: [] };
+	let appBytes = 0, instrumentBytes = 0, appModules = 0, instrumentModules = 0, appEstimated = false, instrumentEstimated = false; const unmappedIds = [];
+	for (const id of ids) { const record = sizes.get(id); if (!record) { appModules++; unmappedIds.push(id); continue; } const bytes = record.raw; instrumentBytes += record.instrumentRaw || 0; if (record.instrument) { instrumentModules++; instrumentBytes += bytes; instrumentEstimated ||= !!record.estimated; } else { appModules++; appBytes += bytes; appEstimated ||= !!record.estimated; } }
+	return { appBytes: unmappedIds.length ? null : appBytes, instrumentBytes, appModules, instrumentModules, estimated: { app: appEstimated, instrument: instrumentEstimated }, unmappedIds };
+}
+function rowKb(items, sizes) { const a = accounting(items, sizes); if (a.unmappedIds.length) return 'bytes unknown'; const total = (a.appBytes || 0) + (a.instrumentBytes || 0); return (total / 1024).toFixed(1) + ' KB' + (a.estimated.app || a.estimated.instrument ? ' est. source' : ''); }
+// One cumulative ledger owns every number the console prints. A module's charge is its own share
+// of its chunk's raw bytes when the build map carries one, else the whole chunk; unit says which.
+function marklessLedger() { return (globalThis.${MARKLESS_EXECUTION_LEDGER_GLOBAL} ||= ${MARKLESS_EXECUTION_LEDGER_INIT}); }
+function ledgerCategory(id, record) { return record && record.instrument ? 'instrument' : ${EXECUTION_LOG_FRAMEWORK_ID_PATTERN}.test(id) ? 'framework' : 'app'; }
+function ledgerCharge(l, ids, sizes) {
+	const seen = (l.chargedIds ||= new Set());
+	const seenChunks = (l.chargedChunks ||= new Set());
+	const delta = { app: 0, framework: 0, instrument: 0, gzip: 0, modules: [], unmapped: [] };
+	const charge = (raw, viaAlias) => {
+		const id = canonicalId(raw, sizes);
+		const record = sizes && sizes.get(id);
+		// A name several modules answer to charges each of them, once.
+		if (record && record.alias) { if (!viaAlias) for (const member of record.alias) charge(member, true); return; }
+		// The dedupe unit is the unit charged: the module when the map splits its chunk, else the
+		// chunk, so one chunk reached under two names is one charge. Dev estimates dedupe by id.
+		const chunk = record && !record.module && record.chunk;
+		if (chunk ? seenChunks.has(chunk) : seen.has(id)) return;
+		if (chunk) seenChunks.add(chunk); else seen.add(id);
+		if (!record) { delta.unmapped.push(id); return; }
+		if (record.estimated) l.unit = 'estimated-source-bytes'; else if (record.module && l.unit !== 'estimated-source-bytes') l.unit = 'module-raw-bytes';
+		delta[ledgerCategory(id, record)] += record.raw; delta.instrument += record.instrumentRaw || 0; delta.gzip += record.gzip || 0; delta.modules.push(id);
+	};
+	for (const raw of ids) charge(raw, false);
+	if (delta.unmapped.length) l.incomplete = { reason: 'unmapped-id', ids: [...new Set([...(l.incomplete ? l.incomplete.ids : []), ...delta.unmapped])] };
+	return delta;
+}
+// Load is everything charged before the FIRST USER GESTURE, which the activation
+// script latches on the gesture itself (loadClosed) rather than on the kind of
+// whichever turn reports first. On an SSR page nothing runs until the click, and
+// the instrument and the wake entry both arrive with it; their render/resume
+// turns are work that gesture caused, so their charge joins the gesture's turn —
+// merged into it if it already exists, carried until it does if it does not.
+function ledgerApply(l, kind, label, delta) {
+	const gesture = kind !== 'render' && kind !== 'resume';
+	if (gesture) l.loadClosed = true;
+	for (const name of ['app', 'framework', 'instrument']) { l.total[name] += delta[name]; if (!l.loadClosed) l.load[name] += delta[name]; }
+	l.totalGzip = (l.totalGzip || 0) + delta.gzip;
+	if (!l.loadClosed) { l.loadGzip = (l.loadGzip || 0) + delta.gzip; for (const id of delta.modules) l.load.modules.push(id); }
+	if (!gesture && l.loadClosed) {
+		const open = l.open;
+		if (open) { open.delta.app += delta.app; open.delta.framework += delta.framework; open.delta.instrument += delta.instrument; for (const id of delta.modules) open.modules.push(id); return open; }
+		const held = (l.carry ||= { app: 0, framework: 0, instrument: 0, modules: [] });
+		held.app += delta.app; held.framework += delta.framework; held.instrument += delta.instrument; for (const id of delta.modules) held.modules.push(id);
+		delta = { app: 0, framework: 0, instrument: 0, modules: [] };
+	}
+	const carry = gesture ? l.carry : undefined;
+	if (carry) l.carry = undefined;
+	const turn = { kind, label, delta: { app: delta.app + (carry ? carry.app : 0), framework: delta.framework + (carry ? carry.framework : 0), instrument: delta.instrument + (carry ? carry.instrument : 0) }, modules: carry ? [...carry.modules, ...delta.modules] : delta.modules };
+	l.turns.push(turn); if (gesture) l.open = turn;
+	return turn;
+}
+function ledgerKb(bytes) { return (bytes / 1024).toFixed(1) + ' KB'; }
+// The instrument is dev-only weight, so it stays out of the headline totals and
+// keeps its own category, exactly as the pre-ledger lines did.
+function ledgerVisible(part) { return part.app + part.framework + part.inline; }
+function ledgerLine(l, turn) {
+	let line = 'markless: ' + ledgerKb(ledgerVisible(l.load)) + ' executed at load';
+	if (turn && turn.kind !== 'render' && turn.kind !== 'resume') line += ' · this ' + turn.kind + ' +' + ledgerKb(turn.delta.app + turn.delta.framework);
+	line += ' · total ' + ledgerKb(ledgerVisible(l.total));
+	if (l.totalGzip) line += ' (gzip ' + ledgerKb(l.totalGzip) + ')';
+	if (l.incomplete) line += ' · ' + l.incomplete.ids.length + ' unmapped (excluded)';
+	return line;
+}
+function ledgerMirror(l, turn, text, attribute) {
+	const root = document.documentElement; if (!root) return;
+	root.setAttribute(attribute, text);
+	root.setAttribute('data-markless-log-unit', l.unit);
+	root.setAttribute('data-markless-log-load-bytes', String(ledgerVisible(l.load)));
+	root.setAttribute('data-markless-log-total-bytes', String(ledgerVisible(l.total)));
+	root.setAttribute('data-markless-log-inline-bytes', String(l.total.inline));
+	if (turn) {
+		root.setAttribute('data-markless-log-app-bytes', String(turn.delta.app));
+		root.setAttribute('data-markless-log-framework-bytes', String(turn.delta.framework));
+		root.setAttribute('data-markless-log-instrument-bytes', String(turn.delta.instrument));
+		root.setAttribute('data-markless-log-turn-bytes', String(turn.delta.app + turn.delta.framework));
+		root.setAttribute('data-markless-log-turn-modules', turn.modules.join(' '));
+		// The headline carries no selector, so the turn's identity lives here.
+		root.setAttribute('data-markless-log-turn-label', turn.kind + (turn.label ? ' ' + turn.label : ''));
+	}
+	if (l.incomplete) root.setAttribute('data-markless-log-incomplete', String(l.incomplete.ids.length)); else root.removeAttribute('data-markless-log-incomplete');
+}
+function warmIds(event) { return [...new Set([event.dispatchModuleId, ...((event.eventRecord && event.eventRecord.symbolIds) || [])].filter(Boolean))]; }
+function causeRows(input) {
+	const before = input.before || new Set(); const after = input.after || new Set(); const woken = [...after].filter((id) => !before.has(id)); const record = input.eventRecord;
+	const cause = record ? input.eventName + ' matched event record ' + record.hostNodeId : input.eventName + ' matched runtime records';
+	const label = (id) => displayObservedId(id, input.moduleSizes) + (input.moduleSizes ? ' (' + rowKb([id], input.moduleSizes) + (input.moduleSizes.get(canonicalId(id, input.moduleSizes))?.instrument ? ' instrument' : '') + ')' : '');
+	const rows = woken.map((id) => 'woke ' + label(id) + ' <- ' + cause);
+	if (record) for (const id of warmIds(input)) rows.push('ran warm ' + label(id) + ' <- ' + cause);
+	if (record && !(input.view?.behaviors || []).some((b) => b.hostNodeId === record.hostNodeId)) rows.push('skip behavior — no matching record touched');
+	return rows;
+}
+function mirrorInteraction(l, turn, text) {
+	const root = document.documentElement; if (!root) return;
+	root.setAttribute('data-markless-log-interactions', String(Number(root.getAttribute('data-markless-log-interactions') || '0') + 1));
+	ledgerMirror(l, turn, text, 'data-markless-log-last');
+}
+export async function installMarklessExecutionLog(input = {}) {
+	const log = globalThis.__mxLog; if (!log || globalThis.__mxLogInteraction) return;
+	if (marklessInstallPromise) return marklessInstallPromise;
+	marklessInstallPromise = (async () => {
+	const moduleSizes = await loadModuleSizes(input); const current = modules(log);
+	if (input.printResumeSummary !== false) {
+		const l = marklessLedger(); const turn = ledgerApply(l, 'resume', undefined, ledgerCharge(l, current, moduleSizes)); const summary = ledgerLine(l, turn);
+		// This summary publishes into the ledger and mirrors; it never prints. The
+		// ledger's turn line is the one printed line, and a resume that lands
+		// beside a render turn would otherwise print the same load figure twice.
+		// A turn merged into an open gesture belongs to that gesture, so it mirrors
+		// onto the interaction attribute instead of the load one.
+		ledgerMirror(l, turn, summary, turn.kind === 'resume' ? 'data-markless-log-summary' : 'data-markless-log-last');
+	}
+	globalThis.__mxLogInteraction = (event) => {
+		const capturedAfter = modules(event.after || log);
+		const symbolIds = qualifySymbolIds((event.eventRecord && event.eventRecord.symbolIds) || [], event.eventRecord && event.eventRecord.hostNodeId, moduleSizes, marklessAttribution);
+		if (event.eventRecord) event = { ...event, eventRecord: { ...event.eventRecord, symbolIds } };
+		const after = capturedAfter; const before = event.before || new Set(); if (log.has(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)}) && !after.includes(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)})) after.push(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)}); const woken = after.filter((id) => !before.has(id)); const warm = warmIds(event);
+		const l = marklessLedger(); const label = '[' + (event.selector || 'event target') + ']';
+		if (event.noMatch) {
+			const turn = ledgerApply(l, event.eventName, label, ledgerCharge(l, [], moduleSizes)); const line = ledgerLine(l, turn) + ' · no event record matched ' + label;
+			console.info(line); mirrorInteraction(l, turn, line); return;
+		}
+		const turn = ledgerApply(l, event.eventName, label, ledgerCharge(l, [...woken, ...warm], moduleSizes)); const header = ledgerLine(l, turn);
+		console.groupCollapsed(header);
+		console.log(event.eventName + ' ' + label + ' · woke ' + woken.length + ' modules · ran warm ' + warm.length + ' modules');
+		for (const row of causeRows({ ...event, after: new Set(after), moduleSizes })) console.log(row);
+		console.groupEnd(); mirrorInteraction(l, turn, header);
+	};
+	log.__marklessInstalled = true;
+	})();
+	return marklessInstallPromise;
+}
+export async function logMarklessInteraction(event) { await installMarklessExecutionLog({ printResumeSummary: false }); globalThis.__mxLogInteraction?.(event); }
+// The inline resumer wakes the runtime with no event (self-wake at load, overlay
+// primer on pointerdown). That is a resume, not a gesture: counting it would
+// close load early and charge one user click as two interactions.
+export async function logMarklessSpecializedInteraction(input, before) {
+	if (!input.event) return logMarklessSpecializedWake();
+	const target = input.element ?? input.event.target;
+	const tag = typeof target?.tagName === 'string' ? target.tagName.toLowerCase() : 'element';
+	await logMarklessInteraction({ eventName: input.event.type ?? 'event', eventRecord: input.eventRecord, before, selector: tag + (target?.id ? '#' + target.id : ''), after: new Set(globalThis.__mxLog) });
+}
+async function logMarklessSpecializedWake() {
+	await installMarklessExecutionLog({ printResumeSummary: false });
+	const log = globalThis.__mxLog; if (!log) return;
+	const moduleSizes = await loadModuleSizes({}); const l = marklessLedger();
+	const turn = ledgerApply(l, 'resume', undefined, ledgerCharge(l, modules(log), moduleSizes));
+	ledgerMirror(l, turn, ledgerLine(l, turn), turn.kind === 'resume' ? 'data-markless-log-summary' : 'data-markless-log-last');
+}
+function marklessRenderSummaryTurnEnd() {
+	// Each injected entry module calls in from its own dynamic-import
+	// resolution, so a microtask window closes between callers of one render;
+	// a frame holds them all. The timeout is the backstop for a document that
+	// never paints, and whichever lands first ends the turn.
+	if (typeof requestAnimationFrame !== 'function') return Promise.resolve();
+	return new Promise((resolve) => { let ended; const end = () => { if (ended) return; ended = true; resolve(); }; requestAnimationFrame(end); setTimeout(end, 50); });
+}
+// Only the console line coalesces: the attribute mirror keeps its per-call
+// last-wins timing, which the interaction mirror interleaves with.
+function coalesceMarklessRenderSummaryLine(summary) {
+	if (marklessRenderSummaryTurn) { marklessRenderSummaryTurn.summary = summary; return marklessRenderSummaryTurn.printed; }
+	const turn = { summary };
+	turn.printed = marklessRenderSummaryTurnEnd().then(() => { marklessRenderSummaryTurn = undefined; console.log(turn.summary); });
+	marklessRenderSummaryTurn = turn;
+	return turn.printed;
+}
+export async function logMarklessRenderSummary(input = {}) {
+	const log = globalThis.__mxLog; if (!log) return;
+	const moduleSizes = await loadModuleSizes(input); const l = marklessLedger();
+	const turn = ledgerApply(l, 'render', undefined, ledgerCharge(l, modules(log), moduleSizes));
+	const summary = ledgerLine(l, turn);
+	if (turn.kind !== 'render') { ledgerMirror(l, turn, summary, 'data-markless-log-last'); return; }
+	ledgerMirror(l, turn, summary, 'data-markless-log-summary');
+	return coalesceMarklessRenderSummaryLine(summary);
+}
+`;
+}
+function executionLogActivationInjection(mode) {
+	if (normalizeExecutionLogMode(mode) === "never") return null;
+	return {
+		tag: "script",
+		location: "head",
+		children: `(() => { const l = location; if (${mode === "always" ? "true" : "/^https?:\\/\\/(?:localhost|127\\.0\\.0\\.1|\\[::1\\])(?::|$)/.test(l.origin) || new URLSearchParams(l.search).has('markless-log') || (() => { try { return localStorage.getItem('marklessLog') === '1'; } catch { return false; } })()"}) { globalThis.__mxLog = globalThis.__mxLog || new Set(); const g = globalThis.${MARKLESS_EXECUTION_LEDGER_GLOBAL} = globalThis.${MARKLESS_EXECUTION_LEDGER_GLOBAL} || ${MARKLESS_EXECUTION_LEDGER_INIT}; const s = document.currentScript && document.currentScript.textContent; if (s) { g.total.inline += s.length; if (!g.loadClosed) g.load.inline += s.length; } const c = (e) => { if (e.isTrusted) g.loadClosed = true; }; for (const t of ${JSON.stringify(EXECUTION_LOG_GESTURE_EVENTS)}) addEventListener(t, c, { capture: true, passive: true }); } })();`
+	};
+}
+//#endregion
+//#region src/scalar-plan-loader.ts
+function emitScalarPlanLoader(actions, routes) {
+	const ordered = routes.filter((route) => route.prefix.length > 0).toSorted((left, right) => right.prefix.length - left.prefix.length);
+	const scalarActions = actions.filter((action) => action.recordKind === "event" && action.plan?.kind === "scalar");
+	if (scalarActions.length === 0 && ordered.length === 0) return "";
+	return [
+		"export function loadScalarActionPlan(symbolId) {",
+		...scalarActions.map((action) => `\tif (symbolId === ${JSON.stringify(action.plan.symbolId)}) return ${JSON.stringify({
+			hostNodeId: action.hostNodeId,
+			eventName: action.eventName,
+			scope: "",
+			plan: action.plan
+		})};`),
+		...ordered.flatMap((route) => [
+			`\tif (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
+			"importSource" in route ? `\t\treturn import(${JSON.stringify(route.importSource)}).then(module => module.loadScalarActionPlan?.(symbolId.slice(${route.prefix.length}))).then(action => action && ({ ...action, scope: ${JSON.stringify(route.prefix)} + action.scope }));` : `\t\treturn Promise.resolve(loadScalarActionPlan(symbolId.slice(${route.prefix.length}))).then(action => action && ({ ...action, scope: ${JSON.stringify(route.prefix)} + action.scope }));`,
+			"	}"
+		]),
+		"}"
+	].join("\n");
+}
+//#endregion
+//#region src/scalar-plan-source.ts
+const MARKLESS_SCALAR_PLAN_SOURCE_QUERY = "markless-scalar-plans";
+function scalarPlanSourceReference(source) {
+	return withQuery(source, {
+		"markless-symbols": null,
+		[MARKLESS_SCALAR_PLAN_SOURCE_QUERY]: null
+	});
+}
+//#endregion
+//#region src/rebound-symbol-route.ts
+function emitReboundSymbolRoute(route, reboundName, localLoader, unboundLoad, indent) {
+	if (!hasBoundSymbols(route)) return [];
+	const rest = `symbolId.slice(${route.prefix.length})`;
+	return [`${indent}const bound = ${JSON.stringify(route.boundSymbols)};`, `${indent}if (Object.hasOwn(bound, ${rest})) return ${reboundName}(${localLoader}(bound[${rest}]), ${JSON.stringify(route.prefix)}, () => ${unboundLoad});`];
+}
+function emitReboundSymbolImport(routes, reboundName) {
+	return routes.some(hasBoundSymbols) ? `import { marklessReboundSymbol as ${reboundName} } from '@markless/web/fns/rebound-symbol';` : "";
+}
+function hasBoundSymbols(route) {
+	return route.boundSymbols !== void 0 && Object.keys(route.boundSymbols).length > 0;
+}
+//#endregion
+//#region src/source-module.ts
+const MARKLESS_VIRTUAL_PREFIX = "virtual:markless:";
+const MARKLESS_BOUND_SYMBOLS_EXPORT = "marklessBoundSymbols";
+const RESUME_ENTRY_SPECIFIER = "@markless/core/web/resume";
+const STORAGE_FREE_RESUME_ENTRY_SPECIFIER = "@markless/core/web/resume-storage-free";
+const SYMBOL_VIRTUAL_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}symbol:`;
+function symbolVirtualModuleId(filename, symbolId) {
+	return `${SYMBOL_VIRTUAL_PREFIX}${encodeURIComponent(filename)}:${encodeURIComponent(symbolId)}`;
+}
+function symbolEntryVirtualModuleId(filename, symbolId) {
+	return `${symbolVirtualModuleId(filename, symbolId)}:entry`;
+}
+function encodedSymbolSource(filename) {
+	return encodeURIComponent(filename);
+}
+function symbolVirtualModuleSourceFile(moduleId) {
+	const bare = moduleId.startsWith("\0") ? moduleId.slice(1) : moduleId;
+	if (!bare.startsWith(SYMBOL_VIRTUAL_PREFIX)) return null;
+	const encoded = bare.slice(SYMBOL_VIRTUAL_PREFIX.length);
+	const separator = encoded.indexOf(":");
+	if (separator <= 0 || separator === encoded.length - 1) return null;
+	if (encoded.includes(":", separator + 1)) return null;
+	try {
+		return decodeURIComponent(encoded.slice(0, separator));
+	} catch {
+		return null;
+	}
+}
+function resumeVirtualModuleId(filename) {
+	return `${MARKLESS_VIRTUAL_PREFIX}resume:${encodeURIComponent(filename)}`;
+}
+function prerenderWakeVirtualModuleId(filename) {
+	return `${MARKLESS_VIRTUAL_PREFIX}prerender-wake:${encodeURIComponent(filename)}`;
+}
+function settleVirtualModuleId(filename) {
+	return `${MARKLESS_VIRTUAL_PREFIX}settle:${encodeURIComponent(filename)}`;
+}
+/**
+* The settle module: import targets and data, no logic. It carries the DOM
+* filler, each boundary's async runner keyed by graph node, and each bound
+* symbol's compiled derive function keyed by the id the fill plan references.
+* Rolldown resolves the real chunk urls, so nothing here is a url the document
+* has to carry, and a page that never settles an arm never loads it.
+*/
+function emitSettleModule(input) {
+	const imports = [...input.runners, ...input.derives].map((entry) => entry.symbol);
+	const seen = /* @__PURE__ */ new Map();
+	const lines = ["export { marklessApplySettlePlan as f } from '@markless/web/fns/settle-plan';"];
+	for (const symbol of imports) {
+		if (seen.has(symbol.id)) continue;
+		seen.set(symbol.id, symbol.exportName);
+		lines.push(`import { ${symbol.exportName} } from ${JSON.stringify(symbol.chunk)};`);
+	}
+	const entries = (rows) => `{${rows.map((row) => `${JSON.stringify(row.key)}: ${seen.get(row.symbolId)}`).join(",")}}`;
+	lines.push(`export const r = ${entries(input.runners.map((entry) => ({
+		key: entry.node,
+		symbolId: entry.symbol.id
+	})))};`);
+	lines.push(`export const d = ${entries(input.derives.map((entry) => ({
+		key: entry.id,
+		symbolId: entry.symbol.id
+	})))};`);
+	return `${lines.join("\n")}\n`;
+}
+function prerenderWakeVirtualModuleSourceFile(moduleId) {
+	const bare = moduleId.startsWith("\0") ? moduleId.slice(1) : moduleId;
+	const prefix = `${MARKLESS_VIRTUAL_PREFIX}prerender-wake:`;
+	if (!bare.startsWith(prefix)) return null;
+	try {
+		return decodeURIComponent(bare.slice(prefix.length));
+	} catch {
+		return null;
+	}
+}
+function scopedSymbolExportName(moduleId, exportName) {
+	return `${exportName}_${stringHash(moduleId)}`;
+}
+function rewriteSymbolModuleExport(source, fromExportName, toExportName) {
+	return source.replace(`export function ${fromExportName}`, `export function ${toExportName}`).replace(`export async function ${fromExportName}`, `export async function ${toExportName}`);
+}
+function payloadModule(payload) {
+	return [
+		`export const state = ${JSON.stringify(payload.state, null, "	")};`,
+		`export const runtimeDemandMap = ${JSON.stringify(withoutFirstUse(payload.runtimeDemandMap), null, "	")};`,
+		`export const view = ${JSON.stringify(payload.view, null, "	")};`,
+		""
+	].join("\n");
+}
+function withoutFirstUse(runtimeDemandMap) {
+	const map = runtimeDemandMap;
+	if (!map?.actions?.some((action) => "firstUse" in action) && !(map && ("firstUsePage" in map || "armActions" in map))) return runtimeDemandMap;
+	const { firstUsePage: _firstUsePage, armActions: _armActions, ...rest } = map;
+	return {
+		...rest,
+		...map.actions ? { actions: map.actions.map((action) => {
+			const { firstUse: _firstUse, ...fields } = action;
+			return fields;
+		}) } : {}
+	};
+}
+/** The module-local name a direct-CSR module's root renders under. */
+function csrRootLocalName(rootExportName) {
+	return `marklessCsr${rootExportName}`;
+}
+function emitPublicRenderModule(source, input) {
+	if (!input.rootExportName) return source;
+	const declaration = `export function ${input.rootExportName}()`;
+	if (!source.includes(declaration)) throw new Error(`MARKLESS_CSR_ROOT_DECLARATION_MISSING: ${input.rootExportName}`);
+	const localName = csrRootLocalName(input.rootExportName);
+	if (!input.executionLogEnabled) return source.replace(declaration, `function ${localName}()`);
+	const implementationName = `marklessRender${input.rootExportName}`;
+	return [
+		source.replace(declaration, `function ${implementationName}()`),
+		`function ${localName}() {`,
+		`\tconst output = ${implementationName}();`,
+		"	if (globalThis.__mxLog) globalThis.__mxLoadLog().then(log => log.logMarklessRenderSummary());",
+		"	return output;",
+		"}"
+	].join("\n");
+}
+function emitSourceModule(input) {
+	if (input.directCsr && input.prerenderRecords) input = {
+		...input,
+		prerenderRecords: false
+	};
+	const symbolsOnly = input.environment === "client" && input.clientOutput === "symbols-only";
+	const routeSymbols = input.environment === "client" && input.symbolRoutes.length > 0;
+	const canonicalRenderData = input.environment === "client" && !symbolsOnly && !input.prerenderRecords && input.canonicalRenderData === true && input.publicRenderRootExportName === null && !!input.publicSsrModuleSource && !!input.renderDataId;
+	const emitsSsrBody = !!input.publicSsrModuleSource && !(input.environment === "client" && (symbolsOnly || !input.prerenderRecords && !input.dev));
+	const csrRootName = input.environment !== "server" && !symbolsOnly && !input.prerenderRecords && input.publicRenderRootExportName ? csrRootLocalName(input.publicRenderRootExportName) : null;
+	return [
+		!input.publicSsrModuleSource && !input.publicRenderModuleSource || symbolsOnly || !input.renderDataId || input.environment === "client" && !input.publicRenderModuleSource && !input.prerenderRecords && !input.dev && !canonicalRenderData ? "" : canonicalRenderData ? emitsSsrBody ? `import { marklessPrerenderData, marklessRenderData } from '${input.renderDataId}';` : `import { marklessPrerenderData } from '${input.renderDataId}';` : `import { marklessRenderData } from '${input.renderDataId}';`,
+		symbolsOnly ? "" : `import { state as payloadState, view as payloadView, runtimeDemandMap as payloadRuntimeDemandMap } from '${input.payloadId}';`,
+		input.environment === "client" && input.directCsr === true && input.hasComputedState === true ? ["import { installMarklessDerivedReconcile } from '@markless/web/fns/reconcile-plane';", "installMarklessDerivedReconcile();"].join("\n") : null,
+		input.environment === "client" && input.hasComputedState === true ? emitRosterResumeLoaderInstall() : null,
+		input.environment === "client" && input.hasOverlayMarks === true ? emitOverlayLoaderInstall() : null,
+		input.environment === "client" && input.hasIdleEvents === true && !symbolsOnly ? emitIdleTriggerInstall() : null,
+		input.environment === "client" ? clientRowMintLoader(input) : null,
+		"",
+		emitLoadSymbol(input),
+		symbolsOnly && input.scalarActions ? emitScalarPlanLoader(input.scalarActions, input.symbolRoutes.map((route) => "importSource" in route ? {
+			...route,
+			importSource: scalarPlanSourceReference(route.importSource)
+		} : route)) : "",
+		symbolsOnly && input.closureActions && emitsClosurePlanLoader(input.closureActions, input.closurePlanRoutes ?? []) ? `${emitClosurePlanRoute(input.closurePlanRoutes ?? [], "loadClosureActionPlan", input.closureActions)}\nexport { loadClosureActionPlan };` : null,
+		input.behaviorSymbols?.length ? emitDirectSourceSymbolLoader(input.behaviorSymbols, "readMarklessBehaviorSourceSymbol").replace("function loadSymbol(", "function loadBehaviorSymbol(") : "",
+		input.environment === "client" && input.executionLog !== "never" ? emitExecutionLogLoader() : "",
+		routeSymbols ? "const marklessLoadLocalSymbol = loadSymbol;" : "",
+		(symbolsOnly || input.publicRenderRootExportName === null) && !routeSymbols ? "export { loadSymbol };" : "",
+		symbolsOnly ? "" : "export { payloadView };",
+		symbolsOnly ? "" : "export { payloadRuntimeDemandMap };",
+		input.devResumeReexport && input.environment === "client" ? `export { resumeContainerEvent } from '${resumeVirtualModuleId(input.filename)}';` : "",
+		"",
+		input.environment === "server" || symbolsOnly || input.prerenderRecords ? "" : emitPublicRenderModule(input.publicRenderModuleSource, {
+			executionLogEnabled: input.executionLog !== "never",
+			rootExportName: input.publicRenderRootExportName
+		}),
+		emitsSsrBody ? input.publicSsrModuleSource : "",
+		routeSymbols ? emitLazySymbolRouteFunction(input.symbolRoutes, "marklessSsrLoadSymbolRoute", "marklessLoadLocalSymbol", input.scalarActions !== void 0) : "",
+		routeSymbols && !symbolsOnly && input.directCsr === true ? emitComposedArmRecordsInstall() : null,
+		symbolsOnly && routeSymbols ? "export { marklessSsrLoadSymbolRoute as loadSymbol };" : "",
+		symbolsOnly ? "" : emitCompiledAppDefault({
+			environment: input.environment,
+			executionLog: input.executionLog,
+			headInjections: input.headInjections,
+			storageSeeds: input.storageSeeds,
+			inlineResumerSources: input.inlineResumerSources,
+			prerenderBoot: input.prerenderBoot,
+			resumeModuleUrl: input.resumeModuleUrl,
+			prerenderWakeModuleUrl: input.prerenderWakeModuleUrl,
+			rootExportName: input.publicRenderRootExportName,
+			csrRootName,
+			symbolLoaderName: routeSymbols ? "marklessSsrLoadSymbolRoute" : "loadSymbol",
+			ssrExportName: input.publicRenderSsrExportName,
+			ssrComponents: input.publicRenderSsrComponentExports ?? [],
+			canonicalRenderData,
+			prerenderRecords: input.prerenderRecords,
+			dev: input.dev
+		}),
+		...emitSharedDefinitionExports(input.sharedDefinitionExports ?? [], input.publicRenderSsrComponentExports ?? []),
+		""
+	].filter((line) => line !== null).join("\n");
+}
+const MARKLESS_SHARED_CALL_UNCOMPILED = "MARKLESS_SHARED_CALL_UNCOMPILED";
+/**
+* One real ES named export per authored shared definition, bound to a callable
+* that only ever throws.
+*
+* The export exists for two reasons, and neither is "run the definition".
+* Linking first: a `.ts` barrel writing `export { nscShared as state } from
+* './family.tsrx'` is resolved before anything runs, and the emitted module
+* replacing the authored one wholesale made that a SyntaxError. Failing closed
+* second: a compiled consumer's `family.state()` is lowered by the compiler and
+* never reaches this binding, so anything that DOES reach it is an uncompiled
+* call site, which cannot be served correctly — a shared instance resolves
+* against the widget the caller renders under, and an uncompiled call has no
+* such caller. It throws by name rather than quietly becoming a second,
+* unratified runtime API.
+*/
+function emitSharedDefinitionExports(sharedExports, ssrComponents) {
+	if (sharedExports.length === 0) return [];
+	const taken = /* @__PURE__ */ new Set([...RESERVED_MODULE_BINDINGS, ...ssrComponents.map((component) => component.exportName)]);
+	return sharedExports.map((name) => {
+		if (taken.has(name)) throw new Error(`MARKLESS_SHARED_EXPORT_NAME_RESERVED: ${name}`);
+		taken.add(name);
+		const message = `${MARKLESS_SHARED_CALL_UNCOMPILED}: ${name} — a shared definition can only be called from a compiled module; this call site was not compiled.`;
+		return `export const ${name} = () => { throw new Error(${JSON.stringify(message)}); };`;
+	});
+}
+/**
+* Whether this app's serialized state defines any computed node. Computed
+* definitions are what `createRuntimeGraph` turns into derived graph nodes on
+* resume, so they are exactly the apps derived reconciliation can act on.
+*/
+function payloadHasComputed(payloadState) {
+	const computed = payloadState?.computed;
+	return Array.isArray(computed) && computed.length > 0;
+}
+function emitIdleTriggerInstall() {
+	return ["import { installMarklessIdle } from '@markless/web/fns/idle-trigger';", "installMarklessIdle();"].join("\n");
+}
+/**
+* The one line that makes elevation cost nothing until it is used.
+*
+* Writing the `import()` specifier HERE rather than in the runtime is the whole
+* mechanism: a module every app loads cannot name the behaviour without making
+* every app ship its chunk. The handoff is a global rather than a slot module
+* for the same reason - a slot module is bytes every app pays for a capability
+* most of them do not have. Nothing is fetched until the runtime calls it.
+*/
+function emitOverlayLoaderInstall() {
+	return [
+		"globalThis.__marklessOverlay = (root) =>",
+		"	root.querySelector('[overlay]')",
+		"		? import('@markless/web/fns/overlay').then((m) => m.installOverlayBehavior(root))",
+		"		: undefined;"
+	].join("\n");
+}
+/**
+* The same one line for the live roster, gated on the same fact the reconcile
+* plane is gated on: a payload with no computed nodes can hold no roster
+* derivation, so it never names the module and never emits its chunk.
+*
+* Both call sites (the start-up wiring and a sync computed's re-derive) sit in
+* modules every resumed page runs, which is why neither may write the specifier.
+* A composed MDX route writes it too: it cannot see its islands' computeds.
+*/
+function emitRosterResumeLoaderInstall() {
+	return "globalThis.__marklessRosterResume ??= () => import('@markless/web/fns/roster-resume');";
+}
+/**
+* The same one line for the row mint, and for the same reason.
+*
+* `resume-keyed-repeats` is loaded by EVERY repeat, so it cannot name the
+* building half: doing so makes an app whose rows only reorder emit the mint
+* chunk anyway. Written here, the specifier exists only in a build the compiler
+* recorded a mintable repeat for; the repeat runtime reads the loader off the
+* global and refuses to build without one.
+*/
+function emitRowMintLoaderInstall() {
+	return "globalThis.__marklessRowMint ??= () => import('@markless/web/fns/row-mint');";
+}
+/**
+* The same one line for per-enclosing-row wiring: only a page holding a `@for`
+* inside another `@for`'s rows names the module, so no other app emits its chunk.
+*/
+function nestedRepeatsLoader(runtimeDemandMap) {
+	return demandsKeyedRepeatModule(runtimeDemandMap, NESTED_REPEATS_RUNTIME_MODULE_ID) ? ["globalThis.__marklessNestedRepeats ??= (...input) =>", "	import('@markless/web/fns/nested-repeats').then((nested) => nested.wireNestedRepeats(...input));"].join("\n") : null;
+}
+/**
+* True when the compiler folded the mint into a keyed-repeat record - which it
+* does exactly for a record carrying `rowTemplate` or `emptyArm`, the two fields
+* that make a repeat able to build nodes.
+*/
+function demandsRowMint(runtimeDemandMap) {
+	const records = runtimeDemandMap?.payloadRecords;
+	return Array.isArray(records) && records.some((record) => record.kind === "keyed-repeat" && record.runtimeModuleIds?.includes(ROW_MINT_RUNTIME_MODULE_ID) === true);
+}
+/**
+* The component-rooted mint, which also needs this page's render-data surface.
+*
+* It answers the SAME global as the template mint, whose builders it re-exports:
+* the repeat runtime carries no second loader, so a page with no component row
+* ships not one byte of this path. Nothing page-specific is written here - every
+* page emits this same line - because one document can hold several modules that
+* install a mint, and the one that builds every kind of row must keep the global
+* whichever is evaluated last. The surface travels on the runtime input instead
+* and arrives as the loader's first argument.
+*/
+function emitRowComponentMintLoaderInstall() {
+	return [
+		"globalThis.__marklessRowMint = Object.assign(",
+		"	(...input) => import('@markless/web/fns/row-component-mint').then((mint) => mint.marklessRowComponentMint(...input)),",
+		"	{ components: true },",
+		");"
+	].join("\n");
+}
+function componentRowLoader(input) {
+	if (!input.renderDataId) return void 0;
+	if (input.linkedRowComponents || demandsKeyedRepeatModule(input.runtimeDemandMap, ROW_COMPONENT_MINT_RUNTIME_MODULE_ID)) return emitRowComponentMintLoaderInstall();
+	return input.linkedRowSlotReaders || demandsKeyedRepeatModule(input.runtimeDemandMap, ROW_SLOT_MINT_RUNTIME_MODULE_ID) ? emitRowSlotMintLoaderInstall() : void 0;
+}
+function clientRowMintLoader(input) {
+	const mint = demandsRowComponentMint(input.runtimeDemandMap) ? emitRowComponentMintLoaderInstall() : componentRowLoader(input) ?? (demandsRowMint(input.runtimeDemandMap) ? emitRowMintLoaderInstall() : null);
+	const nested = nestedRepeatsLoader(input.runtimeDemandMap);
+	return mint && nested ? `${mint}\n${nested}` : mint ?? nested;
+}
+function emitRowSlotMintLoaderInstall() {
+	return ["if (!globalThis.__marklessRowMint?.components) globalThis.__marklessRowMint = (...input) =>", "	import('@markless/web/fns/row-slot-mint').then((mint) => mint.marklessRowSlotMint(...input));"].join("\n");
+}
+/**
+* True when the compiler folded the component mint into a keyed-repeat record -
+* which it does exactly for a record carrying `rowComponent`.
+*/
+function demandsRowComponentMint(runtimeDemandMap) {
+	return demandsKeyedRepeatModule(runtimeDemandMap, ROW_COMPONENT_MINT_RUNTIME_MODULE_ID);
+}
+function demandsKeyedRepeatModule(runtimeDemandMap, moduleId) {
+	const records = runtimeDemandMap?.payloadRecords;
+	return Array.isArray(records) && records.some((record) => record.kind === "keyed-repeat" && record.runtimeModuleIds?.includes(moduleId) === true);
+}
+const ROW_MINT_RUNTIME_MODULE_ID = "web/fns/row-mint";
+const NESTED_REPEATS_RUNTIME_MODULE_ID = "web/fns/nested-repeats";
+const ROW_COMPONENT_MINT_RUNTIME_MODULE_ID = "web/fns/row-component-mint";
+const ROW_SLOT_MINT_RUNTIME_MODULE_ID = "web/fns/row-slot-mint";
+/** True when the compiler recorded an `overlay` mark for this module. */
+function demandsOverlay(runtimeDemandMap) {
+	const records = runtimeDemandMap?.payloadRecords;
+	return Array.isArray(records) && records.some((record) => record.kind === "overlay");
+}
+function emitResumeModule(input) {
+	const routeSymbols = input.symbolRoutes.length > 0;
+	const resumeSymbolLoader = routeSymbols ? "marklessSsrLoadSymbolRoute" : "loadSymbol";
+	const servedPlansOnly = leanResumeMode(input.runtimeDemandMap) === "none" && leanResumeMode(input.servedScalarPlans) !== "none";
+	const scalarSpecializations = scalarDispatcherSpecializations(servedPlansOnly ? {
+		...input,
+		runtimeDemandMap: input.servedScalarPlans
+	} : input);
+	const stagedPrerender = (input.prerenderTriggerGroups?.length ?? 0) > 0;
+	const resumeContainerEvent = emitQueuedResumeContainerEvent(emitResumeContainerEvent(resumeSymbolLoader, input.needsFullResume ?? false, input.payloadState?.version === ASYNC_PROTOCOL_VERSION, servedPlansOnly ? "scalar" : composedLeanMode(input.symbolRoutes.length > 0, leanResumeMode(input.runtimeDemandMap)), scalarSpecializations, input.runtimeDemandMap, input.executionLog !== "never", input.prerenderDataId, stagedPrerender, componentRowLoader(input) ? input.lazyRenderDataId ?? input.renderDataId : void 0, input.symbolRoutes.length > 0 || servedPlansOnly, (input.closurePlanRoutes ?? []).some((route) => "importSource" in route) && scalarSpecializations.length > 0 && !input.prerenderDataId, input.streamsArms === true));
+	const closureImports = [
+		"marklessClosureRouted",
+		"marklessPrimeClosure",
+		"marklessPrimeRoutedClosure",
+		"marklessRunClosureAction",
+		"marklessRunRoutedClosure"
+	].filter((name) => resumeContainerEvent.includes(name));
+	return [
+		input.boundSymbolDescriptors ? `export const ${MARKLESS_BOUND_SYMBOLS_EXPORT} = ${emitBoundSymbolDescriptors(input.boundSymbolDescriptors)};` : null,
+		input.prerenderDataId && !stagedPrerender && resumeContainerEvent.includes("marklessPrerenderData") ? `import { marklessPrerenderData } from '${input.prerenderDataId}';` : null,
+		stagedPrerender && input.prerenderDataId ? `async function marklessLoadPrerenderData() { const module = await import('${input.lazyRenderDataId ?? input.prerenderDataId}'); return module.marklessPrerenderData; }` : null,
+		`import { runtimeDemandMap as payloadRuntimeDemandMap } from '${input.payloadId}';`,
+		payloadHasComputed(input.payloadState) ? [
+			"import { installMarklessDerivedReconcile } from '@markless/web/fns/reconcile-plane';",
+			"installMarklessDerivedReconcile();",
+			emitRosterResumeLoaderInstall()
+		].join("\n") : input.rosterDerivation === true ? emitRosterResumeLoaderInstall() : null,
+		demandsOverlay(input.runtimeDemandMap) ? emitOverlayLoaderInstall() : null,
+		input.hasIdleEvents ? emitIdleTriggerInstall() : null,
+		componentRowLoader(input) ?? (demandsRowMint(input.runtimeDemandMap) ? emitRowMintLoaderInstall() : null),
+		nestedRepeatsLoader(input.runtimeDemandMap),
+		scalarSpecializations.length > 0 ? [
+			"import { marklessDecodeScalarCell, marklessReadScalarCell, marklessScalarSpecializedError } from '@markless/web/fns/scalar-specialized';",
+			resumeContainerEvent.includes("marklessScalarServedOwner") ? `import { marklessScalarLocate, marklessScalarServedOwner, marklessScalarServedPrime${resumeContainerEvent.includes("marklessScalarServedRecord") ? ", marklessScalarServedRecord" : ""} } from '@markless/web/fns/scalar-served';` : "",
+			...closureImports.length > 0 ? [`import { ${closureImports.join(", ")} } from '@markless/web/fns/closure-action';`] : [],
+			"import { marklessWriteScalar } from '@markless/web/fns/write-scalar';",
+			"import { marklessUpdateText } from '@markless/web/fns/update-text';"
+		].join("\n") : "",
+		scalarSpecializations.length > 0 || stagedPrerender ? "import { marklessFindElementAtDomOrderIndex } from '@markless/web/fns/dom-order';" : "",
+		"",
+		input.executionLog === "never" ? "" : emitExecutionLogLoader(),
+		input.installResumeSummary && input.executionLog !== "never" ? "if (globalThis.__mxLog) globalThis.__mxLoadLog().then(log => log.installMarklessExecutionLog());" : null,
+		"",
+		emitLoadSymbol(input, stagedPrerender ? "readMarklessWakeSourceSymbol" : void 0),
+		routeSymbols ? "const marklessLoadLocalSymbol = loadSymbol;" : "",
+		routeSymbols ? emitLazySymbolRouteFunction(input.symbolRoutes, "marklessSsrLoadSymbolRoute", "marklessLoadLocalSymbol") : "",
+		routeSymbols ? "export { marklessSsrLoadSymbolRoute as loadSymbol };" : "",
+		routeSymbols ? emitComposedArmRecordsInstall() : null,
+		stagedPrerender ? emitPrerenderTriggerGroupLoader(input.prerenderTriggerGroups ?? []) : "",
+		resumeContainerEvent.includes("marklessClosurePlanRoute") ? emitClosurePlanRoute(input.closurePlanRoutes ?? [], "marklessClosurePlanRoute", []) : null,
+		resumeContainerEvent,
+		""
+	].filter((line) => line !== null).join("\n");
+}
+function emitBoundSymbolDescriptors(descriptors) {
+	return JSON.stringify(Object.fromEntries(Object.keys(descriptors).sort().map((boundaryId) => [boundaryId, descriptors[boundaryId]])));
+}
+function emitQueuedResumeContainerEvent(source, { censusRepair = true } = {}) {
+	const implementation = source.replace("export async function resumeContainerEvent", "async function marklessResumeContainerEvent");
+	if (implementation === source) throw new Error("MARKLESS_RESUME_DISPATCH_EXPORT_MISSING");
+	return [
+		implementation,
+		"export function resumeContainerEvent(input) {",
+		"	const root = input.root;",
+		censusRepair ? "	if (root.__marklessShifted) return import('@markless/web/fns/served-census-repair').then((census) => (census.marklessRepairCensus(root), resumeContainerEvent(input)));" : "",
+		"	if (!root.__marklessDispatch) {",
+		"		let handler = marklessResumeContainerEvent, tail = Promise.resolve(), done = tail, lastEvent = null, lastEventTime = undefined;",
+		"		root.__marklessRegisterDispatch = next => {",
+		"			const fallback = handler;",
+		"			handler = input => next(input, fallback);",
+		"		};",
+		"		root.__marklessDispatch = next => {",
+		"			const event = next.event, eventTime = event?.timeStamp;",
+		"			if (event && next.eventRecord && next.element) event.__marklessPressHost ??= next.element;",
+		"			if (event === lastEvent && eventTime === lastEventTime) return done;",
+		"			lastEvent = event;",
+		"			lastEventTime = eventTime;",
+		"			let release;",
+		"			const started = new Promise(resolve => release = resolve);",
+		"			const run = () => (root.__marklessReleaseDispatch = release, handler(next));",
+		"			done = tail.then(run, run);",
+		"			done.then(release, release);",
+		"			tail = started;",
+		"			return done;",
+		"		};",
+		"	}",
+		"	return root.__marklessDispatch(input);",
+		"}"
+	].join("\n");
+}
+function emitComposedArmRecordsInstall() {
+	return ["import { installMarklessComposedArmRecords } from '@markless/web/fns/instance-scope';", "installMarklessComposedArmRecords();"].join("\n");
+}
+function emitLazySymbolRouteFunction(routes, functionName, fallbackName = "loadSymbol", includeScalarActionPlans = false) {
+	if (routes.length === 0) return "";
+	const ordered = [...routes].sort((left, right) => right.prefix.length - left.prefix.length);
+	const reboundName = `${functionName}Rebound`;
+	return [
+		emitReboundSymbolImport(ordered, reboundName),
+		`function ${functionName}(symbolId) {`,
+		...ordered.flatMap((route) => {
+			const unbound = "importSource" in route ? `import(${JSON.stringify(symbolRouteImportSource$1(route.importSource, includeScalarActionPlans))}).then((mod) => mod.loadSymbol ? mod.loadSymbol(symbolId.slice(${route.prefix.length})) : Promise.reject(new Error(\`Unknown child async symbol \${symbolId}\`)))` : `${route.prefix.length > 0 ? functionName : fallbackName}(symbolId.slice(${route.prefix.length}))`;
+			return [
+				`	if (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
+				...emitReboundSymbolRoute(route, reboundName, fallbackName, unbound, "		"),
+				`		return ${unbound};`,
+				"	}"
+			];
+		}),
+		`	return ${fallbackName}(symbolId);`,
+		"}"
+	].filter((line) => line !== "").join("\n");
+}
+function emitsClosurePlanLoader(actions, routes) {
+	return routes.some((route) => "importSource" in route) || actions.some((action) => action.plan?.kind === "closure");
+}
+function emitClosurePlanRoute(routes, functionName, actions) {
+	const shapes = [];
+	const local = actions.filter((action) => action.recordKind === "event" && action.plan?.kind === "closure").map((action) => {
+		const { symbolId, cells, computed, updates } = action.plan;
+		const shape = JSON.stringify({
+			cells,
+			computed,
+			updates
+		});
+		if (!shapes.includes(shape)) shapes.push(shape);
+		return `\t${JSON.stringify(symbolId)}: { symbolId: ${JSON.stringify(symbolId)}, ...marklessLocalClosureShapes[${shapes.indexOf(shape)}] },`;
+	});
+	const ordered = [...routes].sort((left, right) => right.prefix.length - left.prefix.length);
+	const localLookup = local.length > 0 ? "Object.hasOwn(marklessLocalClosurePlans, symbolId) ? marklessLocalClosurePlans[symbolId] : undefined" : "undefined";
+	return [
+		local.length > 0 ? [
+			`const marklessLocalClosureShapes = [${shapes.join(", ")}];`,
+			"const marklessLocalClosurePlans = {",
+			...local,
+			"};"
+		].join("\n") : "",
+		`function ${functionName}(symbolId) {`,
+		...ordered.flatMap((route) => [
+			`	if (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
+			"importSource" in route ? `		return import(${JSON.stringify(symbolRouteImportSource$1(route.importSource))}).then((mod) => mod.loadClosureActionPlan?.(symbolId.slice(${route.prefix.length})));` : route.prefix.length > 0 ? `		return ${functionName}(symbolId.slice(${route.prefix.length}));` : `		return ${localLookup};`,
+			"	}"
+		]),
+		`	return ${localLookup};`,
+		"}"
+	].filter(Boolean).join("\n");
+}
+function symbolRouteImportSource$1(importSource, includeScalarActionPlans = false) {
+	if (includeScalarActionPlans) return scalarPlanSourceReference(importSource);
+	return importSource.includes("?") ? `${importSource}&markless-symbols` : `${importSource}?markless-symbols`;
+}
+function emitCompiledAppDefault(input) {
+	const renderCsrEntry = input.csrRootName ? [`	renderCsr: ${input.csrRootName},`] : [];
+	const symbolLoaderEntry = input.environment !== "server" && input.rootExportName === null ? [`\tloadSymbol: ${input.symbolLoaderName},`] : input.prerenderRecords === true ? [`\tloadSymbol: ${input.symbolLoaderName},`] : [];
+	const renderDataEntry = input.canonicalRenderData ? ["	renderData: marklessPrerenderData,"] : [];
+	const servesSsr = !!input.ssrExportName && (input.environment !== "client" || input.prerenderRecords || input.dev);
+	const renderSsrEntry = servesSsr ? [
+		"	renderSsr(props, marklessRenderContext) {",
+		`		return ${input.ssrExportName}(props, marklessRenderContext);`,
+		"	},"
+	] : [];
+	const renderSsrComponentsEntry = servesSsr && input.ssrComponents.length > 0 ? [`	renderSsrComponents: { ${input.ssrComponents.map((component) => `${JSON.stringify(component.exportName)}: { renderSsr: ${component.ssrFunctionName} }`).join(", ")} },`] : [];
+	const resumeModuleEntry = input.resumeModuleUrl && input.environment !== "client" ? [`	resumeModuleUrl: ${JSON.stringify(input.resumeModuleUrl)},`] : [];
+	const prerenderWakeModuleEntry = input.prerenderWakeModuleUrl && input.environment !== "client" ? [`\tprerenderWakeModuleUrl: ${JSON.stringify(input.prerenderWakeModuleUrl)},`] : [];
+	const inlineResumerEntry = input.inlineResumerSources && input.environment !== "client" ? [`\tinlineResumerSources: ${JSON.stringify(input.inlineResumerSources)},`] : [];
+	const prerenderBootEntry = input.prerenderBoot && input.environment !== "client" ? [`\tprerenderBoot: ${JSON.stringify(input.prerenderBoot)},`] : [];
+	const headInjectionEntry = input.headInjections?.length && input.environment !== "client" ? [`	headInjections: ${JSON.stringify(input.headInjections)},`] : [];
+	const storageSeedEntry = input.storageSeeds?.length && input.environment !== "client" ? [`\tstorageSeeds: ${JSON.stringify(input.storageSeeds)},`] : [];
+	const modulePreloadEntry = input.resumeModuleUrl && input.environment === "server" ? [`	modulePreloads: [{ href: ${JSON.stringify(input.resumeModuleUrl)}, fetchPriority: "high" }],`] : [];
+	const metadataEntries = input.environment === "client" ? [] : [
+		...headInjectionEntry,
+		...storageSeedEntry,
+		...resumeModuleEntry,
+		...prerenderWakeModuleEntry,
+		...inlineResumerEntry,
+		...prerenderBootEntry,
+		...modulePreloadEntry,
+		input.executionLog && input.executionLog !== "never" ? `	executionLog: ${JSON.stringify(input.executionLog)},` : "",
+		"	payloadView,"
+	];
+	return [
+		"const marklessCompiledApp = {",
+		...renderCsrEntry,
+		...renderDataEntry,
+		...symbolLoaderEntry,
+		...renderSsrEntry,
+		...renderSsrComponentsEntry,
+		...metadataEntries,
+		"};",
+		"export default marklessCompiledApp;",
+		...emitComponentExports({
+			ssrComponents: input.ssrComponents,
+			rootExportName: input.ssrComponents.find((component) => component.ssrFunctionName === input.ssrExportName)?.exportName,
+			servesSsr: !!servesSsr
+		})
+	].join("\n");
+}
+const RESERVED_MODULE_BINDINGS = /* @__PURE__ */ new Set([
+	"loadBehaviorSymbol",
+	"loadClosureActionPlan",
+	"loadScalarActionPlan",
+	"loadSymbol",
+	"marklessCompiledApp",
+	"marklessLoadLocalSymbol",
+	"marklessLocalClosurePlans",
+	"marklessLocalClosureShapes",
+	"marklessPrerenderData",
+	"marklessRenderData",
+	"marklessRenderSsr",
+	"marklessSsrLoadSymbolRoute",
+	"payloadRuntimeDemandMap",
+	"payloadState",
+	"payloadView",
+	"readMarklessBehaviorSourceSymbol",
+	"resumeContainerEvent"
+]);
+/**
+* One real ES named export per component the module serves, so plain ESM reaches
+* them: a `.ts` barrel writing `export { CheckboxRoot as root } from
+* './checkbox.tsrx'`, and an app writing `import { Gallery } from
+* './Gallery.tsrx'`, are both named reads the bundler resolves at LINK time.
+* Publishing components only on the default export's map answered neither
+* (MISSING_EXPORT at build, "does not provide an export named" in the browser).
+*
+* The root is published merged - the module surface plus its own part's
+* `renderSsr` - because both consumers reach it by that one name: `render(Gallery,
+* { target })` reads the surface (`renderCsr`/`renderData`/`loadSymbol`), while a
+* barrel re-export composed as a member tag reads the part. Every other component
+* is published as the part `marklessSsrComponentPart` hands a composed child,
+* carrying nothing of the module surface. A part rendered AS A PAGE would
+* therefore be served inert, so the export is branded and `renderSsrOutput`
+* refuses it; composition reads the unbranded map entry and is untouched.
+*/
+function emitComponentExports(input) {
+	return input.ssrComponents.map((component) => {
+		if (RESERVED_MODULE_BINDINGS.has(component.exportName)) throw new Error(`MARKLESS_COMPONENT_EXPORT_NAME_RESERVED: ${component.exportName}`);
+		const part = `marklessCompiledApp.renderSsrComponents[${JSON.stringify(component.exportName)}]`;
+		const isRoot = component.exportName === input.rootExportName;
+		const brand = `${MARKLESS_COMPONENT_PART_BRAND}: ${JSON.stringify(component.exportName)}`;
+		if (input.servesSsr) return `export const ${component.exportName} = ${isRoot ? `{ ...marklessCompiledApp, renderSsr: ${part}.renderSsr }` : `{ ...${part}, ${brand} }`};`;
+		return isRoot ? `export const ${component.exportName} = marklessCompiledApp;` : `export const ${component.exportName} = { marklessCsrOnlyPart: ${JSON.stringify(component.exportName)}, ${brand} };`;
+	});
+}
+function emitResumeContainerEvent(loadSymbolName, needsFullResume, storageFreePayload, leanMode, scalarSpecializations, runtimeDemandMap, executionLogEnabled, prerenderDataId, stagedPrerender = false, componentRowRenderDataId, servedOnly = false, routedClosures = false, streamsArms = false) {
+	const armsOpen = (indent) => streamsArms ? [`${indent}const marklessArms = (await import('@markless/web/fns/streamed-arms')).marklessStreamedArms(handoff.root, ${loadSymbolName});`] : [];
+	const armsStarted = (indent) => streamsArms ? [`${indent}marklessArms.started();`] : [];
+	const wakeLoadSymbol = streamsArms ? "marklessArms.loadSymbol" : loadSymbolName;
+	const resumeEntry = storageFreePayload ? STORAGE_FREE_RESUME_ENTRY_SPECIFIER : RESUME_ENTRY_SPECIFIER;
+	const renderDataEntry = (indent, expression) => componentRowRenderDataId ? [`${indent}renderData: () => ${expression},`] : [];
+	const fullResumeHandoff = stagedPrerender && prerenderDataId ? [
+		"async function marklessFullResumeHandoff(handoff) {",
+		"	handoff.root.__asyncResumeRuntimeStarted = true;",
+		"	const group = await marklessLoadPrerenderTriggerGroup(handoff);",
+		"	const { mergePrerenderPayloadRecords, resumePrerenderTriggerGroup } = await import('@markless/web/fns/prerender-trigger-resume');",
+		"	if (!group) {",
+		"		const { derivePrerenderResumeRecords, renderPrerenderBoundary, resumeFromPrerenderRecords } = await import('@markless/web/fns/prerender-resume');",
+		"		handoff.root.__marklessFullResumeRuntime ??= (async () => {",
+		"			const marklessPrerenderData = await marklessLoadPrerenderData();",
+		`\t\t\tconst fallbackRecords = mergePrerenderPayloadRecords(await derivePrerenderResumeRecords(marklessPrerenderData, ${loadSymbolName}), handoff.root);`,
+		"			return (await resumeFromPrerenderRecords({",
+		"				...fallbackRecords,",
+		"				root: handoff.root,",
+		`\t\t\t\tloadSymbol: ${loadSymbolName},`,
+		`\t\t\t\trenderAsyncBoundary: (boundaryId, status, graph) => renderPrerenderBoundary(marklessPrerenderData, boundaryId, status, graph, ${loadSymbolName}),`,
+		...renderDataEntry("				", "marklessPrerenderData"),
+		"			})).runtime;",
+		"		})();",
+		"		const marklessFullRuntime = await handoff.root.__marklessFullResumeRuntime;",
+		"		await marklessFullRuntime.dispatch(handoff.event, { syncPolicyAlreadyApplied: handoff.syncPolicyAlreadyApplied === true, ignoreUnmatched: true });",
+		"		return;",
+		"	}",
+		"	const records = mergePrerenderPayloadRecords({ state: group.state, view: group.view }, handoff.root);",
+		"	const { runtime } = await resumePrerenderTriggerGroup({",
+		"		...records, groupId: group.groupId, graphNodeIds: group.graphNodeIds,",
+		"		root: handoff.root, loadSymbol: group.loadSymbol, prepareBoundaryArm: group.prepareBoundaryArm, renderBoundaryArm: group.renderBoundaryArm,",
+		"	});",
+		"	await runtime.dispatch(handoff.event, { syncPolicyAlreadyApplied: handoff.syncPolicyAlreadyApplied === true, ignoreUnmatched: true });",
+		"}"
+	].join("\n") : prerenderDataId ? [
+		"async function marklessFullResumeHandoff(handoff) {",
+		"	handoff.root.__marklessLinkedRenderDataBoot = true;",
+		"	handoff.root.__asyncResumeRuntimeStarted = true;",
+		"	const runtime = await (handoff.root.__marklessFullResumeRuntime ??= (async () => {",
+		"		const { derivePrerenderResumeRecords, mergePrerenderPayloadRecords, renderPrerenderBoundary, resumeFromPrerenderRecords } = await import('@markless/web/fns/prerender-resume');",
+		`\t\tconst records = await derivePrerenderResumeRecords(marklessPrerenderData, ${loadSymbolName});`,
+		"		const mergedRecords = mergePrerenderPayloadRecords(records, handoff.root);",
+		...armsOpen("		"),
+		streamsArms ? "		const resumed = await resumeFromPrerenderRecords({" : "		return (await resumeFromPrerenderRecords({",
+		"			...mergedRecords,",
+		"			root: handoff.root,",
+		`\t\t\tloadSymbol: ${wakeLoadSymbol},`,
+		`\t\t\trenderAsyncBoundary: (boundaryId, status, graph) => renderPrerenderBoundary(marklessPrerenderData, boundaryId, status, graph, ${loadSymbolName}),`,
+		...renderDataEntry("			", "marklessPrerenderData"),
+		...streamsArms ? [
+			"		});",
+			...armsStarted("		"),
+			"		return resumed.runtime;"
+		] : ["		})).runtime;"],
+		"	})());",
+		"	await runtime.dispatch(handoff.event, { syncPolicyAlreadyApplied: handoff.syncPolicyAlreadyApplied === true, ignoreUnmatched: true });",
+		"}"
+	].join("\n") : [
+		"async function marklessFullResumeHandoff(handoff) {",
+		"	handoff.root.__asyncResumeRuntimeStarted = true;",
+		...armsOpen("	"),
+		`	const { resumeFromPayloadDocument } = await import('${resumeEntry}');`,
+		"	const { runtime } = await resumeFromPayloadDocument({",
+		"		document: handoff.document,",
+		"		root: handoff.root,",
+		`		loadSymbol: ${wakeLoadSymbol},`,
+		...renderDataEntry("		", `import('${componentRowRenderDataId}').then((data) => data.marklessPrerenderData)`),
+		"	});",
+		...armsStarted("	"),
+		"	await runtime.dispatch(handoff.event, { syncPolicyAlreadyApplied: handoff.syncPolicyAlreadyApplied === true, ignoreUnmatched: true });",
+		"}"
+	].join("\n");
+	const scalarOnlySpecialized = leanMode === "scalar" && scalarSpecializations.length > 0 && !needsFullResume && !servedOnly && allEventActionsHaveScalarPlan(runtimeDemandMap);
+	const scalarDispatcher = scalarSpecializations.length > 0 ? emitSpecializedScalarDispatcher(scalarSpecializations, loadSymbolName, scalarOnlySpecialized ? "fail" : "full", scalarOnlySpecialized ? "static" : servedOnly ? "served-only" : "served", !scalarOnlySpecialized && routedClosures) : emitSpecializedScalarDispatcher([], loadSymbolName, "full", "static");
+	const actionScopedLean = leanMode === "scalar" && scalarSpecializations.length > 0 && !prerenderDataId;
+	if (needsFullResume && !actionScopedLean) return [
+		fullResumeHandoff,
+		"export async function resumeContainerEvent(input) {",
+		"	await marklessFullResumeHandoff({ ...input, document: input.root });",
+		"}"
+	].join("\n");
+	if (leanMode !== "none") {
+		const row = [
+			"	const { resumeScalarRowEventFromPayloadDocument } = await import('@markless/web/event-only-lean/row');",
+			"	await resumeScalarRowEventFromPayloadDocument({",
+			...[
+				"		document: input.root,",
+				"		root: input.root,",
+				"		event: input.event,",
+				"		element: input.element,",
+				"		runtimeDemandMap: payloadRuntimeDemandMap,",
+				"		syncPolicyAlreadyApplied: input.syncPolicyAlreadyApplied === true,",
+				`		loadSymbol: ${loadSymbolName},`,
+				"	});"
+			]
+		];
+		if (leanMode === "scalar") return [
+			scalarOnlySpecialized ? "" : fullResumeHandoff,
+			scalarDispatcher,
+			"export async function resumeContainerEvent(input) {",
+			executionLogEnabled ? "	const marklessLogBefore = globalThis.__mxLog && new Set(globalThis.__mxLog);" : "",
+			"	await marklessResumeSpecializedScalarEvent(input);",
+			executionLogEnabled ? "	if (marklessLogBefore) globalThis.__mxLoadLog().then(log => log.logMarklessSpecializedInteraction(input, marklessLogBefore));" : "",
+			"}"
+		].join("\n");
+		if (leanMode === "row") return [
+			"export async function resumeContainerEvent(input) {",
+			...row,
+			"}"
+		].join("\n");
+		return [
+			fullResumeHandoff,
+			scalarDispatcher,
+			"export async function resumeContainerEvent(input) {",
+			"	if (marklessScalarSpecializedAction(input)) {",
+			"		await marklessResumeSpecializedScalarEvent(input);",
+			"		return;",
+			"	}",
+			...row,
+			"}"
+		].join("\n");
+	}
+	if (prerenderDataId) return "export async function resumeContainerEvent(_input) {}";
+	return [
+		fullResumeHandoff,
+		"export async function resumeContainerEvent(input) {",
+		"	await marklessFullResumeHandoff({ ...input, document: input.root });",
+		"}"
+	].join("\n");
+}
+function emitPrerenderTriggerGroupLoader(groups) {
+	return [
+		"function marklessPrerenderTriggerMatches(input, index, tagName, eventName) {",
+		"	if (input.event?.type !== eventName) return false;",
+		"	const host = marklessFindElementAtDomOrderIndex(input.root, index);",
+		"	if (!host || (tagName !== \"*\" && host.tagName.toLowerCase() !== tagName)) return false;",
+		"	const target = input.event?.target;",
+		"	return host === target || (!!target?.nodeType && typeof host.contains === \"function\" && host.contains(target));",
+		"}",
+		"function marklessPrerenderBranchTriggerMatches(input, startIndex, endIndex, hostPath, eventName) {",
+		"	if (input.event?.type !== eventName) return false;",
+		"	const comments = [];",
+		"	const collect = node => { for (const child of node.childNodes ?? []) { if (child.nodeType === 8) comments.push(child); collect(child); } };",
+		"	collect(input.root);",
+		"	const start = comments[startIndex], end = comments[endIndex], armNodes = [];",
+		"	let within = false, done = false;",
+		"	const between = node => { for (const child of node.childNodes ?? []) { if (child === start) { within = true; continue; } if (child === end) { done = true; return; } if (within) armNodes.push(child); else between(child); if (done) return; } };",
+		"	between(input.root);",
+		"	let host = armNodes[hostPath[0]];",
+		"	for (let index = 1; host && index < hostPath.length; index++) host = host.childNodes?.[hostPath[index]];",
+		"	const target = input.event?.target;",
+		"	return host?.nodeType === 1 && (host === target || (!!target?.nodeType && typeof host.contains === \"function\" && host.contains(target)));",
+		"}",
+		"function marklessLoadPrerenderTriggerGroup(input) {",
+		...groups.map((group) => {
+			return `\tif (${group.eventName === "self-wake" ? "input.event === 0" : group.hostPath ? `marklessPrerenderBranchTriggerMatches(input, ${group.branchStartIndex}, ${group.branchEndIndex}, ${JSON.stringify(group.hostPath)}, ${JSON.stringify(group.eventName)})` : `marklessPrerenderTriggerMatches(input, ${group.hostIndex}, ${JSON.stringify(group.hostTagName.toLowerCase())}, ${JSON.stringify(group.eventName)})`}) return import(${JSON.stringify(group.moduleId)});`;
+		}),
+		"	return Promise.resolve(null);",
+		"}"
+	].join("\n");
+}
+function scalarDispatcherSpecializations(input) {
+	const state = input.payloadState;
+	const view = input.payloadView;
+	const map = input.runtimeDemandMap;
+	const cells = state?.cells ?? [];
+	const locators = view?.locators ?? [];
+	return (map?.actions ?? []).flatMap((action, index) => {
+		const plan = action?.plan;
+		if (action?.recordKind !== "event" || plan?.version !== 1) return [];
+		if (plan.kind === "closure") return closureSpecialization(action, plan, index, view, input);
+		if (plan.kind !== "scalar") return [];
+		const cellIndex = cells.findIndex((cell) => cell?.graphNodeId === plan.cell);
+		const initialCell = cells[cellIndex];
+		const host = locators.find((locator) => locator?.hostNodeId === action.hostNodeId);
+		const event = view?.events?.find((candidate) => candidate?.hostNodeId === action.hostNodeId && candidate?.eventName === action.eventName);
+		const symbolId = scalarActionSymbolId(plan.symbolId, event, input.symbolRoutes ?? []);
+		if (!symbolId) return [];
+		if (cellIndex < 0 || !initialCell || !host || typeof host.index !== "number") return [];
+		if (event && syncPolicyGraphNodeIds(event.syncPolicy).some((graphNodeId) => graphNodeId !== plan.cell)) return [];
+		const textUpdates = (plan.textUpdates ?? []).flatMap((update) => {
+			const locator = locators.find((candidate) => candidate?.hostNodeId === update.hostNodeId);
+			return locator && typeof locator.index === "number" ? [{
+				hostNodeId: update.hostNodeId,
+				index: locator.index,
+				tagName: String(locator.tagName ?? "*"),
+				...update.prefix ? { prefix: update.prefix } : {},
+				...update.suffix ? { suffix: update.suffix } : {}
+			}] : [];
+		});
+		if (textUpdates.length !== (plan.textUpdates ?? []).length) return [];
+		return [{
+			kind: "scalar",
+			name: `marklessRunScalar${index}`,
+			hostNodeId: action.hostNodeId,
+			eventName: action.eventName,
+			symbolId,
+			cell: plan.cell,
+			cellIndex,
+			initialCell,
+			hostIndex: host.index,
+			hostTagName: String(host.tagName ?? "*"),
+			syncPolicy: event?.syncPolicy ?? null,
+			write: plan.write,
+			textUpdates
+		}];
+	});
+}
+function closureSpecialization(action, plan, index, view, input) {
+	const host = view?.locators?.find((locator) => locator?.hostNodeId === action.hostNodeId);
+	const event = view?.events?.find((candidate) => candidate?.hostNodeId === action.hostNodeId && candidate?.eventName === action.eventName);
+	const symbolId = scalarActionSymbolId(plan.symbolId, event, input.symbolRoutes ?? []);
+	if (symbolId === null || symbolId !== plan.symbolId || !host || typeof host.index !== "number" || !plan.cells || !plan.computed || !plan.updates) return [];
+	return [{
+		kind: "closure",
+		name: `marklessRunClosure${index}`,
+		hostNodeId: action.hostNodeId,
+		eventName: action.eventName,
+		symbolId,
+		hostIndex: host.index,
+		hostTagName: String(host.tagName ?? "*"),
+		syncPolicy: event?.syncPolicy ?? null,
+		plan: {
+			cells: plan.cells,
+			computed: plan.computed,
+			updates: plan.updates
+		}
+	}];
+}
+function scalarActionSymbolId(plannedSymbolId, event, routes) {
+	if (typeof plannedSymbolId !== "string") return null;
+	const eventSymbolIds = Array.isArray(event?.symbolIds) ? event.symbolIds.filter((symbolId) => typeof symbolId === "string") : [];
+	const routedSymbolId = eventSymbolIds.find((symbolId) => routes.some((route) => symbolId.startsWith(route.prefix)));
+	if (routedSymbolId) return routedSymbolId;
+	if (eventSymbolIds.some((symbolId) => /^[^:]+:symbol:/.test(symbolId))) return null;
+	if (eventSymbolIds.length > 0 && !eventSymbolIds.includes(plannedSymbolId)) return null;
+	return plannedSymbolId;
+}
+function allEventActionsHaveScalarPlan(runtimeDemandMap) {
+	const eventActions = (runtimeDemandMap?.actions ?? []).filter((action) => action.recordKind === "event");
+	return eventActions.length > 0 && eventActions.every((action) => action.plan?.kind === "scalar");
+}
+function emitSpecializedScalarDispatcher(actions, loadSymbolName, fallback, resolution, routedClosures = false) {
+	const shapes = closureShapes(actions);
+	const fallbackName = fallback === "fail" ? "marklessScalarSpecializedHostMiss" : "marklessScalarSpecializedFallback";
+	const fallbackBody = fallback === "full" ? [
+		"async function marklessScalarSpecializedFallback(input, site, syncPolicyAlreadyApplied = input.syncPolicyAlreadyApplied === true) {",
+		"	if (import.meta.env?.DEV) console.warn(Object.assign(new Error(\"MARKLESS_SCALAR_SPECIALIZED_FALLBACK\"), { code: \"MARKLESS_SCALAR_SPECIALIZED_FALLBACK\", site }));",
+		"	await marklessFullResumeHandoff({ ...input, document: input.root, syncPolicyAlreadyApplied });",
+		"}"
+	] : [];
+	return [
+		"async function marklessResumeSpecializedScalarEvent(input) {",
+		...fallback === "full" ? ["	if (input.root.__asyncResumeRuntimeStarted) return marklessFullResumeHandoff({ ...input, document: input.root });"] : [],
+		"	const action = marklessScalarSpecializedAction(input);",
+		"	if (action) {",
+		"		try {",
+		"			return await action(input);",
+		"		} catch (error) {",
+		`			if (error?.code === "MARKLESS_SCALAR_SPECIALIZED_ESCALATE") return ${fallbackName}(input, error.site ?? "escalate", error.syncPolicyAlreadyApplied === true);`,
+		"			throw error;",
+		"		}",
+		"	}",
+		fallback === "fail" ? "	return;" : `	return ${fallbackName}(input, "event-match");`,
+		"}",
+		fallback === "fail" ? "function marklessScalarSpecializedHostMiss(_input, site) { return marklessScalarSpecializedError(\"MARKLESS_SCALAR_SPECIALIZED_HOST_MISS\", site); }" : "function marklessScalarSpecializedHostMiss(input, site) { return marklessScalarSpecializedFallback(input, site); }",
+		...resolution === "static" ? [
+			"function marklessScalarSpecializedAction(input) {",
+			...emitStaticScalarMatches(actions),
+			"}"
+		] : emitServedScalarMatches(actions, loadSymbolName, resolution, shapes, routedClosures),
+		"function marklessScalarEventMatches(input, host, tagName, eventName, hostNodeId) {",
+		"	const eventTypeMatches = input.event?.type === eventName;",
+		"	if (!eventTypeMatches) return false;",
+		"	if (!host || (tagName !== \"*\" && host.tagName.toLowerCase() !== tagName)) return false;",
+		"	const eventTarget = input.event?.target;",
+		"	return host === eventTarget || (!!eventTarget?.nodeType && typeof host.contains === \"function\" && host.contains(eventTarget));",
+		"}",
+		...shapes.length > 0 ? [`const marklessClosureShapes = [${shapes.join(", ")}];`] : [],
+		...actions.map((action) => action.kind === "closure" ? emitClosureAction(action, loadSymbolName, shapes) : emitScalarAction(action, loadSymbolName, resolution)),
+		...fallbackBody
+	].join("\n");
+}
+function emitStaticScalarMatches(actions) {
+	return actions.filter((action) => action.kind === "scalar").map((action) => `	if (marklessScalarEventMatches(input, marklessFindElementAtDomOrderIndex(input.root, ${action.hostIndex}), ${JSON.stringify(action.hostTagName.toLowerCase())}, ${JSON.stringify(action.eventName)}, ${JSON.stringify(action.hostNodeId)})) return ${action.name};`);
+}
+function emitServedScalarMatches(actions, loadSymbolName, resolution, shapes, routedClosures) {
+	const closures = routedClosures || actions.some((action) => action.kind === "closure");
+	return [
+		`const marklessScalarOwners = ${JSON.stringify(actions.map((action) => [
+			action.hostNodeId,
+			action.eventName,
+			action.symbolId
+		]))};`,
+		`const marklessScalarRuns = [${actions.map((action) => action.name).join(", ")}];`,
+		...closures ? [`const marklessScalarPrimes = [${actions.map((action) => action.kind === "closure" ? `() => marklessPrimeClosure(${emitClosurePlan(action, shapes)}, "", ${loadSymbolName})` : `() => ${loadSymbolName}(${JSON.stringify(action.symbolId)})`).join(", ")}];`] : [],
+		"function marklessScalarSpecializedAction(input) {",
+		"	if (input.event === 0) {",
+		...closures ? [`		const primed = marklessScalarServedPrime(input.root, input.element, marklessScalarOwners${routedClosures ? ", marklessClosureRouted" : ""});`, `		return primed && (() => Promise.all(primed.map((owner) => typeof owner === "number" ? marklessScalarPrimes[owner]() : marklessPrimeRoutedClosure(owner, marklessClosurePlanRoute, ${loadSymbolName}))).then(() => undefined));`] : ["		const primed = marklessScalarServedPrime(input.root, input.element, marklessScalarOwners);", `		return primed && (() => Promise.all(primed.map((index) => ${loadSymbolName}(marklessScalarOwners[index][2]))).then(() => undefined));`],
+		"	}",
+		"	const owner = input.event && marklessScalarServedOwner(input.root, input.event, marklessScalarOwners);",
+		...routedClosures ? [
+			"	if (owner === -1) {",
+			"		const record = marklessScalarServedRecord(input.root, input.event);",
+			`		if (record && record !== -1 && marklessClosureRouted(record)) return (input) => marklessRunRoutedClosure(input, record, marklessClosurePlanRoute, ${loadSymbolName});`,
+			"	}"
+		] : [],
+		...resolution === "served" ? [
+			"	if (owner === undefined) {",
+			...emitStaticScalarMatches(actions).map((line) => `\t${line}`),
+			"		return;",
+			"	}"
+		] : [],
+		"	return owner >= 0 ? marklessScalarRuns[owner] : undefined;",
+		"}"
+	];
+}
+function emitScalarHostLookup(resolution, hostNodeId, index, tagName) {
+	return resolution === "static" ? `marklessFindElementAtDomOrderIndex(input.root, ${index})` : `marklessScalarLocate(input.root, ${JSON.stringify(hostNodeId)}, ${resolution === "served" ? index : -1}, ${JSON.stringify(tagName.toLowerCase())})`;
+}
+function closureShapes(actions) {
+	return [...new Set(actions.flatMap((action) => action.kind === "closure" ? [JSON.stringify(action.plan)] : []))];
+}
+function emitClosurePlan(action, shapes) {
+	return `{ symbolId: ${JSON.stringify(action.symbolId)}, ...marklessClosureShapes[${shapes.indexOf(JSON.stringify(action.plan))}] }`;
+}
+function emitClosureAction(action, loadSymbolName, shapes) {
+	return [
+		`function ${action.name}(input) {`,
+		`	return marklessRunClosureAction(input, ${emitClosurePlan(action, shapes)}, "", ${JSON.stringify(action.hostNodeId)}, ${loadSymbolName}${action.syncPolicy ? `, ${JSON.stringify(action.syncPolicy)}` : ""});`,
+		"}"
+	].join("\n");
+}
+function emitScalarAction(action, loadSymbolName, resolution) {
+	return [
+		`async function ${action.name}(input) {`,
+		"	let syncPolicyAlreadyApplied = input.syncPolicyAlreadyApplied === true;",
+		"	const values = input.root.__marklessEventOnlyGraph || new Map();",
+		"	input.root.__marklessEventOnlyGraph = values;",
+		`	if (!values.has(${JSON.stringify(action.cell)})) values.set(${JSON.stringify(action.cell)}, marklessDecodeScalarCell(marklessReadScalarCell(input.root, ${JSON.stringify(action.cell)})${resolution === "served-only" ? "" : ` ?? ${JSON.stringify(action.initialCell)}`}, ${JSON.stringify(action.cell)}, ${JSON.stringify(`markless/state cell ${action.cell}`)}));`,
+		`	const state = { value: values.get(${JSON.stringify(action.cell)}), dirty: false };`,
+		"	try {",
+		`	const host = ${emitScalarHostLookup(resolution, action.hostNodeId, action.hostIndex, action.hostTagName)};`,
+		`	if (!host || (${JSON.stringify(action.hostTagName.toLowerCase())} !== "*" && host.tagName.toLowerCase() !== ${JSON.stringify(action.hostTagName.toLowerCase())})) return marklessScalarSpecializedHostMiss(input, "host");`,
+		...action.textUpdates.map((update, index) => `	const textTarget${index} = ${emitScalarHostLookup(resolution, update.hostNodeId, update.index, update.tagName)};`),
+		...action.textUpdates.map((update, index) => `	if (!textTarget${index} || (${JSON.stringify(update.tagName.toLowerCase())} !== "*" && textTarget${index}.tagName.toLowerCase() !== ${JSON.stringify(update.tagName.toLowerCase())})) return marklessScalarSpecializedHostMiss(input, "text-target");`),
+		"	const graph = {",
+		`		hasCell(graphNodeId) { return graphNodeId === ${JSON.stringify(action.cell)}; },`,
+		`		read(graphNodeId, path = []) { if (graphNodeId !== ${JSON.stringify(action.cell)} || path.length) return marklessScalarSpecializedError("MARKLESS_SCALAR_SPECIALIZED_ESCALATE", "read"); return state.value; },`,
+		`		write(write) { if (write.graphNodeId !== ${JSON.stringify(action.cell)} || (write.path?.length ?? 0)) return marklessScalarSpecializedError("MARKLESS_SCALAR_SPECIALIZED_ESCALATE", "write"); if (!Object.is(state.value, write.value)) { state.value = write.value; values.set(${JSON.stringify(action.cell)}, state.value); state.dirty = true; } },`,
+		`		update(update) { if (update.graphNodeId !== ${JSON.stringify(action.cell)} || (update.path?.length ?? 0)) return marklessScalarSpecializedError("MARKLESS_SCALAR_SPECIALIZED_ESCALATE", "update"); const previous = state.value; const next = update.update(previous); if (!Object.is(previous, next)) { state.value = next; values.set(${JSON.stringify(action.cell)}, state.value); state.dirty = true; } return update.returnValue === "previous" ? previous : update.returnValue === "next" ? next : undefined; },`,
+		"		call() { return marklessScalarSpecializedError(\"MARKLESS_SCALAR_SPECIALIZED_ESCALATE\", \"call\"); },",
+		"		async flush() {},",
+		"	};",
+		...action.syncPolicy ? [
+			`	const syncPolicy = ${JSON.stringify(action.syncPolicy)};`,
+			"	if (syncPolicy && !syncPolicyAlreadyApplied) {",
+			"		const { runSyncPolicyActions } = await import('@markless/web/inline/sync-policy-core-lazy');",
+			"		runSyncPolicyActions(syncPolicy, graph, input.event);",
+			"		syncPolicyAlreadyApplied = true;",
+			"	}"
+		] : [],
+		...emitScalarWrite(action),
+		`	const symbol = await Promise.resolve(${loadSymbolName}(${JSON.stringify(action.symbolId)}));`,
+		"	await Promise.resolve(symbol({ graph: { ...graph, write() {}, update(update) { const value = graph.read(update.graphNodeId, update.path ?? []); return update.returnValue === \"previous\" || update.returnValue === \"next\" ? value : undefined; } }, event: input.event, element: host, getElementHandle: () => undefined }));",
+		"	if (state.dirty) {",
+		"		state.dirty = false;",
+		...action.textUpdates.map((update, index) => `		textTarget${index}.textContent = marklessUpdateText({ domUpdate: { hostNodeId: ${JSON.stringify(update.hostNodeId)} }, value: ${JSON.stringify(update.prefix ?? "")} + (state.value == null ? '' : String(state.value))${update.suffix ? ` + ${JSON.stringify(update.suffix)}` : ""} }, ${JSON.stringify(update.hostNodeId)}).value;`),
+		"	}",
+		"	} catch (error) {",
+		"		if (error?.code === \"MARKLESS_SCALAR_SPECIALIZED_ESCALATE\") error.syncPolicyAlreadyApplied = syncPolicyAlreadyApplied;",
+		"		throw error;",
+		"	}",
+		"}"
+	].join("\n");
+}
+function emitScalarWrite(action) {
+	if (action.write.kind === "update") return [
+		"	marklessWriteScalar({ graph }, {",
+		`		graphNodeId: ${JSON.stringify(action.cell)},`,
+		"		returnValue: \"next\",",
+		"		update(value) {",
+		`			return typeof value === "bigint" ? value ${action.write.updateOperator === "--" ? "-" : "+"} BigInt(1) : Number(value) ${action.write.updateOperator === "--" ? "-" : "+"} 1;`,
+		"		},",
+		"	});"
+	];
+	return [
+		"	marklessWriteScalar({ graph }, {",
+		`		graphNodeId: ${JSON.stringify(action.cell)},`,
+		`		value: ${action.write.valueKind === "undefined" ? "undefined" : JSON.stringify(action.write.value)},`,
+		"	});"
+	];
+}
+function syncPolicyGraphNodeIds(policy) {
+	if (!policy || typeof policy !== "object") return [];
+	const branches = Array.isArray(policy.branches) ? policy.branches : [policy];
+	return [...new Set(branches.flatMap((branch) => conditionGraphNodeIds(branch.when)))].sort();
+}
+function conditionGraphNodeIds(condition) {
+	if (!condition || typeof condition !== "object") return [];
+	const typed = condition;
+	if (typed.type === "graph-truthy" && typeof typed.graphNodeId === "string") return [typed.graphNodeId];
+	if (typed.type === "not") return conditionGraphNodeIds(typed.condition);
+	if ((typed.type === "and" || typed.type === "or") && Array.isArray(typed.conditions)) return typed.conditions.flatMap(conditionGraphNodeIds);
+	return [];
+}
+function composedLeanMode(composed, mode) {
+	return composed && mode !== "scalar" ? "none" : mode;
+}
+function leanResumeMode(runtimeDemandMap) {
+	const recordKinds = runtimeDemandMap?.recordKinds;
+	if (!recordKinds) return "none";
+	const replaced = new Map(recordKinds.map((record) => [record.kind, record.replaced]));
+	const scalar = replaced.get("event") === true && replaced.get("dom-update") === true;
+	const row = replaced.get("keyed-repeat") === true && replaced.get("dom-update") === true;
+	if (scalar && row) return "mixed";
+	if (scalar) return "scalar";
+	if (row) return "row";
+	return "none";
+}
+function emitExecutionLogLoader() {
+	return `globalThis.__mxLoadLog ||= () => import(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)});`;
+}
+function emitLoadSymbol(input, sourceReaderName) {
+	if (input.symbols.length > 0 && input.symbols.length <= 8) {
+		const direct = emitDirectSourceSymbolLoader(input.symbols, sourceReaderName);
+		if (!input.hasBoundSymbols) return direct;
+		return [`const marklessSymbolResolverModule = () => import('${input.resolverId}');`, direct.replace("	return Promise.reject(new Error(`Unknown async symbol ${symbolId}`));", "	return marklessSymbolResolverModule().then((mod) => mod.loadSymbol(symbolId));")].join("\n");
+	}
+	return [
+		`const marklessSymbolResolverModule = () => import('${input.resolverId}');`,
+		"function loadSymbol(symbolId) {",
+		"	return marklessSymbolResolverModule().then((mod) => mod.loadSymbol(symbolId));",
+		"}"
+	].join("\n");
+}
+function emitDirectSourceSymbolLoader(symbols, readerName = "readMarklessSourceSymbol") {
+	return [
+		"function loadSymbol(symbolId) {",
+		...symbols.flatMap((symbol) => [`	if (symbolId === ${JSON.stringify(symbol.id)}) return import('${symbol.lazyChunk ?? symbol.chunk}')`, `		.then((mod) => ${readerName}(mod, ${JSON.stringify(symbol.exportName)}));`]),
+		"	return Promise.reject(new Error(`Unknown async symbol ${symbolId}`));",
+		"}",
+		emitSourceSymbolExportReader(readerName)
+	].join("\n");
+}
+function emitSourceSymbolExportReader(name = "readMarklessSourceSymbol") {
+	return [
+		`function ${name}(mod, exportName) {`,
+		"	mod.init__virtual_markless_symbol?.();",
+		"	return mod[exportName];",
+		"}"
+	].join("\n");
+}
+function stringHash(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index++) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+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_BUILD_METADATA_FILES = [
+	MARKLESS_BUNDLE_GRAPH,
+	MARKLESS_EXECUTION_SIZES,
+	MARKLESS_EXECUTION_DEMAND,
+	MARKLESS_INTERACTION_CLOSURES,
+	MARKLESS_BYTE_ATTRIBUTION
+];
+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[/\\]/
+}];
+function outputDefaults(output, environment) {
+	if (environment === "lib") return output;
+	const next = {
+		...output,
+		hoistTransitiveImports: false
+	};
+	if (environment === "server") {
+		next.entryFileNames ??= "[name].js";
+		next.chunkFileNames ??= "chunk-[hash].js";
+		next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
+		return next;
+	}
+	next.entryFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
+	next.chunkFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
+	next.minifyInternalExports = true;
+	next.strictExecutionOrder = true;
+	next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
+	return next;
+}
+function marklessCodeSplitting(codeSplitting) {
+	if (typeof codeSplitting === "boolean") throw new Error("@markless/bundler requires output.codeSplitting to be an object so runtime chunks can be grouped.");
+	return {
+		...codeSplitting,
+		groups: [...MARKLESS_RUNTIME_GROUPS, ...codeSplitting?.groups ?? []]
+	};
+}
+//#endregion
+//#region src/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 += [
+			emitReboundSymbolImport(routes, "marklessLoadSymbolRebound"),
+			"export function loadSymbol(symbolId) {",
+			...routes.flatMap((route) => {
+				const unbound = "importSource" in route ? `import(${JSON.stringify(symbolRouteImportSource(route.importSource))}).then((mod) => mod.loadSymbol ? mod.loadSymbol(symbolId.slice(${route.prefix.length})) : Promise.reject(new Error(\`Unknown child async symbol \${symbolId}\`)))` : `${route.prefix.length > 0 ? "loadSymbol" : "marklessLoadLocalSymbol"}(symbolId.slice(${route.prefix.length}))`;
+				return [
+					`\tif (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
+					...emitReboundSymbolRoute(route, "marklessLoadSymbolRebound", "marklessLoadLocalSymbol", unbound, "		"),
+					`\t\treturn ${unbound};`,
+					"	}"
+				];
+			}),
+			"	return marklessLoadLocalSymbol(symbolId);",
+			"}"
+		].filter((line) => line !== "").join("\n");
+	}
+	return [
+		armRendererModuleId ? [
+			`import { prepareBoundaryArm as marklessPrepareBoundaryArm, renderBoundaryArm as marklessRenderBoundaryArm } from ${JSON.stringify(armRendererModuleId)};`,
+			"export function prepareBoundaryArm(boundaryId, status, graph) {",
+			"	return marklessPrepareBoundaryArm(boundaryId, status, graph, loadSymbol);",
+			"}",
+			"export function renderBoundaryArm(boundaryId, status, graph) {",
+			"	return marklessRenderBoundaryArm(boundaryId, status, graph, loadSymbol);",
+			"}"
+		].join("\n") : "",
+		adaptImportedCaptureResolver(source, boundRows.some((row) => row.loaderSymbolId !== void 0)),
+		`export const groupId=${JSON.stringify(input.group.id)};`,
+		`export const state=${JSON.stringify(input.group.state)};`,
+		`export const view=${JSON.stringify(input.group.view)};`,
+		`export const graphNodeIds=${JSON.stringify(input.group.graphNodeIds)};`
+	].join("\n");
+}
+function emitPrerenderBoundaryRendererModule(renderDataId) {
+	return [
+		`import { marklessPrerenderData } from ${JSON.stringify(renderDataId)};`,
+		"import { renderPrerenderBoundary } from '@markless/web/fns/prerender-resume';",
+		"const marklessPreparedBoundaryArms = new 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/virtual-ids.ts
+const TSRX_SOURCE_FILE = /\.tsrx(?:[?#].*)?$/;
+const MARKLESS_SYMBOL_SOURCE_QUERY_RE = /[?&]markless-symbols(?:[&#]|$)/;
+const MARKLESS_RESUME_SOURCE_QUERY_RE = /[?&]markless-resume(?:[&#]|$)/;
+const MARKLESS_RENDER_DATA_SOURCE_QUERY_RE = /[?&]markless-render-data(?:[&#]|$)/;
+const MARKLESS_REACHED_FROM_SOURCE_QUERY = "markless-reached-from";
+const MARKLESS_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(MARKLESS_BUILD_PREFIX) ? fileName.slice(MARKLESS_BUILD_PREFIX.length) : fileName;
+}
+function virtualModuleSourceForLoad(module, options) {
+	if (!options.dev || module.type !== "resolver") return module.source;
+	if (!module.source.includes("moduleUrls[row[0]]")) return module.source;
+	return module.source.replace(SYMBOL_VIRTUAL_STRING_RE, (_match, _quote, virtualId) => JSON.stringify(devBrowserVirtualModuleUrl(virtualId, options.publicPath)));
+}
+function devBrowserSourceModuleUrl(source, _root, publicPath) {
+	const path = withQuery(joinURL("@fs", withoutLeadingSlash(source)), { import: null });
+	return publicPath ? publicPath(path) : joinURL("/", path);
+}
+function devBrowserVirtualModuleUrl(virtualId, publicPath) {
+	const path = joinURL("@id", resolveVirtualId(virtualId).replace("\0", "__x00__"));
+	return publicPath ? publicPath(path) : joinURL("/", path);
+}
+function clientSymbolEntries(input, root) {
+	if (!input || typeof input !== "object" || Array.isArray(input)) return [];
+	const sources = [];
+	for (const [name, value] of Object.entries(input)) {
+		if (!/symbol/i.test(name)) continue;
+		for (const entry of inputEntryValues(value)) if (typeof entry === "string" && TSRX_SOURCE_FILE.test(entry)) sources.push(normalizeInputSource(entry, root));
+	}
+	return sources;
+}
+function inputEntryValues(value) {
+	return Array.isArray(value) ? value.flatMap(inputEntryValues) : [value];
+}
+function normalizeInputSource(source, root) {
+	const path = pathname(source);
+	if (isAbsolute(path)) return path;
+	return pathname(resolve(root ?? "", path));
+}
+function isSymbolOnlySourceRequest(id) {
+	return MARKLESS_SYMBOL_SOURCE_QUERY_RE.test(id);
+}
+function 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;
+}
+function isRouteNavigationSourceRequest(id) {
+	return MARKLESS_ROUTE_SOURCE_QUERY_RE.test(id) || isRenderDataSourceRequest(id) && renderDataReachedFromQuery(id) === void 0;
+}
+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 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(17).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-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
+//#region src/build/pack-cost-model.ts
+const PACK_COST_MODEL = {
+	roundMs: 162,
+	parallelRequestMs: 0,
+	bootMsPerGzipKb: 2.8,
+	interactionMsPerGzipKb: 1.5,
+	decodedMsPerKb: 0,
+	fileOverheadGzipKb: .5,
+	lazySiblingOverheadGzipKb: 1,
+	minDeferredGzipKb: 1,
+	sourceGzipRatio: .25
+};
+function estimatedGzipKb(sourceLength, model = PACK_COST_MODEL) {
+	return sourceLength * model.sourceGzipRatio / 1024;
+}
+function mergeIntoWiderPack(input, model = PACK_COST_MODEL) {
+	return input.loadersNotNeeding * input.gzipKb * input.msPerGzipKb < input.loadersNeeding * (model.parallelRequestMs + model.fileOverheadGzipKb * input.msPerGzipKb);
+}
+function deferralPays(gzipKb, model = PACK_COST_MODEL) {
+	return gzipKb >= model.minDeferredGzipKb;
+}
+function lazySiblingPays(input, model = PACK_COST_MODEL) {
+	return deferralPays(input.gzipKb, model) && input.loadersSpedUp * input.gzipKb > input.loaders * model.lazySiblingOverheadGzipKb;
+}
+function frameworkSplitPays(input, model = PACK_COST_MODEL) {
+	return deferralPays(input.appGzipKb, model) && deferralPays(input.frameworkGzipKb, model);
+}
+//#endregion
+//#region src/build/route-pack-groups.ts
+const MARKLESS_DEFERRED_PACK = "markless-deferred";
+const MARKLESS_NAVIGATION_PACK_PREFIX = "navigation:";
+function isMarklessDeferredPack(name) {
+	return name === "markless-deferred" || !!name?.startsWith(`markless-deferred-`);
+}
+/** Deferred packs plus the module-free facade chunks Rolldown emits in front of their entries. */
+function marklessDeferredChunkFileNames(chunks) {
+	const all = [...chunks];
+	const deferred = new Set(all.filter((chunk) => isMarklessDeferredPack(chunk.name)).map((chunk) => chunk.fileName));
+	for (let grew = deferred.size > 0; grew;) {
+		grew = false;
+		for (const chunk of all) if (!deferred.has(chunk.fileName) && chunk.moduleIds?.length === 0 && chunk.imports.length > 0 && chunk.imports.every((name) => deferred.has(name))) {
+			deferred.add(chunk.fileName);
+			grew = true;
+		}
+	}
+	return deferred;
+}
+function isMarklessNavigationPack(name) {
+	return !!name?.startsWith(MARKLESS_NAVIGATION_PACK_PREFIX);
+}
+function isStartupPack(group) {
+	return !isMarklessDeferredPack(group) && !isMarklessNavigationPack(group);
+}
+function planRoutePackGroups(input) {
+	const sources = /* @__PURE__ */ new Map();
+	for (const [id, module] of input.modules) {
+		if (!module.source || module.reachedFrom !== void 0) continue;
+		push(sources, module.source, id);
+	}
+	const roots = /* @__PURE__ */ new Map();
+	for (const [route, ids] of input.routes) for (const id of ids) {
+		if (!input.modules.has(id)) throw new Error(`Markless route ${route} has missing root ${id}.`);
+		roots.set(id, route);
+	}
+	const owners = /* @__PURE__ */ new Map();
+	const walk = (route, start, visited) => {
+		const reached = [];
+		const pending = [...start];
+		while (pending.length) {
+			const id = pending.pop();
+			if (visited.has(id)) continue;
+			visited.add(id);
+			if (roots.has(id) && roots.get(id) !== route) continue;
+			const module = input.modules.get(id);
+			if (!module) continue;
+			add(owners, id, route);
+			reached.push(id);
+			pending.push(...module.dependencies, ...module.dynamicDependencies ?? []);
+		}
+		return reached;
+	};
+	const visitedByRoute = /* @__PURE__ */ new Map();
+	for (const [route, ids] of input.routes) {
+		const visited = /* @__PURE__ */ new Set();
+		walk(route, ids, visited);
+		visitedByRoute.set(route, visited);
+	}
+	const imported = new Set(owners.keys());
+	for (const [route, visited] of visitedByRoute) {
+		const expanded = /* @__PURE__ */ new Set();
+		let frontier = [...visited].filter((id) => owners.get(id)?.has(route));
+		while (frontier.length) {
+			const next = [];
+			for (const id of frontier) {
+				const source = input.modules.get(id)?.source;
+				if (!source || expanded.has(source)) continue;
+				expanded.add(source);
+				const siblings = (sources.get(source) ?? []).filter((sibling) => !imported.has(sibling));
+				next.push(...walk(route, siblings, visited));
+			}
+			frontier = next;
+		}
+	}
+	const reachedOutsideRoutes = /* @__PURE__ */ new Set();
+	const outside = [...input.modules.keys()].filter((id) => !owners.has(id));
+	while (outside.length) {
+		const id = outside.pop();
+		for (const dependency of input.modules.get(id)?.dependencies ?? []) {
+			if (roots.has(dependency) || !owners.has(dependency)) continue;
+			if (reachedOutsideRoutes.has(dependency)) continue;
+			reachedOutsideRoutes.add(dependency);
+			outside.push(dependency);
+		}
+	}
+	const routeSpecific = (id) => owners.get(id).size < input.routes.size && (owners.get(id).size === 1 || input.modules.get(id)?.reachedFrom !== void 0);
+	const rootedLandings = new Set([...roots].filter(([id]) => !input.modules.get(id).navigationOnly).map(([, route]) => route));
+	const undemanded = input.undemandedDynamicTargets ?? /* @__PURE__ */ new Set();
+	const reach = (landingOnly) => {
+		const reached = /* @__PURE__ */ new Set();
+		const pending = [...input.modules.keys()].filter((id) => roots.has(id) || !owners.has(id));
+		while (pending.length) {
+			const id = pending.pop();
+			if (reached.has(id)) continue;
+			const module = input.modules.get(id);
+			if (landingOnly && module?.navigationOnly && roots.has(id)) continue;
+			reached.add(id);
+			if (!module) continue;
+			pending.push(...module.dependencies);
+			for (const target of module.dynamicDependencies ?? []) if (landingOnly || !undemanded.has(target)) pending.push(target);
+			if (module.source) pending.push(...sources.get(module.source) ?? []);
+		}
+		return reached;
+	};
+	const eager = reach(false);
+	const landing = reach(true);
+	const firstUse = /* @__PURE__ */ new Map();
+	const render = /* @__PURE__ */ new Map();
+	const known = /* @__PURE__ */ new Set();
+	for (const route of input.closures ?? []) {
+		if (route.fallback) continue;
+		known.add(route.route);
+		for (const consumer of route.consumers) for (const id of consumer.modules) add(consumer.kind === "render" ? render : firstUse, id, route.route);
+	}
+	const planned = [...owners.keys()].filter((id) => eager.has(id) && !(reachedOutsideRoutes.has(id) && routeSpecific(id)));
+	for (const id of planned) for (const route of owners.get(id)) if (!known.has(route)) add(landing.has(id) || !rootedLandings.has(route) ? firstUse : render, id, route);
+	const gzipKb = (ids) => estimatedGzipKb(ids.reduce((sum, id) => sum + (input.modules.get(id)?.size ?? 0), 0));
+	const renderIds = planned.filter((id) => !firstUse.has(id) && render.has(id));
+	const deferRender = deferralPays(gzipKb(renderIds));
+	if (!deferRender) for (const id of renderIds) firstUse.set(id, render.get(id));
+	const idleIds = planned.filter((id) => !firstUse.has(id) && !render.has(id));
+	const deferIdle = deferralPays(gzipKb(idleIds));
+	if (!deferIdle) for (const id of idleIds) firstUse.set(id, owners.get(id));
+	const groups = /* @__PURE__ */ new Map();
+	for (const id of owners.keys()) if (!eager.has(id) && !(reachedOutsideRoutes.has(id) && routeSpecific(id))) groups.set(id, MARKLESS_DEFERRED_PACK);
+	const critical = /* @__PURE__ */ new Map();
+	for (const id of planned) {
+		const routes = firstUse.get(id);
+		if (!routes) continue;
+		const foreign = [...owners.get(id)].some((route) => !routes.has(route));
+		push(critical, `${routeKey(routes)}${foreign ? SHARED_MARK : ""}`, id);
+	}
+	const landingRoutes = new Set([...critical.keys()].flatMap(routesOf));
+	for (const [marked, ids] of critical) {
+		const key = marked.replace(SHARED_MARK, "");
+		const routes = routesOf(key);
+		const name = routes.length === 1 && key === marked ? `route:${routes[0]}` : routes.length === landingRoutes.size || !input.pagesLoadOneRoute || mergeIntoWiderPack({
+			gzipKb: gzipKb(ids),
+			loadersNeeding: routes.length,
+			loadersNotNeeding: landingRoutes.size - routes.length,
+			msPerGzipKb: PACK_COST_MODEL.bootMsPerGzipKb
+		}) ? "shared" : `shared:${routeSetId(key)}`;
+		if (name.startsWith("shared:")) input.routeSets?.set(name, routes);
+		for (const id of ids) groups.set(id, name);
+	}
+	if (deferRender) {
+		const rendered = /* @__PURE__ */ new Map();
+		for (const id of renderIds) push(rendered, routeKey(render.get(id)), id);
+		const renderRoutes = new Set([...rendered.keys()].flatMap(routesOf));
+		for (const [key, ids] of rendered) {
+			const routes = routesOf(key);
+			const name = routes.length === 1 ? `${MARKLESS_NAVIGATION_PACK_PREFIX}${routes[0]}` : routes.length === renderRoutes.size || mergeIntoWiderPack({
+				gzipKb: gzipKb(ids),
+				loadersNeeding: routes.length,
+				loadersNotNeeding: renderRoutes.size - routes.length,
+				msPerGzipKb: PACK_COST_MODEL.interactionMsPerGzipKb
+			}) ? `${MARKLESS_NAVIGATION_PACK_PREFIX}shared` : `${MARKLESS_NAVIGATION_PACK_PREFIX}shared:${routeSetId(key)}`;
+			for (const id of ids) groups.set(id, name);
+		}
+	}
+	if (deferIdle) {
+		const deferred = /* @__PURE__ */ new Map();
+		for (const id of idleIds) push(deferred, routeKey(owners.get(id)), id);
+		const reachingRoutes = new Set([...deferred.keys()].flatMap(routesOf));
+		for (const [key, ids] of deferred) {
+			const routes = routesOf(key);
+			const name = routes.length === reachingRoutes.size || mergeIntoWiderPack({
+				gzipKb: gzipKb(ids),
+				loadersNeeding: routes.length,
+				loadersNotNeeding: reachingRoutes.size - routes.length,
+				msPerGzipKb: PACK_COST_MODEL.interactionMsPerGzipKb
+			}) ? MARKLESS_DEFERRED_PACK : `${MARKLESS_DEFERRED_PACK}-${routeSetId(key)}`;
+			for (const id of ids) groups.set(id, name);
+		}
+		for (let moved = true; moved;) {
+			moved = false;
+			for (const id of idleIds) {
+				const own = groups.get(id);
+				if (!isMarklessDeferredPack(own)) continue;
+				const target = input.modules.get(id).dependencies.map((dependency) => groups.get(dependency)).filter((name) => name !== void 0 && name !== own && (isMarklessNavigationPack(name) || isMarklessDeferredPack(name))).sort()[0];
+				if (!target) continue;
+				for (const other of idleIds) if (groups.get(other) === own) groups.set(other, target);
+				moved = true;
+			}
+		}
+	}
+	return input.pagesLoadOneRoute ? splitFrameworkFromApp(splitStartupPacksByStaticReach(groups, roots, sources, owners, input), input) : groups;
+}
+function splitFrameworkFromApp(groups, input) {
+	const halves = /* @__PURE__ */ new Map();
+	for (const [id, group] of groups) {
+		if (!isStartupPack(group)) continue;
+		const half = halves.get(group) ?? {
+			app: [],
+			framework: []
+		};
+		halves.set(group, half);
+		(input.modules.get(id)?.app ? half.app : half.framework).push(id);
+	}
+	const gzipKb = (ids) => estimatedGzipKb(ids.reduce((sum, id) => sum + (input.modules.get(id)?.size ?? 0), 0));
+	for (const [group, half] of halves) {
+		if (!frameworkSplitPays({
+			appGzipKb: gzipKb(half.app),
+			frameworkGzipKb: gzipKb(half.framework)
+		})) continue;
+		for (const id of half.framework) groups.set(id, `${group}${FRAMEWORK_PIECE}`);
+	}
+	return groups;
+}
+function splitStartupPacksByStaticReach(groups, roots, sources, owners, input) {
+	const gzipKbOf = (ids) => estimatedGzipKb(ids.reduce((sum, id) => sum + (input.modules.get(id)?.size ?? 0), 0));
+	const flagged = [...input.modules.values()].some((module) => module.firstEvent !== void 0);
+	const seed = (id) => {
+		const module = input.modules.get(id);
+		return !!module && !module.navigationOnly && (!flagged || !!module.firstEvent);
+	};
+	const handler = (id) => !!input.modules.get(id)?.handler;
+	const closure = (route, start, path) => {
+		const reached = /* @__PURE__ */ new Set();
+		const handlers = /* @__PURE__ */ new Set();
+		const pending = [...start];
+		while (pending.length) {
+			const id = pending.pop();
+			if (path.has(id) || reached.has(id) || roots.has(id) && roots.get(id) !== route) continue;
+			const module = input.modules.get(id);
+			if (!module) continue;
+			reached.add(id);
+			pending.push(...module.dependencies);
+			for (const sibling of module.source ? sources.get(module.source) ?? [] : []) if (seed(sibling) && sibling !== id) if (handler(sibling)) handlers.add(sibling);
+			else pending.push(sibling);
+		}
+		return {
+			reached,
+			handlers
+		};
+	};
+	const staticReach = /* @__PURE__ */ new Set();
+	for (const [route, ids] of input.routes) {
+		const visited = /* @__PURE__ */ new Set();
+		const first = closure(route, ids.filter((id) => seed(id) && !handler(id)), visited);
+		for (const id of first.reached) visited.add(id);
+		const candidates = [...first.handlers, ...[...owners].filter(([id, routes]) => routes.size === 1 && routes.has(route) && seed(id) && handler(id)).map(([id]) => id)];
+		while (candidates.length) {
+			const id = candidates.pop();
+			if (visited.has(id)) continue;
+			const extra = closure(route, [id], visited);
+			if (deferralPays(gzipKbOf([...extra.reached].filter((reached) => reached !== id)))) continue;
+			for (const reached of extra.reached) visited.add(reached);
+			candidates.push(...extra.handlers);
+		}
+		for (const id of visited) staticReach.add(id);
+	}
+	const known = new Map((input.closures ?? []).filter((route) => !route.fallback).map((route) => [route.route, route]));
+	const firstEventNeedsRuntime = (route) => !known.has(route) || known.get(route).consumers.some((consumer) => consumer.kind === "action" && !consumer.lean);
+	const firstEventIsLean = (route) => !firstEventNeedsRuntime(route) && known.get(route).consumers.some((consumer) => consumer.kind === "action");
+	const routePacks = new Set([...groups.values()].filter((group) => group.startsWith("route:")));
+	const lazy = /* @__PURE__ */ new Map();
+	const packSizes = /* @__PURE__ */ new Map();
+	for (const [id, group] of groups) {
+		if (!isStartupPack(group)) continue;
+		packSizes.set(group, (packSizes.get(group) ?? 0) + 1);
+		if (!staticReach.has(id)) push(lazy, group, id);
+	}
+	for (const [group, ids] of lazy) {
+		if (ids.length === packSizes.get(group)) continue;
+		const loaders = new Set(ids.flatMap((id) => [...owners.get(id) ?? []]));
+		const eager = [...loaders].filter(firstEventNeedsRuntime);
+		const loadersSpedUp = [...loaders].filter(firstEventIsLean).length;
+		if (!lazySiblingPays({
+			gzipKb: gzipKbOf(ids),
+			loadersSpedUp,
+			loaders: loaders.size
+		})) continue;
+		if (eager.some((route) => !routePacks.has(`route:${route}`))) continue;
+		const name = lazyStartupPackName(group);
+		for (const id of ids) groups.set(id, name);
+		if (eager.length) input.eagerLazyRoutes?.set(name, eager.sort());
+	}
+	return groups;
+}
+function lazyStartupPackName(group) {
+	return group.replace(/^(route|shared)/, `$1${LAZY_PACK_MARK}`);
+}
+function startupPackOfLazy(name) {
+	return name.replace(new RegExp(`^(route|shared)${LAZY_PACK_MARK}`), "$1");
+}
+const LAZY_PACK_MARK = "-lazy";
+const FRAMEWORK_PIECE = "~1";
+const ROUTE_KEY_SEPARATOR = "\n";
+const SHARED_MARK = "	";
+function routeKey(routes) {
+	return [...routes].sort().join(ROUTE_KEY_SEPARATOR);
+}
+function routeSetId(key) {
+	let hash = 2166136261;
+	for (let index = 0; index < key.length; index++) hash = Math.imul(hash ^ key.charCodeAt(index), 16777619) >>> 0;
+	return hash.toString(36);
+}
+function routesOf(key) {
+	return key.replace(SHARED_MARK, "").split(ROUTE_KEY_SEPARATOR);
+}
+function add(map, key, value) {
+	const values = map.get(key);
+	if (values) values.add(value);
+	else map.set(key, /* @__PURE__ */ new Set([value]));
+}
+function push(map, key, value) {
+	const values = map.get(key);
+	if (values) values.push(value);
+	else map.set(key, [value]);
+}
+//#endregion
+export { MARKLESS_EXECUTION_DEMAND as $, normalizeVirtualId as A, isExecutionLogChunk as At, sourceForSymbolVirtualImporter as B, isRelativeImport as C, EXECUTION_LOG_DISPATCH_MODULE_IDS as Ct, isScalarPlanSourceRequest as D, executionLogVirtualModuleSource as Dt, isRouteNavigationSourceRequest as E, executionLogActivationInjection as Et, serverSharedSourceRequest as F, emitPrerenderTriggerGroupModule as G, stripBuildPrefix as H, sharedReachedRenderDataRequest as I, adaptImportedCaptureResolver as J, planPrerenderTriggerGroups as K, sourceForPrerenderWakeVirtualImporter as L, renderDataReachedFromQuery as M, requalifyExecutionLogModuleHook as Mt, resolveVirtualId as N, planModulePreloadUrls as Nt, isSymbolOnlySourceRequest as O, hasExecutionLogModuleHook as Ot, resolverVirtualModuleSourceFile as P, planModulePreloads as Pt, MARKLESS_BYTE_ATTRIBUTION as Q, sourceForResumeVirtualImporter as R, isPrerenderWakeSourceRequest as S, withoutFirstUse as St, isResumeSourceRequest as T, MARKLESS_EXECUTION_LOG_MODULE_ID as Tt, virtualModuleSourceForLoad as U, sourceForTriggerGroupVirtualImporter as V, emitPrerenderBoundaryRendererModule as W, MARKLESS_BUILD_PREFIX as X, MARKLESS_BUILD_METADATA_FILES as Y, MARKLESS_BUNDLE_GRAPH as Z, devBrowserVirtualModuleUrl as _, scopedSymbolExportName as _t, isStartupPack as a, STORAGE_FREE_RESUME_ENTRY_SPECIFIER as at, isClientPrimarySourceRequest as b, symbolVirtualModuleId as bt, planRoutePackGroups as c, emitResumeModule as ct, plannedLandingFiles as d, encodedSymbolSource as dt, MARKLESS_EXECUTION_SIZES as et, MARKLESS_ROUTE_SOURCE_QUERY_RE as f, payloadModule as ft, devBrowserSourceModuleUrl as g, rewriteSymbolModuleExport as gt, clientSymbolEntries as h, resumeVirtualModuleId as ht, isMarklessNavigationPack as i, RESUME_ENTRY_SPECIFIER as it, pathname as j, normalizeExecutionLogMode as jt, materializedReachedRenderDataSource as k, injectExecutionLogModuleHook as kt, startupPackOfLazy as l, emitSettleModule as lt, clientRouteArtifactReference as m, prerenderWakeVirtualModuleSourceFile as mt, MARKLESS_NAVIGATION_PACK_PREFIX as n, outputDefaults as nt, lazyStartupPackName as o, demandsOverlay as ot, TSRX_SOURCE_FILE as p, prerenderWakeVirtualModuleId as pt, triggerGroupVirtualModuleId as q, isMarklessDeferredPack as r, MARKLESS_VIRTUAL_PREFIX as rt, marklessDeferredChunkFileNames as s, emitOverlayLoaderInstall as st, MARKLESS_DEFERRED_PACK as t, MARKLESS_INTERACTION_CLOSURES as tt, MARKLESS_INTERACTION_CLOSURES_ASSET as u, emitSourceModule as ut, emittedBundleModuleIds as v, settleVirtualModuleId as vt, isRenderDataSourceRequest as w, MARKLESS_EXECUTION_LOG_GLOBAL as wt, isMarklessRuntimeModule as x, symbolVirtualModuleSourceFile as xt, executionLogRuntimeModuleId as y, symbolEntryVirtualModuleId as yt, sourceForSettleVirtualImporter as z };