@markless/bundler 0.2.2 → 0.3.0

package/dist/{source-module-C8W2THUI.js → source-module-BCEdLQvG.js}

@@ -1,4 +1,5 @@
 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)(?:[?#].*)?$/;
@@ -33,7 +34,7 @@ function planModulePreloads(input) {
 			probability
 		});
 	};
-	const visit = (name, probability, priority, fetchPriority, seen, suppressed = false) => {
+	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];
@@ -52,7 +53,7 @@ function planModulePreloads(input) {
 			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);
+		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;
@@ -61,7 +62,7 @@ function planModulePreloads(input) {
 	};
 	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");
+		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];
@@ -128,179 +129,18 @@ function priorityToFetchPriority(priority) {
 	if (priority === "auto") return "auto";
 	return priority;
 }
-const MARKLESS_BUILD_PREFIX = `build/`;
-const MARKLESS_BUNDLE_GRAPH = `${MARKLESS_BUILD_PREFIX}bundle-graph.json`;
-const WEB_RUNTIME_CAPABILITY_GROUPS = [
-	{
-		name: "markless-resume-branches",
-		test: fileBasenamePattern("resume-branches")
-	},
-	{
-		name: "markless-resume-behaviors",
-		test: fileBasenamePattern("resume-behaviors")
-	},
-	{
-		name: "markless-resume-repeats",
-		test: fileBasenamePattern("resume-keyed-repeats", "repeat-runtime")
-	},
-	{
-		name: "markless-resume-async",
-		test: fileBasenamePattern("resume-async-boundaries", "resume-async-wiring")
-	},
-	{
-		name: "markless-resume-shared-patch",
-		test: fileBasenamePattern("resume-shared-patch")
-	},
-	{
-		name: "markless-resume-runtime",
-		test: fileBasenamePattern("resume-runtime")
-	},
-	{
-		name: "markless-resume-runtime-start",
-		test: fileBasenamePattern("resume-runtime-start")
-	},
-	{
-		name: "markless-resume-runtime-shared",
-		test: fileBasenamePattern("resume-runtime-shared")
-	},
-	{
-		name: "markless-resume-events",
-		test: fileBasenamePattern("resume-events")
-	},
-	{
-		name: "markless-resume-handoff",
-		test: fileBasenamePattern("resume-handoff")
-	},
-	{
-		name: "markless-resume-locators",
-		test: fileBasenamePattern("resume-locators")
-	},
-	{
-		name: "markless-resume-errors",
-		test: fileBasenamePattern("resume-errors")
-	},
-	{
-		name: "markless-resume-sync-computed",
-		test: fileBasenamePattern("resume-sync-computed")
-	},
-	{
-		name: "markless-resume-sync-demand",
-		test: fileBasenamePattern("resume-sync-demand")
-	},
-	{
-		name: "markless-payload-full",
-		test: fileBasenamePattern("payload-full")
-	},
-	{
-		name: "markless-payload-resume",
-		test: fileBasenamePattern("payload-resume")
-	},
-	{
-		name: "markless-inline-payload-document",
-		test: /[/\\]web[/\\]src[/\\]inline[/\\]payload-document\.ts(?:[?#].*)?$/
-	},
-	{
-		name: "markless-payload-document",
-		test: fileBasenamePattern("payload-document", "payload-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-state")
-	},
-	{
-		name: "markless-value-decode",
-		test: fileBasenamePattern("value-decode-client", "value-decode-extensions")
-	},
-	{
-		name: "markless-payload-leaves",
-		test: fileBasenamePattern("payload", "payload-document")
-	},
-	{
-		name: "markless-dev-log",
-		test: /virtual:markless:dev-log|[/\\]web[/\\]src[/\\]dev-log\.ts(?:[?#].*)?$/
-	},
-	{
-		name: "markless-resume-core",
-		test: fileBasenamePattern("resume")
-	},
-	{
-		name: "markless-runtime-graph-core",
-		test: fileBasenamePattern("graph-core")
-	},
-	{
-		name: "markless-runtime-graph-collections",
-		test: fileBasenamePattern("graph-collections")
-	},
-	{
-		name: "markless-runtime-graph-computed",
-		test: fileBasenamePattern("graph-computed")
-	},
-	{
-		name: "markless-runtime-graph-async",
-		test: fileBasenamePattern("graph-async")
-	},
-	{
-		name: "markless-runtime-graph-scheduler",
-		test: fileBasenamePattern("graph-scheduler")
-	},
-	{
-		name: "markless-runtime-graph-shared",
-		test: fileBasenamePattern("graph-shared")
-	},
-	{
-		name: "markless-graph",
-		test: /[/\\](?:runtime[/\\]src[/\\](?!graph-(?:core|collections|computed|async|scheduler|shared)\.ts)|core[/\\]src[/\\]runtime)[/\\]?/
-	},
-	{
-		name: "markless-serializer",
-		test: /[/\\]serializer[/\\]src[/\\](?!protocol-validation)/
-	}
-];
-function fileBasenamePattern(...names) {
-	return new RegExp(`[/\\\\](?:${names.join("|")})\\.ts(?:[?#].*)?$`);
-}
-const MARKLESS_RUNTIME_GROUPS = [...WEB_RUNTIME_CAPABILITY_GROUPS, {
-	name: "markless-runtime",
-	test: /[/\\]@markless[/\\]runtime[/\\]/
-}];
-function outputDefaults(output, environment) {
-	if (environment === "lib") return output;
-	const next = {
-		...output,
-		hoistTransitiveImports: false
-	};
-	if (environment === "server") {
-		next.entryFileNames ??= "[name].js";
-		next.chunkFileNames ??= "chunk-[hash].js";
-		next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
-		return next;
-	}
-	next.entryFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
-	next.chunkFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
-	next.minifyInternalExports = true;
-	next.strictExecutionOrder = true;
-	next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
-	return next;
-}
-function marklessCodeSplitting(codeSplitting) {
-	if (typeof codeSplitting === "boolean") throw new Error("@markless/bundler requires output.codeSplitting to be an object so runtime chunks can be grouped.");
-	return {
-		...codeSplitting,
-		groups: [...MARKLESS_RUNTIME_GROUPS, ...codeSplitting?.groups ?? []]
-	};
-}
 //#endregion
 //#region src/execution-log.ts
 const MARKLESS_EXECUTION_LOG_MODULE_ID = "virtual:markless:dev-log";
-const MARKLESS_EXECUTION_SIZES = `${MARKLESS_BUILD_PREFIX}execution-sizes.json`;
+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";
 }
@@ -309,6 +149,9 @@ function injectExecutionLogModuleHook(source, moduleId, mode) {
 	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`);
@@ -334,9 +177,10 @@ 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') map.set(id, sizeRecord(input[id])); return map; }
+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); }
@@ -347,7 +191,20 @@ async function loadModuleSizes(input) {
 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; } }
-function qualifySymbolIds(ids, hostNodeId, sizes, tables) { const route = routeFile(); if (!route || route.includes('..') || route.includes('\\\\')) return ids; const canonical = route.replace(/^\\/+/, ''); const scopes = tables && Object.prototype.hasOwnProperty.call(tables, canonical) ? tables[canonical] : undefined; 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 || !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; const matches = [...(sizes?.keys() || [])].filter((key) => { const match = /^virtual:markless:symbol:([^:]+):([^:]+)$/.exec(key); if (!match || match[1] !== scopes[scope]) return false; try { return decodeURIComponent(match[2]) === sizeSymbolId; } catch { return false; } }); if (matches.length !== 1) return id; if (!base) return matches[0]; const match = /^virtual:markless:symbol:([^:]+):/.exec(matches[0]); return match ? 'virtual:markless:symbol:' + match[1] + ':' + encodeURIComponent(local) : id; }); }
+// 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;
@@ -361,11 +218,91 @@ 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.estimated ? record.raw : (record.gzip ?? record.raw); if (record.instrument) { instrumentModules++; instrumentBytes += bytes; instrumentEstimated ||= !!record.estimated; } else { appModules++; appBytes += bytes; appEstimated ||= !!record.estimated; } }
+	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 category(a, name) { const bytes = name === 'app' ? a.appBytes : a.instrumentBytes; const count = name === 'app' ? a.appModules : a.instrumentModules; if (bytes === null) return count + ' ' + name + ' module' + (count === 1 ? '' : 's') + (name === 'app' && a.unmappedIds.length ? ' (bytes unknown; ' + a.unmappedIds.length + ' unmapped)' : ''); return (bytes / 1024).toFixed(1) + ' KB' + (a.estimated[name] ? ' est. source' : '') + ' ' + name; }
 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;
@@ -376,34 +313,40 @@ function causeRows(input) {
 	if (record && !(input.view?.behaviors || []).some((b) => b.hostNodeId === record.hostNodeId)) rows.push('skip behavior — no matching record touched');
 	return rows;
 }
-function mirror(text, a) {
+function mirrorInteraction(l, turn, text) {
 	const root = document.documentElement; if (!root) return;
-	const count = Number(root.getAttribute('data-markless-log-interactions') || '0') + 1;
-	root.setAttribute('data-markless-log-interactions', String(count)); root.setAttribute('data-markless-log-last', text); mirrorBytes(root, a);
+	root.setAttribute('data-markless-log-interactions', String(Number(root.getAttribute('data-markless-log-interactions') || '0') + 1));
+	ledgerMirror(l, turn, text, 'data-markless-log-last');
 }
-function mirrorBytes(root, a) { if (a.appBytes === null || a.instrumentBytes === null) { root.removeAttribute('data-markless-log-app-bytes'); root.removeAttribute('data-markless-log-instrument-bytes'); return; } root.setAttribute('data-markless-log-app-bytes', String(a.appBytes)); root.setAttribute('data-markless-log-instrument-bytes', String(a.instrumentBytes)); }
 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 preloaded = input.preloadedModuleCount || document.querySelectorAll('link[rel="modulepreload"]').length; const current = modules(log);
+	const moduleSizes = await loadModuleSizes(input); const current = modules(log);
 	if (input.printResumeSummary !== false) {
-		const a = accounting(current, moduleSizes); const summary = 'markless: resumed — ' + category(a, 'app') + ' executed, ' + preloaded + ' modules preloaded (' + a.appModules + ' app executed) · ' + category(a, 'instrument');
-		console.log(summary); const root = document.documentElement; if (root) { root.setAttribute('data-markless-log-summary', summary); mirrorBytes(root, a); }
+		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 a = accounting([], moduleSizes); const line = 'markless: ' + event.eventName + ' [' + (event.selector || 'event target') + '] — no event record matched · 0.0 KB app · 0.0 KB instrument';
-			console.info(line); mirror(line, a); return;
+			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 a = accounting([...woken, ...warm], moduleSizes); const header = 'markless: ' + event.eventName + ' [' + (event.selector || 'event target') + '] · woke ' + woken.length + ' modules · ran warm ' + warm.length + ' modules · ' + category(a, 'app') + ' · ' + category(a, 'instrument');
+		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(); mirror(header, a);
+		console.groupEnd(); mirrorInteraction(l, turn, header);
 	};
 	log.__marklessInstalled = true;
 	})();
@@ -415,96 +358,47 @@ export async function logMarklessSpecializedInteraction(input, before) {
 	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 current = modules(log); const a = accounting(current, moduleSizes);
-	const summary = 'markless: rendered — ' + a.appModules + ' app module' + (a.appModules === 1 ? '' : 's') + ' executed (' + category(a, 'app') + ') · ' + a.instrumentModules + ' instrument module' + (a.instrumentModules === 1 ? '' : 's') + ' executed (' + category(a, 'instrument').replace(/ instrument$/, '') + ')';
-	console.log(summary); const root = document.documentElement; if (root) { root.setAttribute('data-markless-log-summary', summary); mirrorBytes(root, a); }
+	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);
 }
 `;
 }
-async function createExecutionSizesAsset(bundle, metadata, canonPath = (fileName) => fileName, attribution) {
-	const entries = {};
-	const symbolLogIdsByChunk = /* @__PURE__ */ new Map();
-	for (const module of metadata.modules) for (const symbol of module.symbols) {
-		if (!symbol.fileName) continue;
-		const chunk = symbolLogIdsByChunk.get(symbol.fileName) ?? [];
-		chunk.push(stripResolvedIdMarker(symbol.virtualModuleId));
-		symbolLogIdsByChunk.set(symbol.fileName, chunk);
-	}
-	for (const item of Object.values(bundle)) {
-		if (item.type !== "chunk") continue;
-		const chunk = canonPath(item.fileName);
-		const logIds = new Set([...item.moduleIds.flatMap((id) => chunkModuleLogId(id) ?? []), ...symbolLogIdsByChunk.get(chunk) ?? []]);
-		if (logIds.size === 0) continue;
-		if (logIds.has("virtual:markless:dev-log") && logIds.size > 1) {
-			const cohabitingIds = [...logIds].filter((id) => id !== MARKLESS_EXECUTION_LOG_MODULE_ID).sort();
-			throw new Error(`Markless execution sizes require an isolated dev-log chunk; chunk "${chunk}" also contains logged module ids: ${cohabitingIds.join(", ")}.`);
-		}
-		const size = {
-			raw: item.code.length,
-			gzip: await gzipByteLength(item.code),
-			chunk
-		};
-		for (const id of logIds) entries[id] = id === "virtual:markless:dev-log" ? {
-			...size,
-			instrument: true
-		} : size;
-	}
-	return {
-		type: "asset",
-		fileName: MARKLESS_EXECUTION_SIZES,
-		source: JSON.stringify({
-			...sortRecord(entries),
-			...attribution && Object.keys(attribution).length > 0 ? { attribution: sortNestedRecord(attribution) } : {}
-		})
-	};
-}
 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(); })();`
+		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 }); } })();`
 	};
 }
