@markless/bundler 0.4.0 → 0.5.0

package/dist/source-module-DI20i0ZG.js

@@ -1,1168 +0,0 @@
-import { joinURL } from "ufo";
-import { ASYNC_PROTOCOL_VERSION } from "@markless/serializer";
-//#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")) {
-			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 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; 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 the whole raw byte length of the chunk that absorbed it (several modules in
-// one chunk are each charged the whole chunk), which is what unit says.
-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: [] };
-	for (const raw of ids) {
-		const id = canonicalId(raw, sizes);
-		const record = sizes && sizes.get(id);
-		// The unit is the chunk, so the dedupe unit is the chunk: one chunk reached
-		// under two names (a symbol id and the emitted specifier Rolldown rewrote
-		// its hook to) is one charge, not two. Dev estimates carry no chunk, so
-		// there the id is still the unit.
-		const chunk = record && record.chunk;
-		if (chunk ? seenChunks.has(chunk) : seen.has(id)) continue;
-		if (chunk) seenChunks.add(chunk); else seen.add(id);
-		if (!record) { delta.unmapped.push(id); continue; }
-		if (record.estimated) l.unit = 'estimated-source-bytes';
-		delta[ledgerCategory(id, record)] += record.raw; delta.gzip += record.gzip || 0; delta.modules.push(id);
-	}
-	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);
-	const rows = woken.map((id) => 'woke ' + label(id) + (input.moduleSizes ? ' (' + rowKb([id], input.moduleSizes) + (input.moduleSizes.get(canonicalId(id, input.moduleSizes))?.instrument ? ' instrument' : '') + ')' : '') + ' <- ' + cause);
-	if (record) for (const id of warmIds(input)) rows.push('ran warm ' + label(id) + (input.moduleSizes ? ' (' + rowKb([id], input.moduleSizes) + (input.moduleSizes.get(canonicalId(id, input.moduleSizes))?.instrument ? ' instrument' : '') + ')' : '') + ' <- ' + 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); }
-export async function logMarklessSpecializedInteraction(input, before) {
-	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) });
-}
-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/source-module.ts
-const MARKLESS_VIRTUAL_PREFIX = "virtual:markless:";
-const SMALL_SYMBOL_DIRECT_LOAD_LIMIT = 8;
-const MARKLESS_BOUND_SYMBOLS_EXPORT = "marklessBoundSymbols";
-const SYMBOL_VIRTUAL_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}symbol:`;
-function symbolVirtualModuleId(filename, symbolId) {
-	return `${SYMBOL_VIRTUAL_PREFIX}${encodeURIComponent(filename)}:${encodeURIComponent(symbolId)}`;
-}
-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(filename, exportName) {
-	return `${exportName}_${stringHash(filename)}`;
-}
-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(payload.runtimeDemandMap, null, "	")};`,
-		`export const view = ${JSON.stringify(payload.view, null, "	")};`,
-		""
-	].join("\n");
-}
-/** 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}();`,
-		"	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.hasOverlayMarks === true ? emitOverlayLoaderInstall() : null,
-		"",
-		emitLoadSymbol(input),
-		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") : "",
-		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 = 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;
-}
-/**
-* 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 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');";
-}
-/**
-* 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);
-}
-const ROW_MINT_RUNTIME_MODULE_ID = "web/fns/row-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 scalarSpecializations = scalarDispatcherSpecializations(input);
-	const stagedPrerender = (input.prerenderTriggerGroups?.length ?? 0) > 0;
-	const resumeContainerEvent = emitQueuedResumeContainerEvent(emitResumeContainerEvent(resumeSymbolLoader, input.needsFullResume ?? false, input.payloadState?.version === ASYNC_PROTOCOL_VERSION, input.symbolRoutes.length > 0 ? "none" : leanResumeMode(input.runtimeDemandMap), scalarSpecializations, input.runtimeDemandMap, input.executionLog !== "never", input.prerenderDataId, stagedPrerender));
-	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.prerenderDataId}'); return module.marklessPrerenderData; }` : null,
-		`import { runtimeDemandMap as payloadRuntimeDemandMap } from '${input.payloadId}';`,
-		payloadHasComputed(input.payloadState) ? ["import { installMarklessDerivedReconcile } from '@markless/web/fns/reconcile-plane';", "installMarklessDerivedReconcile();"].join("\n") : null,
-		demandsOverlay(input.runtimeDemandMap) ? emitOverlayLoaderInstall() : null,
-		demandsRowMint(input.runtimeDemandMap) ? emitRowMintLoaderInstall() : null,
-		scalarSpecializations.length > 0 ? [
-			"import { marklessDecodeScalarCell, marklessReadScalarCell, marklessScalarSpecializedError } from '@markless/web/fns/scalar-specialized';",
-			"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" ? "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,
-		""
-	].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) {
-	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;",
-		"	if (!root.__marklessDispatch) {",
-		"		let handler = marklessResumeContainerEvent, tail = Promise.resolve(), 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 === lastEvent && eventTime === lastEventTime) return tail;",
-		"			lastEvent = event;",
-		"			lastEventTime = eventTime;",
-		"			const run = () => handler(next);",
-		"			return tail = tail.then(run, run);",
-		"		};",
-		"	}",
-		"	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") {
-	if (routes.length === 0) return "";
-	const ordered = [...routes].sort((left, right) => right.prefix.length - left.prefix.length);
-	return [
-		`function ${functionName}(symbolId) {`,
-		...ordered.flatMap((route) => [
-			`	if (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
-			"importSource" in route ? `		return import(${JSON.stringify(symbolRouteImportSource(route.importSource))}).then((mod) => mod.loadSymbol ? mod.loadSymbol(symbolId.slice(${route.prefix.length})) : Promise.reject(new Error(\`Unknown child async symbol \${symbolId}\`)));` : `		return ${route.prefix.length > 0 ? functionName : fallbackName}(symbolId.slice(${route.prefix.length}));`,
-			"	}"
-		]),
-		`	return ${fallbackName}(symbolId);`,
-		"}"
-	].join("\n");
-}
-function symbolRouteImportSource(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 = new Set([
-	"loadBehaviorSymbol",
-	"loadSymbol",
-	"marklessCompiledApp",
-	"marklessLoadLocalSymbol",
-	"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 exactly the part `marklessSsrComponentPart` hands a composed
-* child, through the same access path, so a named import and a member tag reach
-* one object.
-*/
-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;
-		if (input.servesSsr) return `export const ${component.exportName} = ${isRoot ? `{ ...marklessCompiledApp, renderSsr: ${part}.renderSsr }` : part};`;
-		return isRoot ? `export const ${component.exportName} = marklessCompiledApp;` : `export const ${component.exportName} = { marklessCsrOnlyPart: ${JSON.stringify(component.exportName)} };`;
-	});
-}
-function emitResumeContainerEvent(loadSymbolName, needsFullResume, storageFreePayload, leanMode, scalarSpecializations, runtimeDemandMap, executionLogEnabled, prerenderDataId, stagedPrerender = false) {
-	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}),`,
-		"			})).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 { derivePrerenderResumeRecords, mergePrerenderPayloadRecords, renderPrerenderBoundary, resumeFromPrerenderRecords } = await import('@markless/web/fns/prerender-resume');",
-		`\tconst records = await derivePrerenderResumeRecords(marklessPrerenderData, ${loadSymbolName});`,
-		"	const mergedRecords = mergePrerenderPayloadRecords(records, handoff.root);",
-		"	const { runtime } = await resumeFromPrerenderRecords({",
-		"		...mergedRecords,",
-		"		root: handoff.root,",
-		`\t\tloadSymbol: ${loadSymbolName},`,
-		`\t\trenderAsyncBoundary: (boundaryId, status, graph) => renderPrerenderBoundary(marklessPrerenderData, boundaryId, status, graph, ${loadSymbolName}),`,
-		"	});",
-		"	await runtime.dispatch(handoff.event, { syncPolicyAlreadyApplied: handoff.syncPolicyAlreadyApplied === true, ignoreUnmatched: true });",
-		"}"
-	].join("\n") : [
-		"async function marklessFullResumeHandoff(handoff) {",
-		"	handoff.root.__asyncResumeRuntimeStarted = true;",
-		`	const { resumeFromPayloadDocument } = await import('${storageFreePayload ? "@markless/core/web/resume-storage-free" : "@markless/core/web/resume"}');`,
-		"	const { runtime } = await resumeFromPayloadDocument({",
-		"		document: handoff.document,",
-		"		root: handoff.root,",
-		`		loadSymbol: ${loadSymbolName},`,
-		"	});",
-		"	await runtime.dispatch(handoff.event, { syncPolicyAlreadyApplied: handoff.syncPolicyAlreadyApplied === true, ignoreUnmatched: true });",
-		"}"
-	].join("\n");
-	const scalarOnlySpecialized = leanMode === "scalar" && scalarSpecializations.length > 0 && allEventActionsHaveScalarPlan(runtimeDemandMap);
-	const scalarDispatcher = scalarSpecializations.length > 0 ? emitSpecializedScalarDispatcher(scalarSpecializations, loadSymbolName, scalarOnlySpecialized ? "fail" : "full") : emitSpecializedScalarDispatcher([], loadSymbolName, "full");
-	if (needsFullResume) 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;
-	if ((input.symbolRoutes?.length ?? 0) > 0) return [];
-	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 || 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 } : {}
-			}] : [];
-		});
-		if (textUpdates.length !== (plan.textUpdates ?? []).length) return [];
-		return [{
-			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 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) {
-	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) {",
-		"	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); }",
-		"function marklessScalarSpecializedAction(input) {",
-		...actions.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 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));",
-		"}",
-		...actions.map((action) => emitScalarAction(action, loadSymbolName)),
-		...fallbackBody
-	].join("\n");
-}
-function emitScalarAction(action, loadSymbolName) {
-	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)}) ?? ${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 = marklessFindElementAtDomOrderIndex(input.root, ${action.hostIndex});`,
-		`	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} = marklessFindElementAtDomOrderIndex(input.root, ${update.index});`),
-		...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');",
-			"		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)) }, ${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 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 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 <= SMALL_SYMBOL_DIRECT_LOAD_LIMIT) {
-		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.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);
-}
-//#endregion
-export { planModulePreloadUrls as C, requalifyExecutionLogModuleHook as S, executionLogActivationInjection as _, encodedSymbolSource as a, injectExecutionLogModuleHook as b, prerenderWakeVirtualModuleSourceFile as c, scopedSymbolExportName as d, settleVirtualModuleId as f, MARKLESS_EXECUTION_LOG_MODULE_ID as g, EXECUTION_LOG_DISPATCH_MODULE_IDS as h, emitSourceModule as i, resumeVirtualModuleId as l, symbolVirtualModuleSourceFile as m, emitResumeModule as n, payloadModule as o, symbolVirtualModuleId as p, emitSettleModule as r, prerenderWakeVirtualModuleId as s, MARKLESS_VIRTUAL_PREFIX as t, rewriteSymbolModuleExport as u, executionLogVirtualModuleSource as v, planModulePreloads as w, normalizeExecutionLogMode as x, hasExecutionLogModuleHook as y };