@markless/bundler 0.1.0

package/dist/source-module-CSRzW4Ny.js

@@ -0,0 +1,876 @@
+import { joinURL } from "ufo";
+//#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) => {
+		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);
+		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");
+	}
+	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;
+}
+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`;
+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 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
+	}]]) : null;
+	return `
+globalThis.__mxLog?.add(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)});
+const marklessDefaultModuleSizes = ${JSON.stringify(moduleSizes)};
+const marklessSizesUrl = ${JSON.stringify(options.sizesUrl ?? null)};
+let marklessSizesPromise;
+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)) map.set(id, sizeRecord(input[id])); return map; }
+async function loadModuleSizes(input) {
+	if (input.moduleSizes) return normalizeSizes(input.moduleSizes);
+	if (marklessDefaultModuleSizes) return normalizeSizes(marklessDefaultModuleSizes);
+	if (!marklessSizesUrl) return undefined;
+	marklessSizesPromise ||= fetch(marklessSizesUrl).then((response) => response.ok ? response.json() : undefined).then(normalizeSizes).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 canonicalId(id, sizes) {
+	if (!sizes || sizes.has(id)) return id;
+	const local = id.replace(/^(?:c\\d+:)+/, '');
+	if (!local.startsWith('symbol:')) return id;
+	const matches = [...sizes.keys()].filter((key) => { const parts = symbolParts(key); return !!parts && parts.symbolId === local; });
+	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 kb(items, sizes) {
+	if (!sizes) return items.length === 1 ? '1 module' : items.length + ' modules';
+	const records = [...new Set(items.map((id) => canonicalId(id, sizes)))].map((id) => sizes.get(id)).filter(Boolean); const est = [...sizes.values()].some((record) => record.estimated); let total = 0;
+	for (const record of records) total += record.estimated ? record.raw : (record.gzip || record.raw || 0);
+	return (total / 1024).toFixed(1) + ' KB' + (est ? ' est.' : '');
+}
+function bytesText(items, sizes) { return !sizes ? (items.length === 1 ? '1 module executed' : items.length + ' modules executed') : kb(items, sizes) + ' executed'; }
+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) => displayId(canonicalId(id, input.moduleSizes));
+	const rows = woken.map((id) => 'woke ' + label(id) + (input.moduleSizes ? ' (' + kb([id], input.moduleSizes) + ')' : '') + ' <- ' + cause);
+	if (record) for (const id of warmIds(input)) rows.push('ran warm ' + label(id) + (input.moduleSizes ? ' (' + kb([id], input.moduleSizes) + ')' : '') + ' <- ' + cause);
+	if (record && !(input.view?.behaviors || []).some((b) => b.hostNodeId === record.hostNodeId)) rows.push('skip behavior — no matching record touched');
+	return rows;
+}
+function mirror(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);
+}
+export async function installMarklessExecutionLog(input = {}) {
+	const log = globalThis.__mxLog; if (!log || log.__marklessInstalled) return;
+	log.__marklessInstalled = true;
+	const moduleSizes = await loadModuleSizes(input); const preloaded = input.preloadedModuleCount || document.querySelectorAll('link[rel="modulepreload"]').length; const current = modules(log);
+	if (input.printResumeSummary !== false) {
+		const summary = 'markless: resumed — ' + bytesText(current, moduleSizes) + ', ' + preloaded + ' modules preloaded (' + current.length + ' executed)';
+		console.log(summary); document.documentElement?.setAttribute('data-markless-log-summary', summary);
+	}
+	globalThis.__mxLogInteraction = (event) => {
+		const after = modules(log); const before = event.before || new Set(); const woken = after.filter((id) => !before.has(id)); const warm = warmIds(event);
+		if (event.noMatch) {
+			const line = 'markless: ' + event.eventName + ' [' + (event.selector || 'event target') + '] — no event record matched (0.0 KB)';
+			console.info(line); mirror(line); return;
+		}
+		const header = 'markless: ' + event.eventName + ' [' + (event.selector || 'event target') + '] · woke ' + woken.length + ' modules · ran warm ' + warm.length + ' modules · ' + kb([...new Set([...woken, ...warm])], moduleSizes);
+		console.groupCollapsed(header);
+		for (const row of causeRows({ ...event, after: new Set(after), moduleSizes })) console.log(row);
+		console.groupEnd(); mirror(header);
+	};
+}
+export async function logMarklessInteraction(event) { await installMarklessExecutionLog({ printResumeSummary: false }); globalThis.__mxLogInteraction?.(event); }
+export async function logMarklessRenderSummary(input = {}) {
+	const log = globalThis.__mxLog; if (!log) return;
+	const moduleSizes = await loadModuleSizes(input); const current = modules(log);
+	const summary = 'markless: rendered — ' + current.length + ' ' + (current.length === 1 ? 'module' : 'modules') + ' executed (' + kb(current, moduleSizes) + ')';
+	console.log(summary); document.documentElement?.setAttribute('data-markless-log-summary', summary);
+}
+`;
+}
+async function createExecutionSizesAsset(bundle, metadata, canonPath = (fileName) => fileName) {
+	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;
+		const size = {
+			raw: item.code.length,
+			gzip: await gzipByteLength(item.code),
+			chunk
+		};
+		for (const id of logIds) entries[id] = size;
+	}
+	return {
+		type: "asset",
+		fileName: MARKLESS_EXECUTION_SIZES,
+		source: JSON.stringify(sortRecord(entries))
+	};
+}
+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(); })();`
+	};
+}
+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;
+}
+//#endregion
+//#region src/source-module.ts
+const MARKLESS_VIRTUAL_PREFIX = "virtual:markless:";
+const SMALL_SYMBOL_DIRECT_LOAD_LIMIT = 8;
+const SYMBOL_VIRTUAL_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}symbol:`;
+function symbolVirtualModuleId(filename, symbolId) {
+	return `${SYMBOL_VIRTUAL_PREFIX}${encodeURIComponent(filename)}:${encodeURIComponent(symbolId)}`;
+}
+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 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");
+}
+function emitSourceModule(input) {
+	const symbolsOnly = input.environment === "client" && input.clientOutput === "symbols-only";
+	const routeSymbols = input.environment === "client" && input.symbolRoutes.length > 0;
+	return [
+		symbolsOnly ? "" : `import { state as payloadState, view as payloadView, runtimeDemandMap as payloadRuntimeDemandMap } from '${input.payloadId}';`,
+		"",
+		emitLoadSymbol(input),
+		input.environment === "client" && input.executionLog !== "never" ? emitExecutionLogLoader() : "",
+		routeSymbols ? "const marklessLoadLocalSymbol = loadSymbol;" : "",
+		symbolsOnly && !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.publicRenderModuleSource,
+		input.environment === "server" || symbolsOnly ? "" : input.publicCsrModuleSource,
+		input.environment === "client" ? "" : input.publicSsrModuleSource,
+		routeSymbols ? emitLazySymbolRouteFunction(input.symbolRoutes, "marklessSsrLoadSymbolRoute", "marklessLoadLocalSymbol") : "",
+		symbolsOnly && routeSymbols ? "export { marklessSsrLoadSymbolRoute as loadSymbol };" : "",
+		symbolsOnly ? "" : emitCompiledAppDefault({
+			environment: input.environment,
+			executionLog: input.executionLog,
+			headInjections: input.headInjections,
+			resumeModuleUrl: input.resumeModuleUrl,
+			rootExportName: input.publicRenderRootExportName,
+			csrExportName: input.publicRenderCsrExportName,
+			ssrExportName: input.publicRenderSsrExportName
+		}),
+		""
+	].filter((line) => line !== null).join("\n");
+}
+function emitResumeModule(input) {
+	const routeSymbols = input.symbolRoutes.length > 0;
+	const resumeSymbolLoader = routeSymbols ? "marklessSsrLoadSymbolRoute" : "loadSymbol";
+	const scalarSpecializations = scalarDispatcherSpecializations(input);
+	return [
+		`import { runtimeDemandMap as payloadRuntimeDemandMap } from '${input.payloadId}';`,
+		scalarSpecializations.length > 0 ? [
+			"import { marklessDecodeScalarCell, marklessFindElementAtDomOrderIndex, 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") : "",
+		"",
+		input.executionLog === "never" ? "" : emitExecutionLogLoader(),
+		"",
+		emitLoadSymbol(input),
+		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),
+		""
+	].filter((line) => line !== null).join("\n");
+}
+function emitLazySymbolRouteFunction(routes, functionName, fallbackName = "loadSymbol") {
+	if (routes.length === 0) return "";
+	return [
+		`function ${functionName}(symbolId) {`,
+		...routes.flatMap((route) => [
+			`	if (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
+			`		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 ${fallbackName}(symbolId);`,
+		"}"
+	].join("\n");
+}
+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" ? [
+		"	renderSsr(props, marklessRenderContext) {",
+		`		return ${input.ssrExportName}(props, marklessRenderContext);`,
+		"	},"
+	] : [];
+	const resumeModuleEntry = input.resumeModuleUrl && input.environment !== "client" ? [`	resumeModuleUrl: ${JSON.stringify(input.resumeModuleUrl)},`] : [];
+	const headInjectionEntry = input.headInjections?.length && input.environment !== "client" ? [`	headInjections: ${JSON.stringify(input.headInjections)},`] : [];
+	const modulePreloadEntry = input.resumeModuleUrl && input.environment === "server" ? [`	modulePreloads: [{ href: ${JSON.stringify(input.resumeModuleUrl)}, fetchPriority: "high" }],`] : [];
+	const metadataEntries = input.environment === "client" ? [] : [
+		...headInjectionEntry,
+		...resumeModuleEntry,
+		...modulePreloadEntry,
+		input.executionLog && input.executionLog !== "never" ? `	executionLog: ${JSON.stringify(input.executionLog)},` : "",
+		"	payloadView,"
+	];
+	return [
+		"const marklessCompiledApp = {",
+		...renderCsrEntry,
+		...renderSsrEntry,
+		...metadataEntries,
+		"};",
+		"export default marklessCompiledApp;"
+	].join("\n");
+}
+function emitResumeContainerEvent(loadSymbolName, needsFullResume, leanMode, scalarSpecializations, runtimeDemandMap) {
+	const fullResumeHandoff = [
+		"async function marklessFullResumeHandoff(handoff) {",
+		"	handoff.root.__asyncResumeRuntimeStarted = true;",
+		"	const { resumeFromPayloadDocument } = await import('@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) {",
+			"	await marklessResumeSpecializedScalarEvent(input);",
+			"}"
+		].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");
+	}
+	return [
+		fullResumeHandoff,
+		"export async function resumeContainerEvent(input) {",
+		"	await marklessFullResumeHandoff({ ...input, document: input.root });",
+		"}"
+	].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 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 (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,
+			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 state = { value: marklessDecodeScalarCell(marklessReadScalarCell(input.root, ${action.cellIndex}), ${JSON.stringify(action.cell)}, ${JSON.stringify(`markless/state cell[${action.cellIndex}]`)}), 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; 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; 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) {
+	if (input.symbols.length > 0 && input.symbols.length <= SMALL_SYMBOL_DIRECT_LOAD_LIMIT) return emitDirectSourceSymbolLoader(input.symbols);
+	return [
+		`const marklessSymbolResolverModule = () => import('${input.resolverId}');`,
+		"function loadSymbol(symbolId) {",
+		"	return marklessSymbolResolverModule().then((mod) => mod.loadSymbol(symbolId));",
+		"}"
+	].join("\n");
+}
+function emitDirectSourceSymbolLoader(symbols) {
+	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)}));`]),
+		"	return Promise.reject(new Error(`Unknown async symbol ${symbolId}`));",
+		"}",
+		emitSourceSymbolExportReader()
+	].join("\n");
+}
+function emitSourceSymbolExportReader() {
+	return [
+		"function readMarklessSourceSymbol(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 { planModulePreloads as S, requalifyExecutionLogModuleHook as _, resumeVirtualModuleId as a, outputDefaults as b, symbolVirtualModuleId as c, MARKLESS_EXECUTION_SIZES as d, createExecutionSizesAsset as f, normalizeExecutionLogMode as g, injectExecutionLogModuleHook as h, payloadModule as i, symbolVirtualModuleSourceFile as l, executionLogVirtualModuleSource as m, emitResumeModule as n, rewriteSymbolModuleExport as o, executionLogActivationInjection as p, emitSourceModule as r, scopedSymbolExportName as s, MARKLESS_VIRTUAL_PREFIX as t, MARKLESS_EXECUTION_LOG_MODULE_ID as u, MARKLESS_BUILD_PREFIX as v, planModulePreloadUrls as x, MARKLESS_BUNDLE_GRAPH as y };