-function chunkModuleLogId(id) {
-	const path = stripResolvedIdMarker(id);
-	if (path === "virtual:markless:dev-log") return path;
-	const match = path.match(/[/\\](web|runtime|serializer)[/\\]src[/\\]([^?#]+)\.ts$/);
-	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : null;
-}
-function stripResolvedIdMarker(id) {
-	return id.startsWith("\0") ? id.slice(1) : id;
-}
-async function gzipByteLength(code) {
-	const encoded = new TextEncoder().encode(code);
-	const reader = new ReadableStream({ start(controller) {
-		controller.enqueue(encoded);
-		controller.close();
-	} }).pipeThrough(new CompressionStream("gzip")).getReader();
-	let total = 0;
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		total += value.byteLength;
-	}
-	return total;
-}
-function sortRecord(record) {
-	const next = {};
-	for (const key of Object.keys(record).sort()) next[key] = record[key];
-	return next;
-}
-function sortNestedRecord(record) {
-	const next = {};
-	for (const key of Object.keys(record).sort()) next[key] = sortRecord({ ...record[key] });
-	return next;
-}
 //#endregion
 //#region src/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)}`;
@@ -528,6 +422,49 @@ function symbolVirtualModuleSourceFile(moduleId) {
 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)}`;
 }
@@ -557,25 +494,31 @@ function emitPublicRenderModule(source, input) {
 	].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;
 	return [
+		!input.publicSsrModuleSource && !input.publicRenderModuleSource || symbolsOnly || !input.renderDataId || input.environment === "client" && !input.publicRenderModuleSource && !input.prerenderRecords && !input.dev && !canonicalRenderData ? "" : canonicalRenderData ? `import { marklessPrerenderData } from '${input.renderDataId}';` : `import { marklessRenderData } from '${input.renderDataId}';`,
 		symbolsOnly ? "" : `import { state as payloadState, view as payloadView, runtimeDemandMap as payloadRuntimeDemandMap } from '${input.payloadId}';`,
 		"",
 		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 && !routeSymbols ? "export { 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 ? "" : emitPublicRenderModule(input.publicRenderModuleSource, {
+		input.environment === "server" || symbolsOnly || input.prerenderRecords ? "" : emitPublicRenderModule(input.publicRenderModuleSource, {
 			executionLogEnabled: input.executionLog !== "never",
 			rootExportName: input.publicRenderRootExportName
 		}),
-		input.environment === "server" || symbolsOnly ? "" : input.publicCsrModuleSource,
-		input.environment === "client" ? "" : input.publicSsrModuleSource,
+		input.environment === "client" && (symbolsOnly || !input.prerenderRecords && !input.dev) ? "" : input.publicSsrModuleSource,
 		routeSymbols ? emitLazySymbolRouteFunction(input.symbolRoutes, "marklessSsrLoadSymbolRoute", "marklessLoadLocalSymbol") : "",
 		symbolsOnly && routeSymbols ? "export { marklessSsrLoadSymbolRoute as loadSymbol };" : "",
 		symbolsOnly ? "" : emitCompiledAppDefault({
@@ -584,10 +527,15 @@ function emitSourceModule(input) {
 			headInjections: input.headInjections,
 			storageSeeds: input.storageSeeds,
 			inlineResumerSources: input.inlineResumerSources,
+			prerenderBoot: input.prerenderBoot,
 			resumeModuleUrl: input.resumeModuleUrl,
+			prerenderWakeModuleUrl: input.prerenderWakeModuleUrl,
 			rootExportName: input.publicRenderRootExportName,
-			csrExportName: input.publicRenderCsrExportName,
-			ssrExportName: input.publicRenderSsrExportName
+			symbolLoaderName: routeSymbols ? "marklessSsrLoadSymbolRoute" : "loadSymbol",
+			ssrExportName: input.publicRenderSsrExportName,
+			canonicalRenderData,
+			prerenderRecords: input.prerenderRecords,
+			dev: input.dev
 		}),
 		""
 	].filter((line) => line !== null).join("\n");
@@ -596,24 +544,63 @@ 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 streamedResume = stagedPrerender || (input.payloadView?.asyncBoundaries?.length ?? 0) > 0;
+	const bareResumeContainerEvent = 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);
+	const resumeContainerEvent = streamedResume ? emitQueuedResumeContainerEvent(bareResumeContainerEvent) : bareResumeContainerEvent;
 	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}';`,
 		scalarSpecializations.length > 0 ? [
-			"import { marklessDecodeScalarCell, marklessFindElementAtDomOrderIndex, marklessReadScalarCell, marklessScalarSpecializedError } from '@markless/web/fns/scalar-specialized';",
+			"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),
+		emitLoadSymbol(input, stagedPrerender ? "readMarklessWakeSourceSymbol" : void 0),
 		routeSymbols ? "const marklessLoadLocalSymbol = loadSymbol;" : "",
 		routeSymbols ? emitLazySymbolRouteFunction(input.symbolRoutes, "marklessSsrLoadSymbolRoute", "marklessLoadLocalSymbol") : "",
 		routeSymbols ? "export { marklessSsrLoadSymbolRoute as loadSymbol };" : "",
-		emitResumeContainerEvent(resumeSymbolLoader, input.needsFullResume ?? false, input.symbolRoutes.length > 0 ? "none" : leanResumeMode(input.runtimeDemandMap), scalarSpecializations, input.runtimeDemandMap, input.executionLog !== "never"),
+		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 emitLazySymbolRouteFunction(routes, functionName, fallbackName = "loadSymbol") {
 	if (routes.length === 0) return "";
 	return [
@@ -631,14 +618,18 @@ function symbolRouteImportSource(importSource) {
 	return importSource.includes("?") ? `${importSource}&markless-symbols` : `${importSource}?markless-symbols`;
 }
 function emitCompiledAppDefault(input) {
-	const renderCsrEntry = (input.rootExportName || input.csrExportName) && input.environment !== "server" ? [`	renderCsr: ${input.rootExportName ?? input.csrExportName},`] : [];
-	const renderSsrEntry = input.ssrExportName && input.environment !== "client" ? [
+	const renderCsrEntry = input.rootExportName && input.environment !== "server" && !input.prerenderRecords ? [`	renderCsr: ${input.rootExportName},`] : [];
+	const symbolLoaderEntry = input.environment !== "server" && input.rootExportName === null ? [`\tloadSymbol: ${input.symbolLoaderName},`] : input.prerenderRecords === true ? [`\tloadSymbol: ${input.symbolLoaderName},`] : [];
+	const renderDataEntry = input.canonicalRenderData ? ["	renderData: marklessPrerenderData,"] : [];
+	const renderSsrEntry = input.ssrExportName && (input.environment !== "client" || input.prerenderRecords || input.dev) ? [
 		"	renderSsr(props, marklessRenderContext) {",
 		`		return ${input.ssrExportName}(props, marklessRenderContext);`,
 		"	},"
 	] : [];
 	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" }],`] : [];
@@ -646,7 +637,9 @@ function emitCompiledAppDefault(input) {
 		...headInjectionEntry,
 		...storageSeedEntry,
 		...resumeModuleEntry,
+		...prerenderWakeModuleEntry,
 		...inlineResumerEntry,
+		...prerenderBootEntry,
 		...modulePreloadEntry,
 		input.executionLog && input.executionLog !== "never" ? `	executionLog: ${JSON.stringify(input.executionLog)},` : "",
 		"	payloadView,"
@@ -654,17 +647,62 @@ function emitCompiledAppDefault(input) {
 	return [
 		"const marklessCompiledApp = {",
 		...renderCsrEntry,
+		...renderDataEntry,
+		...symbolLoaderEntry,
 		...renderSsrEntry,
 		...metadataEntries,
 		"};",
 		"export default marklessCompiledApp;"
 	].join("\n");
 }
-function emitResumeContainerEvent(loadSymbolName, needsFullResume, leanMode, scalarSpecializations, runtimeDemandMap, executionLogEnabled) {
-	const fullResumeHandoff = [
+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 { resumeFromPayloadDocument } = await import('@markless/core/web/resume');",
+		"	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,",
@@ -722,6 +760,7 @@ function emitResumeContainerEvent(loadSymbolName, needsFullResume, leanMode, sca
 			"}"
 		].join("\n");
 	}
+	if (prerenderDataId) return "export async function resumeContainerEvent(_input) {}";
 	return [
 		fullResumeHandoff,
 		"export async function resumeContainerEvent(input) {",
@@ -729,6 +768,37 @@ function emitResumeContainerEvent(loadSymbolName, needsFullResume, leanMode, sca
 		"}"
 	].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;
@@ -740,11 +810,12 @@ function scalarDispatcherSpecializations(input) {
 		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 || !host || typeof host.index !== "number") 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);
@@ -763,6 +834,7 @@ function scalarDispatcherSpecializations(input) {
 			symbolId,
 			cell: plan.cell,
 			cellIndex,
+			initialCell,
 			hostIndex: host.index,
 			hostTagName: String(host.tagName ?? "*"),
 			syncPolicy: event?.syncPolicy ?? null,
@@ -826,7 +898,7 @@ function emitScalarAction(action, loadSymbolName) {
 		"	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, ${action.cellIndex}), ${JSON.stringify(action.cell)}, ${JSON.stringify(`markless/state cell[${action.cellIndex}]`)}));`,
+		`	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});`,
@@ -907,8 +979,12 @@ function leanResumeMode(runtimeDemandMap) {
 function emitExecutionLogLoader() {
 	return `globalThis.__mxLoadLog ||= () => import(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)});`;
 }
-function emitLoadSymbol(input) {
-	if (!input.hasBoundSymbols && input.symbols.length > 0 && input.symbols.length <= SMALL_SYMBOL_DIRECT_LOAD_LIMIT) return emitDirectSourceSymbolLoader(input.symbols);
+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) {",
@@ -916,18 +992,18 @@ function emitLoadSymbol(input) {
 		"}"
 	].join("\n");
 }
-function emitDirectSourceSymbolLoader(symbols) {
+function emitDirectSourceSymbolLoader(symbols, readerName = "readMarklessSourceSymbol") {
 	return [
 		"function loadSymbol(symbolId) {",
-		...symbols.flatMap((symbol) => [`	if (symbolId === ${JSON.stringify(symbol.id)}) return import('${symbol.chunk}')`, `		.then((mod) => readMarklessSourceSymbol(mod, ${JSON.stringify(symbol.exportName)}));`]),
+		...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()
+		emitSourceSymbolExportReader(readerName)
 	].join("\n");
 }
-function emitSourceSymbolExportReader() {
+function emitSourceSymbolExportReader(name = "readMarklessSourceSymbol") {
 	return [
-		"function readMarklessSourceSymbol(mod, exportName) {",
+		`function ${name}(mod, exportName) {`,
 		"	mod.init__virtual_markless_symbol?.();",
 		"	return mod[exportName];",
 		"}"
@@ -942,4 +1018,4 @@ function stringHash(value) {
 	return (hash >>> 0).toString(36);
 }
 //#endregion
-export { planModulePreloads as C, planModulePreloadUrls as S, normalizeExecutionLogMode as _, payloadModule as a, MARKLESS_BUNDLE_GRAPH as b, scopedSymbolExportName as c, MARKLESS_EXECUTION_LOG_MODULE_ID as d, MARKLESS_EXECUTION_SIZES as f, injectExecutionLogModuleHook as g, executionLogVirtualModuleSource as h, encodedSymbolSource as i, symbolVirtualModuleId as l, executionLogActivationInjection as m, emitResumeModule as n, resumeVirtualModuleId as o, createExecutionSizesAsset as p, emitSourceModule as r, rewriteSymbolModuleExport as s, MARKLESS_VIRTUAL_PREFIX as t, symbolVirtualModuleSourceFile as u, requalifyExecutionLogModuleHook as v, outputDefaults as x, MARKLESS_BUILD_PREFIX as y };
+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 };