@markless/bundler 0.2.2 → 0.3.1

package/dist/vite.js

@@ -1,9 +1,916 @@
-import { MARKLESS_DEV_ERROR_CLEAR_EVENT, MARKLESS_DEV_ERROR_CLIENT_ID, MARKLESS_DEV_ERROR_EVENT, normalizeMarklessDevError } from "./dev-error.js";
-import { m as executionLogActivationInjection, x as outputDefaults } from "./source-module-C8W2THUI.js";
-import { a as preflightTsrxModuleDiagnostics, t as createMarklessRolldownPlugin, u as createPreloadGraphAdder } from "./rolldown-CpG_S-ZJ.js";
-import { joinURL, parsePath } from "ufo";
-import { readFile } from "node:fs/promises";
-import { isAbsolute } from "node:path";
+import { MARKLESS_DEV_ERROR_CLEAR_EVENT, MARKLESS_DEV_ERROR_CLIENT_ID, MARKLESS_DEV_ERROR_EVENT, normalizeMarklessDevError, renderMarklessDevErrorDocument } from "./dev-error.js";
+import { _ as executionLogActivationInjection } from "./source-module-BCEdLQvG.js";
+import { d as outputDefaults, o as preflightTsrxModuleDiagnostics, p as createPreloadGraphAdder, t as createMarklessRolldownPlugin } from "./rolldown-DAsY_7V1.js";
+import { joinURL, parsePath, withQuery } from "ufo";
+import { ASYNC_PROTOCOL_VERSION, STORAGE_SLOT_SYMBOL_KEY, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName } from "@markless/serializer";
+import { pathToFileURL } from "node:url";
+import { join, resolve } from "pathe";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { PROTOCOL_EVENT_ACTION_KIND as PROTOCOL_EVENT_ACTION_KIND$1, protocolEventDispatchesMarkless } from "@markless/serializer/protocol";
+import "@markless/serializer/resume-record-delta";
+import { deserializeGraphValueForClient } from "@markless/serializer/decode-client";
+import { createServerModuleRunner, isRunnableDevEnvironment } from "vite";
+import { isAbsolute as isAbsolute$1 } from "node:path";
+//#region ../web/src/inline/resumer.ts
+PROTOCOL_EVENT_ACTION_KIND$1.event, PROTOCOL_EVENT_ACTION_KIND$1.externalDelegate;
+function createInlineResumerSelfWakeSource(resumeModuleUrl) {
+	return `;(${runInlineResumerSelfWake.toString()})(${JSON.stringify(resumeModuleUrl)});`;
+}
+const PRERENDER_INLINE_EVENT_NAMES_TOKEN = "__MARKLESS_PRERENDER_EVENT_NAMES__";
+function renderPrerenderInlineResumerSource(compiled, eventNames) {
+	return compiled.replace(PRERENDER_INLINE_EVENT_NAMES_TOKEN, JSON.stringify(eventNames));
+}
+function createPrerenderInlineResumerSource(eventNames, resumeModuleUrl, options) {
+	const plain = `(${runPrerenderInlineResumer.toString()})(${JSON.stringify(eventNames)},${JSON.stringify(resumeModuleUrl)},u=>import(u));`;
+	const logging = options?.executionLog !== void 0 && options.executionLog !== "never";
+	if (!options?.debug && !logging) return plain;
+	return `{
+${options?.debug ? `const __MARKLESS_PRERENDER_DEBUG_BOOTSTRAP__=${options.debug.bootstrapSource};\n(${runPrerenderInlineResumerDebugSetup.toString()})(${JSON.stringify(eventNames)});` : ""}
+${logging ? `(${runPrerenderInlineResumerLogSummary.toString()})(${JSON.stringify(options.executionLog)});` : ""}
+${plain}
+}`;
+}
+function runPrerenderInlineResumerLogSummary(mode) {
+	if (!(() => {
+		if (mode === "always") return true;
+		const currentLocation = location;
+		if (/^https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::|$)/.test(currentLocation.origin) || new URLSearchParams(currentLocation.search).has("markless-log")) return true;
+		try {
+			return localStorage.getItem("marklessLog") === "1";
+		} catch {
+			return false;
+		}
+	})()) return;
+	const globalScope = globalThis;
+	const ledger = globalScope.__marklessExecutionLedger ||= {
+		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 ownBytes = document.currentScript?.textContent?.length ?? 0;
+	ledger.total.inline += ownBytes;
+	if (!ledger.loadClosed) ledger.load.inline += ownBytes;
+	for (const type of [
+		"pointerdown",
+		"touchstart",
+		"keydown"
+	]) addEventListener(type, (event) => {
+		if (event.isTrusted) ledger.loadClosed = true;
+	}, {
+		capture: true,
+		passive: true
+	});
+	ledger.turns.push({
+		kind: "resume",
+		delta: {
+			app: 0,
+			framework: 0,
+			instrument: 0
+		},
+		modules: []
+	});
+	const executed = [...globalScope.__mxLog ||= /* @__PURE__ */ new Set()];
+	const preloaded = document.querySelectorAll("link[rel=modulepreload]").length;
+	const loadBytes = ledger.load.app + ledger.load.framework + ledger.load.inline;
+	const totalBytes = ledger.total.app + ledger.total.framework + ledger.total.inline;
+	const summary = executed.length === 0 ? `markless: resumed — 0.0 KB app executed, ${preloaded} modules preloaded (0 app executed) · 0.0 KB instrument` : `markless: ${(loadBytes / 1024).toFixed(1)} KB executed at load · total ${(totalBytes / 1024).toFixed(1)} KB · ${executed.length} modules pending sizes`;
+	console.log(summary);
+	const documentElement = document.documentElement;
+	if (documentElement) {
+		documentElement.setAttribute("data-markless-log-summary", summary);
+		documentElement.setAttribute("data-markless-log-inline-bytes", String(ledger.total.inline));
+		documentElement.setAttribute("data-markless-log-load-bytes", String(loadBytes));
+		if (executed.length === 0) {
+			documentElement.setAttribute("data-markless-log-app-bytes", "0");
+			documentElement.setAttribute("data-markless-log-instrument-bytes", "0");
+		} else documentElement.removeAttribute("data-markless-log-app-bytes");
+	}
+}
+function runPrerenderInlineResumerDebugSetup(eventNames) {
+	const root = document.currentScript?.closest("[data-async-container]");
+	if (!root) return;
+	try {
+		const controls = __MARKLESS_PRERENDER_DEBUG_BOOTSTRAP__?.(root, "ssr-inline", false);
+		controls?.delegated?.(eventNames);
+		controls?.activate();
+	} catch {}
+}
+function runPrerenderInlineResumer(eventNames, fallbackResumeModuleUrl, loadModule) {
+	const currentScript = document.currentScript;
+	const root = currentScript?.closest("[data-async-container]");
+	const resumeModuleUrl = currentScript?.getAttribute?.("data-markless-resume-module") ?? fallbackResumeModuleUrl;
+	if (!root || !resumeModuleUrl) return;
+	for (const eventName of eventNames) root.addEventListener(eventName, (event) => {
+		root.__marklessDelegatedDispatch = true;
+		return loadModule(resumeModuleUrl).then((module) => module.resumeContainerEvent({
+			root,
+			event,
+			element: event.target,
+			eventRecord: null
+		}));
+	}, true);
+}
+function runInlineResumerSelfWake(fallbackResumeModuleUrl) {
+	const currentScript = document.currentScript;
+	const root = currentScript?.closest("[data-async-container]");
+	const resumeModuleUrl = currentScript?.getAttribute?.("data-markless-resume-module") ?? fallbackResumeModuleUrl;
+	if (!root || !resumeModuleUrl) return;
+	const wake = () => requestAnimationFrame(() => {
+		queueMicrotask(async () => {
+			if (!root.__asyncResumeRuntimeStarted) {
+				root.__marklessDelegatedDispatch = true;
+				await (await import(
+					/* @vite-ignore */
+					resumeModuleUrl
+)).resumeContainerEvent({
+					root,
+					event: 0
+				});
+			}
+		});
+	});
+	if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", wake, { once: true });
+	else wake();
+}
+//#endregion
+//#region ../web/src/repeat-runtime.ts
+var KeyedRepeatRuntimeError = class extends Error {
+	code = "MARKLESS_REPEAT_KEY_DUPLICATE";
+	severity = "error";
+	phase = "runtime";
+	repeatId;
+	keyPath;
+	collidingValue;
+	docsUrl;
+	constructor(diagnostic) {
+		super(diagnostic.message);
+		Object.defineProperty(this, "message", {
+			value: diagnostic.message,
+			enumerable: true,
+			configurable: true
+		});
+		this.name = "KeyedRepeatRuntimeError";
+		this.repeatId = diagnostic.repeatId;
+		this.keyPath = diagnostic.keyPath;
+		this.collidingValue = diagnostic.collidingValue;
+		this.docsUrl = diagnostic.docsUrl;
+	}
+};
+function validateKeyedRepeatGraphKeys(graph, view) {
+	for (const repeat of view.keyedRepeats ?? []) assertUniqueRepeatKeys(repeat, readKeyedRepeatCollection(graph, repeat));
+}
+async function validateKeyedRepeatPayloadKeys(input) {
+	const entries = await Promise.all(input.state.cells.map(async (cell) => [cell.graphNodeId, cell.value === void 0 ? void 0 : await deserializeGraphValueForClient(cell.value)]));
+	const cells = new Map(entries);
+	validateKeyedRepeatGraphKeys({ read(graphNodeId, path = []) {
+		return readPath(cells.get(graphNodeId), path);
+	} }, input.view);
+}
+function readKeyedRepeatCollection(graph, repeat) {
+	if (!repeat.collectionGraphNodeId) return [];
+	const value = graph.read(repeat.collectionGraphNodeId, repeat.collectionPath);
+	if (Array.isArray(value)) return value;
+	return Array.from(value ?? []);
+}
+function repeatItemKey(item, repeat) {
+	return readPath(item, repeat.keyPath);
+}
+function assertUniqueRepeatKeys(repeat, items) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const key = repeatItemKey(item, repeat);
+		if (seen.has(key)) throw duplicateRepeatKeyError(repeat, key);
+		seen.set(key, true);
+	}
+}
+function duplicateRepeatKeyError(repeat, key) {
+	const source = `${repeat.itemName}.${repeat.keyPath.join(".")}`;
+	return new KeyedRepeatRuntimeError({
+		message: `MARKLESS_REPEAT_KEY_DUPLICATE: Duplicate @for key ${JSON.stringify(key)} from ${source}.`,
+		repeatId: repeat.id,
+		keyPath: repeat.keyPath,
+		collidingValue: key,
+		docsUrl: "https://markless.dev/errors/MARKLESS_REPEAT_KEY_DUPLICATE"
+	});
+}
+function readPath(value, path) {
+	let cursor = value;
+	for (const key of path) {
+		if (cursor == null) return void 0;
+		cursor = cursor[key];
+	}
+	return cursor;
+}
+//#endregion
+//#region ../web/src/prerender/records.ts
+async function prepareSsrResumeRecords(output) {
+	const rawState = output.state ?? emptyStatePayload();
+	const state = {
+		...rawState,
+		cells: serializeRuntimeStateCells(rawState.cells ?? []),
+		computed: serializeRuntimeAsyncSnapshots(rawState.computed ?? [])
+	};
+	const view = containerScopedView(output.view ?? emptyViewPayload());
+	await validateKeyedRepeatPayloadKeys({
+		state,
+		view
+	});
+	return {
+		state,
+		view
+	};
+}
+function containerScopedView(view) {
+	return {
+		...view,
+		locators: view.locators.map((locator) => ({
+			...locator,
+			index: locator.index + 1
+		}))
+	};
+}
+function emptyStatePayload() {
+	return {
+		version: ASYNC_PROTOCOL_VERSION,
+		cells: [],
+		computed: []
+	};
+}
+function emptyViewPayload() {
+	return {
+		version: ASYNC_PROTOCOL_VERSION,
+		locators: [],
+		events: [],
+		domUpdates: [],
+		behaviors: [],
+		elementHandles: [],
+		asyncBoundaries: []
+	};
+}
+//#endregion
+//#region ../web/src/prerender/evaluator.ts
+async function evaluateBuiltPageClosure(page, props) {
+	const renderContext = { prerender: true };
+	if (typeof page === "function") return page(props, renderContext);
+	if (page && typeof page.renderSsr === "function") return page.renderSsr(props, renderContext);
+	throw new TypeError("Prerender resume requires a compiled TSRX artifact.");
+}
+//#endregion
+//#region ../web/src/render-to-string.ts
+async function assemblePrerenderPageParts(component, output, options) {
+	const { state, view } = await prepareSsrResumeRecords(output);
+	const browserTriggers = hasBrowserTriggers(view, state);
+	const resumeModuleUrl = options.prerenderWakeModuleUrl ?? options.resumeModuleUrl ?? artifactPrerenderWakeModuleUrl(component) ?? artifactResumeModuleUrl(component);
+	const modulePreloads = (typeof options.modulePreloads === "function" ? options.modulePreloads(output.html) : options.modulePreloads) ?? (browserTriggers ? artifactModulePreloads(component) : void 0);
+	const eventNames = browserEventNames(view);
+	const selfWake = hasUnsettledAsyncBoundaryRunner(view, state);
+	const boot = artifactPrerenderBoot(component);
+	const settle = options.armEmission && selfWake ? boot?.settle : void 0;
+	const resumerScript = browserTriggers && resumeModuleUrl ? renderInlineResumerScript(settle ? renderPrerenderInlineResumerSource(settle.boot, eventNames) : boot ? renderPrerenderInlineResumerSource(selfWake ? boot.prerenderSelfWake : boot.prerender, eventNames) : createPrerenderInlineResumerSource(eventNames, resumeModuleUrl), options.nonce, resumeModuleUrl, selfWake && !settle, settle?.moduleUrl, !boot) : "";
+	return {
+		head: [
+			renderStorageSeedScript(artifactStorageSeeds(component), options.nonce),
+			renderHeadInjections(artifactHeadInjections(component), options.nonce),
+			renderModulePreloadLinks(modulePreloads, options.nonce)
+		].filter(Boolean).join(""),
+		container: [
+			`<div${renderContainerAttributes(options.containerId)}>`,
+			output.html,
+			options.armEmission ?? "",
+			resumerScript,
+			"</div>"
+		].filter(Boolean).join("")
+	};
+}
+async function renderSsrOutput(component, props, renderContext) {
+	if (typeof component === "function") return component(props, renderContext);
+	if (component && typeof component.renderSsr === "function") return component.renderSsr(props, renderContext);
+	throw new TypeError("renderToString(App) requires a compiled TSRX artifact.");
+}
+function artifactResumeModuleUrl(component) {
+	return typeof component === "object" ? component.resumeModuleUrl : void 0;
+}
+function artifactPrerenderBoot(component) {
+	return typeof component === "object" ? component.prerenderBoot : void 0;
+}
+function artifactPrerenderWakeModuleUrl(component) {
+	return typeof component === "object" ? component.prerenderWakeModuleUrl : void 0;
+}
+function artifactModulePreloads(component) {
+	return typeof component === "object" ? component.modulePreloads : void 0;
+}
+function artifactHeadInjections(component) {
+	return typeof component === "object" ? component.headInjections : void 0;
+}
+function artifactStorageSeeds(component) {
+	return typeof component === "object" ? component.storageSeeds : void 0;
+}
+function renderHeadInjections(injections, nonce) {
+	if (!injections?.length) return "";
+	return injections.filter((injection) => injection.location === "head").map((injection) => renderHeadInjection(injection, nonce)).join("");
+}
+function renderStorageSeedScript(seeds, nonce) {
+	if (!seeds?.length) return "";
+	return `<script${nonce ? ` nonce="${escapeAttribute(nonce)}"` : ""}>${escapeInlineScript(`(()=>{const s=globalThis[Symbol.for(${JSON.stringify(STORAGE_SLOT_SYMBOL_KEY)})]||={};for(const[k,d,a,f]of ${JSON.stringify(seeds.map((seed) => [
+		seed.slotKey,
+		seed.driverKey,
+		storageAttributeName(seed.driverKey),
+		seed.fallback
+	]))}){let v=f;try{v=localStorage.getItem(d)??f}catch{}s[k]=v;document.documentElement.setAttribute(a,v)}})()`)}<\/script>`;
+}
+function renderHeadInjection(injection, nonce) {
+	const attributes = { ...injection.attributes };
+	if (nonce && injection.tag === "script" && !attributes.nonce) attributes.nonce = nonce;
+	const renderedAttributes = Object.entries(attributes).map(([name, value]) => `${name}="${escapeAttribute(value)}"`).join(" ");
+	const suffix = renderedAttributes ? ` ${renderedAttributes}` : "";
+	return injection.tag === "link" ? `<${injection.tag}${suffix}>` : `<${injection.tag}${suffix}>${escapeInlineScript(injection.children ?? "")}</${injection.tag}>`;
+}
+function renderModulePreloadLinks(preloads, nonce) {
+	if (!preloads?.length) return "";
+	const seen = /* @__PURE__ */ new Set();
+	const links = [];
+	for (const preload of preloads) {
+		const entry = typeof preload === "string" ? { href: preload } : preload;
+		if (!entry.href || seen.has(entry.href)) continue;
+		seen.add(entry.href);
+		const attributes = [
+			"rel=\"modulepreload\"",
+			`href="${escapeAttribute(entry.href)}"`,
+			`crossorigin="${escapeAttribute(entry.crossOrigin ?? "anonymous")}"`,
+			entry.fetchPriority ? `fetchpriority="${entry.fetchPriority}"` : "",
+			nonce ? `nonce="${escapeAttribute(nonce)}"` : ""
+		].filter(Boolean);
+		links.push(`<link ${attributes.join(" ")}>`);
+	}
+	return links.join("");
+}
+function hasBrowserTriggers(view, state) {
+	return (state.storage?.length ?? 0) > 0 || view.events.some(protocolEventDispatchesMarkless) || state.computed.some((computed) => computed.async === false && typeof computed.deriveSymbolId === "string") || view.behaviors.some((behavior) => !!behavior.symbolId) || Object.keys(view.asyncRunners ?? {}).length > 0 || view.asyncBoundaries.some((boundary) => boundary.asyncReads.some((read) => !!read.runnerSymbolId)) || (view.keyedRepeats ?? []).some((repeat) => repeat.rowEvents.length > 0) || (view.branches ?? []).some((branch) => (branch.armRecords ?? []).some((arm) => arm.events.some(protocolEventDispatchesMarkless))) || view.asyncBoundaries.some((boundary) => boundaryArmEventNames(boundary).length > 0);
+}
+function hasUnsettledAsyncBoundaryRunner(view, state) {
+	const runners = { ...view.asyncRunners };
+	const reachable = /* @__PURE__ */ new Set();
+	for (const boundary of view.asyncBoundaries) for (const read of boundary.asyncReads) {
+		reachable.add(read.graphNodeId);
+		if (read.runnerSymbolId) runners[read.graphNodeId] ??= read.runnerSymbolId;
+	}
+	const computedByGraphNode = new Map(state.computed.map((computed) => [computed.graphNodeId, computed]));
+	for (const graphNodeId of reachable) {
+		const computed = computedByGraphNode.get(graphNodeId);
+		if (!computed) continue;
+		if (runners[graphNodeId]) {
+			const status = computed.snapshot?.status;
+			if (status !== "fulfilled" && status !== "rejected") return true;
+		}
+		for (const dependency of computed.dependencies ?? []) reachable.add(dependency.graphNodeId);
+	}
+	return false;
+}
+function boundaryArmEventNames(boundary) {
+	const armRecords = boundary.armRecords;
+	if (!armRecords || Array.isArray(armRecords)) return [];
+	return [...(armRecords.events ?? []).filter(protocolEventDispatchesMarkless).map((event) => event.eventName), ...(armRecords.keyedRepeats ?? []).flatMap((repeat) => repeat.rowEvents.map((event) => event.eventName))];
+}
+function browserEventNames(view) {
+	return [...new Set([
+		...view.events.filter(protocolEventDispatchesMarkless).map((event) => event.eventName),
+		...(view.keyedRepeats ?? []).flatMap((repeat) => repeat.rowEvents.map((event) => event.eventName)),
+		...(view.branches ?? []).flatMap((branch) => (branch.armRecords ?? []).flatMap((arm) => arm.events.filter(protocolEventDispatchesMarkless).map((event) => event.eventName))),
+		...view.asyncBoundaries.flatMap(boundaryArmEventNames)
+	])].filter((eventName) => eventName !== "visible");
+}
+function renderContainerAttributes(containerId) {
+	return containerId ? ` data-async-container="${escapeAttribute(containerId)}"` : " data-async-container";
+}
+function renderInlineResumerScript(source, nonce, resumeModuleUrl, selfWake, settleModuleUrl, appendSelfWakeSource = true) {
+	return `<script data-async-resumer${nonce ? ` nonce="${escapeAttribute(nonce)}"` : ""}${resumeModuleUrl ? ` data-markless-resume-module="${escapeAttribute(resumeModuleUrl)}"` : ""}${settleModuleUrl ? ` data-markless-settle-module="${escapeAttribute(settleModuleUrl)}"` : ""}${selfWake ? " data-markless-self-wake" : ""}>${escapeInlineScript(source + (selfWake && appendSelfWakeSource ? createInlineResumerSelfWakeSource(resumeModuleUrl) : ""))}<\/script>`;
+}
+function escapeAttribute(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function escapeInlineScript(value) {
+	return value.replace(/<\/script/gi, "<\\/script");
+}
+//#endregion
+//#region src/build/prerender.ts
+async function deriveBuiltPrerenderRecords(input) {
+	return withBuiltPrerenderPage(input, async (page) => prepareSsrResumeRecords(await evaluateBuiltPageClosure(page)));
+}
+async function emitPrerenderedPage(input) {
+	const page = await withBuiltPrerenderPage(input, async (built) => {
+		const output = await evaluateBuiltPageClosure(built);
+		const emission = await deriveArmFillPlan(built, {
+			state: output.state,
+			bound: artifactSettleBound(built)
+		});
+		return assemblePrerenderPageParts(built, output, {
+			resumeModuleUrl: input.resumeModuleUrl,
+			prerenderWakeModuleUrl: input.prerenderWakeModuleUrl,
+			armEmission: emission?.html
+		});
+	});
+	const htmlFile = resolve(input.root, input.outDir, "index.html");
+	const html = await readFile(htmlFile, "utf8");
+	const placeholder = "<div id=\"app\"></div>";
+	if (!html.includes(placeholder)) throw new Error("MARKLESS_PRERENDER_CONTAINER_MISSING: expected exact #app build placeholder");
+	await writeFile(htmlFile, (page.head ? html.replace("</head>", `${page.head}</head>`) : html).replace(placeholder, page.container));
+}
+const SENTINEL_OPEN = "";
+const SENTINEL_CLOSE = "";
+const SENTINEL_PATTERN = /mh(\d+)/g;
+const PROBE_TAGS = [1000003, 8000017];
+var ArmPlanUnsupported = class extends Error {};
+function unsupported(reason) {
+	throw new ArmPlanUnsupported(reason);
+}
+function createHoleMinter() {
+	const byKey = /* @__PURE__ */ new Map();
+	const paths = [];
+	return {
+		paths,
+		sentinel(path) {
+			const key = path.join("\0");
+			let index = byKey.get(key);
+			if (index === void 0) {
+				index = paths.length;
+				byKey.set(key, index);
+				paths.push(path);
+			}
+			return `${SENTINEL_OPEN}mh${index}${SENTINEL_CLOSE}`;
+		},
+		index(path) {
+			const key = path.join("\0");
+			const found = byKey.get(key);
+			if (found === void 0) unsupported(`unminted path: ${path.join(".")}`);
+			return found;
+		}
+	};
+}
+function holeProxy(minter, path, options) {
+	const target = options.rows === null ? {} : Array.from({ length: options.rows });
+	return new Proxy(target, {
+		get(_target, key) {
+			if (typeof key === "symbol") return void 0;
+			if (key === "then") return void 0;
+			if (key === "toString" || key === "valueOf" || key === "toJSON") return () => minter.sentinel(path);
+			if (key === "length") {
+				const sentinel = minter.sentinel([...path, "length"]);
+				const tag = options.tag + minter.index([...path, "length"]);
+				return {
+					toString: () => sentinel,
+					valueOf: () => tag
+				};
+			}
+			if (key === "map") return (visit) => Array.from({ length: options.rows ?? 0 }, (_unused, index) => visit(holeProxy(minter, [...path, "[]"], options), index));
+			if (/^\d+$/.test(String(key))) return holeProxy(minter, [...path, "[]"], options);
+			return holeProxy(minter, [...path, String(key)], options);
+		},
+		has() {
+			return true;
+		}
+	});
+}
+async function renderForcedArm(page, rows, tag) {
+	const minter = createHoleMinter();
+	return {
+		output: await renderSsrOutput(page, void 0, { prerenderSettle: { graph: { read: () => ({
+			status: "fulfilled",
+			version: 1,
+			key: null,
+			value: holeProxy(minter, [], {
+				rows,
+				tag
+			})
+		}) } } }),
+		minter
+	};
+}
+async function deriveArmFillPlan(page, context = {}) {
+	try {
+		return buildArmFillEmission(await Promise.all(PROBE_TAGS.map(async (tag) => ({
+			two: await renderForcedArm(page, 2, tag),
+			one: await renderForcedArm(page, 1, tag),
+			none: await renderForcedArm(page, null, tag)
+		}))), context);
+	} catch (error) {
+		if (process.env.MARKLESS_ARM_PLAN_DEBUG) throw error;
+		return;
+	}
+}
+function buildArmFillEmission(probes, context = {}) {
+	return planArmEmission(probes, context).emission;
+}
+function planArmEmission(probes, context = {}) {
+	const first = probes[0];
+	if (!first) return { skipped: [] };
+	const boundaryIds = (first.one.output.structure?.anchors ?? []).filter((anchor) => anchor.kind === "async").map((anchor) => anchor.id);
+	const skipped = [];
+	const plans = [];
+	const markup = [];
+	const bounds = {};
+	const initials = {};
+	for (const id of boundaryIds) {
+		const [primary, ...rest] = probes.map((probe, index) => {
+			try {
+				return buildBoundary(probe, probes[(index + 1) % probes.length], id);
+			} catch (error) {
+				skipped.push({
+					id,
+					reason: error instanceof ArmPlanUnsupported ? error.message : "render failed"
+				});
+				return;
+			}
+		});
+		if (!primary) continue;
+		if (rest.some((other) => !other || other.markup !== primary.markup)) {
+			skipped.push({
+				id,
+				reason: "probe-dependent residue survived in the template"
+			});
+			continue;
+		}
+		if (rest.some((other) => JSON.stringify(other.plan) !== JSON.stringify(primary.plan))) {
+			skipped.push({
+				id,
+				reason: "probe-dependent plan"
+			});
+			continue;
+		}
+		const initial = initialScalarsFor(primary.plan, context.state);
+		const bound = context.bound?.[id];
+		if (!initial) {
+			skipped.push({
+				id,
+				reason: "derived argument is not a build-known scalar"
+			});
+			continue;
+		}
+		if (derivedSymbolIds(primary.plan).some((symbolId) => !bound?.[symbolId])) {
+			skipped.push({
+				id,
+				reason: "derived symbol has no bound-symbol descriptor"
+			});
+			continue;
+		}
+		for (const [node, value] of Object.entries(initial)) initials[node] = value;
+		if (bound) bounds[id] = bound;
+		plans.push({
+			...primary.plan,
+			...runnerSnapshot(primary.plan.node, context.state)
+		});
+		markup.push(primary.markup);
+	}
+	if (plans.length === 0) return { skipped };
+	const plan = {
+		version: 1,
+		boundaries: plans,
+		...Object.keys(bounds).length > 0 ? { bound: bounds } : {},
+		...Object.keys(initials).length > 0 ? { initial: initials } : {}
+	};
+	const planJson = JSON.stringify(plan);
+	const templateHtml = markup.join("");
+	const planScript = `<script type="markless/fill-plan">${planJson.replace(/<\/script/gi, "<\\/script")}<\/script>`;
+	return {
+		emission: {
+			html: `${templateHtml}${planScript}`,
+			planBytes: Buffer.byteLength(planScript, "utf8"),
+			templateBytes: Buffer.byteLength(templateHtml, "utf8"),
+			plan,
+			skipped
+		},
+		skipped
+	};
+}
+function runnerSnapshot(node, state) {
+	const snapshot = (state?.computed)?.find((entry) => entry.graphNodeId === node)?.snapshot;
+	if (!snapshot) return {};
+	return {
+		..."key" in snapshot ? { key: snapshot.key } : {},
+		...typeof snapshot.version === "number" ? { version: snapshot.version } : {}
+	};
+}
+function derivedSymbolIds(plan) {
+	return [
+		...plan.holes,
+		...plan.repeat?.holes ?? [],
+		...plan.repeat?.emptyHoles ?? []
+	].flatMap((hole) => Array.isArray(hole.from) ? [] : [hole.from.symbolId]);
+}
+/**
+* The scalar cells a derived hole reads besides the settled value. Returns
+* undefined when any of them is not a build-known scalar, which fails the whole
+* boundary closed: an unresolvable argument would fill the hole from nothing.
+*/
+function initialScalarsFor(plan, state) {
+	const cells = state?.cells;
+	const wanted = new Set([
+		...plan.holes,
+		...plan.repeat?.holes ?? [],
+		...plan.repeat?.emptyHoles ?? []
+	].flatMap((hole) => Array.isArray(hole.from) ? [] : hole.from.args ?? []).map((argument) => argument.node).filter((node) => node !== plan.node));
+	const initial = {};
+	for (const node of wanted) {
+		const envelope = (cells?.find((candidate) => candidate.graphNodeId === node))?.value;
+		if (!envelope || (envelope.records?.length ?? 0) > 0) return void 0;
+		const root = envelope.root;
+		if (root !== null && ![
+			"string",
+			"number",
+			"boolean"
+		].includes(typeof root)) return void 0;
+		initial[node] = root;
+	}
+	return initial;
+}
+function artifactSettleBound(page) {
+	return typeof page === "object" ? page.prerenderBoot?.settle?.bound : void 0;
+}
+function boundaryRecords(output, boundaryId) {
+	const view = output.view;
+	const state = output.state;
+	const boundary = (view?.asyncBoundaries ?? []).find((entry) => entry.id === boundaryId);
+	if (!boundary) unsupported(`boundary records missing: ${boundaryId}`);
+	const armRecords = boundary.armRecords;
+	if (!armRecords || Array.isArray(armRecords)) unsupported(`boundary is not composed-settled: ${boundaryId}`);
+	const armLocatorIndex = /* @__PURE__ */ new Map();
+	for (const locator of armRecords.locators ?? []) if (!armLocatorIndex.has(locator.hostNodeId)) armLocatorIndex.set(locator.hostNodeId, locator.index);
+	const pageUpdates = (view?.domUpdates ?? []).filter((update) => armLocatorIndex.has(update.hostNodeId));
+	return {
+		runnerGraphNodeId: boundary.runnerGraphNodeId,
+		armLocatorIndex,
+		domUpdates: [...pageUpdates, ...armRecords.domUpdates ?? []],
+		keyedRepeats: armRecords.keyedRepeats ?? [],
+		branches: armRecords.branches ?? [],
+		computedByNode: new Map((state?.computed ?? []).map((entry) => [entry.graphNodeId, entry]))
+	};
+}
+function armHtml(output, boundaryId) {
+	const anchor = (output.structure?.anchors ?? []).find((candidate) => candidate.kind === "async" && candidate.id === boundaryId);
+	if (!anchor) unsupported(`arm markup missing: ${boundaryId}`);
+	return anchor.html;
+}
+function buildBoundary(probe, sibling, boundaryId) {
+	const records = boundaryRecords(probe.one.output, boundaryId);
+	if (records.branches.length > 0) unsupported(`arm structure depends on data (branch in arm): ${boundaryId}`);
+	if (records.keyedRepeats.length > 1) unsupported("more than one repeat in the arm");
+	const htmlTwo = armHtml(probe.two.output, boundaryId);
+	const htmlOne = armHtml(probe.one.output, boundaryId);
+	const htmlNone = armHtml(probe.none.output, boundaryId);
+	const repeat = records.keyedRepeats[0];
+	const parts = repeat ? reconstruct(htmlTwo, htmlOne, htmlNone, Number(repeat.rowElementCount ?? 0)) : {
+		prefix: htmlOne,
+		row: "",
+		suffix: "",
+		empty: ""
+	};
+	if (!repeat && (htmlTwo !== htmlOne || htmlNone !== htmlOne)) unsupported("arm markup varies by row count without a repeat record");
+	const derived = derivedHoleSites(probe, sibling, boundaryId, records, parts);
+	const counter = { next: 0 };
+	const armHoles = [];
+	const prefix = substituteHoles(parts.prefix, probe.one.minter, armHoles, counter, derived, 0);
+	const rowAnchorCoordinate = repeat ? counter.next++ : -1;
+	const suffix = substituteHoles(parts.suffix, probe.one.minter, armHoles, counter, derived, parts.prefix.length + parts.row.length);
+	const rowHoles = [];
+	const row = repeat ? substituteHoles(parts.row, probe.one.minter, rowHoles, counter, [], -1) : "";
+	const emptyHoles = [];
+	const empty = repeat ? substituteHoles(parts.empty, probe.one.minter, emptyHoles, counter, [], -1) : "";
+	const collectionPath = repeat ? repeat.collectionPath ?? [] : [];
+	if (repeat && repeat.collectionGraphNodeId !== records.runnerGraphNodeId) unsupported("repeat collection is not the settled value");
+	for (const hole of rowHoles) rebaseRowHole(hole, collectionPath);
+	assertCoverage(records, [
+		...armHoles,
+		...rowHoles,
+		...emptyHoles
+	], repeat);
+	const plan = {
+		id: boundaryId,
+		arm: "try",
+		node: records.runnerGraphNodeId,
+		holes: armHoles,
+		...repeat ? { repeat: {
+			id: String(repeat.id),
+			coordinate: rowAnchorCoordinate,
+			from: collectionPath,
+			holes: rowHoles,
+			emptyHoles
+		} } : {}
+	};
+	const escaped = `${escapeArmId(boundaryId)}`;
+	const markup = [
+		`<template m:arm="${escaped}">${prefix}${repeat ? holeAnchor(rowAnchorCoordinate) : ""}${suffix}</template>`,
+		repeat ? `<template m:row="${escaped}">${row}</template>` : "",
+		repeat ? `<template m:empty="${escaped}">${empty}</template>` : ""
+	].join("");
+	if (markup.includes(SENTINEL_OPEN)) unsupported("sentinel leaked into emitted markup");
+	return {
+		plan,
+		markup
+	};
+}
+function escapeArmId(value) {
+	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function holeAnchor(coordinate) {
+	return `<!--mh:${coordinate}-->`;
+}
+function reconstruct(htmlTwo, htmlOne, htmlNone, rowElementCount) {
+	const rowLength = htmlTwo.length - htmlOne.length;
+	if (rowLength <= 0) unsupported("two-row markup is not longer than one-row markup");
+	const candidates = [];
+	for (let split = 0; split + rowLength <= htmlOne.length; split++) {
+		const prefix = htmlOne.slice(0, split);
+		const row = htmlOne.slice(split, split + rowLength);
+		const suffix = htmlOne.slice(split + rowLength);
+		if (`${prefix}${row}${row}${suffix}` !== htmlTwo) continue;
+		if (!row.startsWith("<")) continue;
+		if ((row.match(/<[A-Za-z]/g) ?? []).length !== rowElementCount) continue;
+		candidates.push({
+			prefix,
+			row,
+			suffix
+		});
+	}
+	if (candidates.length !== 1) unsupported(`row reconstruction is not unique (${candidates.length} splits)`);
+	const { prefix, row, suffix } = candidates[0];
+	if (!htmlNone.startsWith(prefix) || !htmlNone.endsWith(suffix)) unsupported("empty markup does not share the reconstructed prefix and suffix");
+	return {
+		prefix,
+		row,
+		suffix,
+		empty: htmlNone.slice(prefix.length, htmlNone.length - suffix.length)
+	};
+}
+function derivedHoleSites(probe, sibling, boundaryId, records, parts) {
+	const derivedUpdates = records.domUpdates.filter((update) => {
+		return !!records.computedByNode.get(update.graphNodeId)?.deriveSymbolId;
+	});
+	if (derivedUpdates.length === 0) return [];
+	if (derivedUpdates.length > 1) unsupported("more than one derived residue in the arm");
+	const update = derivedUpdates[0];
+	const computed = records.computedByNode.get(update.graphNodeId);
+	const other = armHtml(sibling.one.output, boundaryId);
+	const html = armHtml(probe.one.output, boundaryId);
+	if (html === other) unsupported("derived residue did not move between probes");
+	let head = 0;
+	while (head < html.length && html[head] === other[head]) head++;
+	let tail = 0;
+	while (tail < html.length - head && tail < other.length - head && html[html.length - 1 - tail] === other[other.length - 1 - tail]) tail++;
+	const region = expandRegion(html, head, html.length - tail);
+	const ordinal = elementOrdinalAt(html, region.start);
+	const expected = records.armLocatorIndex.get(update.hostNodeId);
+	if (expected === void 0 || expected !== ordinal) unsupported("derived residue is not inside its recorded host element");
+	const target = update.target ?? {};
+	if (target.kind !== "text") unsupported(`derived residue target is not expressible: ${String(target.kind)}`);
+	const prefixText = String(target.prefix ?? "");
+	if (!html.slice(region.start, region.end).startsWith(prefixText)) unsupported("derived text residue does not follow its recorded prefix");
+	const start = region.start + prefixText.length;
+	if (start >= parts.prefix.length && start < parts.prefix.length + parts.row.length) unsupported("derived residue lands inside a repeat row");
+	return [{
+		start,
+		end: region.end,
+		hole: {
+			kind: "text",
+			from: {
+				symbolId: String(computed.deriveSymbolId),
+				args: (computed.dependencies ?? []).map((dependency) => ({
+					node: String(dependency.graphNodeId),
+					path: dependency.path ?? []
+				}))
+			}
+		}
+	}];
+}
+function expandRegion(html, start, end) {
+	let left = start;
+	while (left > 0 && html[left - 1] !== ">" && html[left - 1] !== "\"") left--;
+	let right = end;
+	while (right < html.length && html[right] !== "<" && html[right] !== "\"") right++;
+	if (html[left - 1] === "\"") {
+		const name = /([A-Za-z_:][-A-Za-z0-9_:.]*)="$/.exec(html.slice(0, left))?.[1];
+		if (!name) unsupported("attribute residue has no attribute name");
+		return {
+			start: left,
+			end: right,
+			attributeName: name
+		};
+	}
+	return {
+		start: left,
+		end: right
+	};
+}
+function elementOrdinalAt(html, index) {
+	return (html.slice(0, index).match(/<[A-Za-z]/g) ?? []).length - 1;
+}
+function substituteHoles(source, minter, holes, counter, derived, offset) {
+	SENTINEL_PATTERN.lastIndex = 0;
+	const sites = [];
+	for (const match of source.matchAll(SENTINEL_PATTERN)) {
+		const index = match.index;
+		const path = minter.paths[Number(match[1])];
+		if (!path) unsupported("unknown sentinel");
+		const attribute = /([A-Za-z_:][-A-Za-z0-9_:.]*)="$/.exec(source.slice(0, index))?.[1];
+		sites.push({
+			start: index,
+			end: index + match[0].length,
+			hole: {
+				kind: attribute ? "attribute" : "text",
+				...attribute ? { name: attribute } : {},
+				from: path
+			}
+		});
+	}
+	for (const site of derived) {
+		if (offset < 0) continue;
+		const start = site.start - offset;
+		const end = site.end - offset;
+		if (start < 0 || end > source.length) continue;
+		sites.push({
+			start,
+			end,
+			hole: site.hole
+		});
+	}
+	sites.sort((left, right) => left.start - right.start);
+	let result = "";
+	let cursor = 0;
+	for (const site of sites) {
+		const coordinate = counter.next++;
+		holes.push({
+			...site.hole,
+			coordinate
+		});
+		if (site.hole.kind === "attribute") {
+			const elementStart = source.lastIndexOf("<", site.start);
+			if (elementStart < cursor) unsupported("attribute hole outside the working segment");
+			result += `${source.slice(cursor, elementStart)}${holeAnchor(coordinate)}${source.slice(elementStart, site.start)}`;
+		} else result += `${source.slice(cursor, site.start)}${holeAnchor(coordinate)}`;
+		cursor = site.end;
+	}
+	return `${result}${source.slice(cursor)}`;
+}
+function rebaseRowHole(hole, collectionPath) {
+	if (!Array.isArray(hole.from)) unsupported("derived residue inside a repeat row");
+	const path = hole.from;
+	const marker = [...collectionPath, "[]"];
+	for (let index = 0; index < marker.length; index++) if (path[index] !== marker[index]) unsupported("row hole is not item-relative");
+	hole.from = path.slice(marker.length);
+}
+function assertCoverage(records, holes, repeat) {
+	const pathHoles = new Set(holes.filter((hole) => Array.isArray(hole.from)).map((hole) => hole.from.join(".")));
+	const derivedHoles = new Set(holes.filter((hole) => !Array.isArray(hole.from)).map((hole) => hole.from.symbolId));
+	for (const update of records.domUpdates) {
+		const computed = records.computedByNode.get(update.graphNodeId);
+		if (computed?.deriveSymbolId) {
+			if (!derivedHoles.has(String(computed.deriveSymbolId))) unsupported(`derived residue without a hole: ${update.graphNodeId}`);
+			continue;
+		}
+		if (update.graphNodeId !== records.runnerGraphNodeId) continue;
+		const path = update.path ?? [];
+		if (!pathHoles.has(path.join(".")) && !pathHoles.has(path.slice(-1).join("."))) unsupported(`settled residue without a hole: ${update.source}`);
+	}
+	if (repeat && !repeat.collectionPath) unsupported("repeat without a collection path");
+}
+async function withBuiltPrerenderPage(input, read) {
+	const temporaryDirectory = await mkdtemp(join(tmpdir(), "markless-prerender-"));
+	try {
+		const { rolldown } = await import("rolldown");
+		const build = await rolldown({
+			input: { prerender: input.entry },
+			plugins: [input.serverPlugin]
+		});
+		await build.write({
+			dir: temporaryDirectory,
+			format: "esm",
+			entryFileNames: "[name].js",
+			chunkFileNames: "chunk-[hash].js"
+		});
+		await build.close();
+		const built = await import(`${pathToFileURL(join(temporaryDirectory, "prerender.js")).href}?build=${Date.now()}`);
+		if (!built.default) throw new Error("MARKLESS_PRERENDER_ENTRY_MISSING");
+		return await read(built.default);
+	} finally {
+		await rm(temporaryDirectory, {
+			force: true,
+			recursive: true
+		});
+	}
+}
+//#endregion
 //#region src/vite/dev-tags.ts
 function createDevTags() {
 	const tags = [];
@@ -31,39 +938,6 @@ function headScript(base, src) {
 	};
 }
 //#endregion
-//#region src/vite/environment.ts
-const UNMANAGED_VITE_ENVIRONMENTS = new Set(["nitro"]);
-function viteEnvironmentName(environment, options = {}) {
-	if (environment === "client") return options.clientEnvironment ?? "client";
-	if (environment === "server") return options.serverEnvironment ?? "ssr";
-	return environment;
-}
-function marklessEnvironment(environment) {
-	const config = environment?.config;
-	if (isUnmanagedViteEnvironment(environment)) return "lib";
-	if (!config) return "client";
-	if (config.build?.lib) return "lib";
-	if (isServerViteEnvironment(environment)) return "server";
-	return "client";
-}
-function isServerViteEnvironment(environment) {
-	if (isUnmanagedViteEnvironment(environment)) return false;
-	const consumer = environment?.config?.consumer;
-	if (consumer) return consumer === "server";
-	return environment?.name !== void 0 && environment.name !== "client";
-}
-function isUnmanagedViteEnvironment(environment) {
-	return !!environment?.name && UNMANAGED_VITE_ENVIRONMENTS.has(environment.name);
-}
-function transformMarklessRequest(server, url, environment, options) {
-	return server.environments[viteEnvironmentName(environment, options)]?.transformRequest(url);
-}
-function fetchableDevEnvironment(environment) {
-	if (!environment) return;
-	const maybeFetchable = environment;
-	if (typeof maybeFetchable.dispatchFetch === "function") return maybeFetchable;
-}
-//#endregion
 //#region src/dev-error/client-asset.ts
 function createDevErrorClientAsset(viteClientUrl) {
 	const base = viteClientUrl.endsWith("/@vite/client") ? viteClientUrl.slice(0, -13) : "";
@@ -147,15 +1021,112 @@ if (window.__MARKLESS_DEV_ERROR__) show(window.__MARKLESS_DEV_ERROR__);
 `;
 }
 //#endregion
+//#region src/vite/environment.ts
+const UNMANAGED_VITE_ENVIRONMENTS = new Set(["nitro"]);
+function viteEnvironmentName(environment, options = {}) {
+	if (environment === "client") return options.clientEnvironment ?? "client";
+	if (environment === "server") return options.serverEnvironment ?? "ssr";
+	return environment;
+}
+function marklessEnvironment(environment) {
+	const config = environment?.config;
+	if (isUnmanagedViteEnvironment(environment)) return "lib";
+	if (!config) return "client";
+	if (config.build?.lib) return "lib";
+	if (isServerViteEnvironment(environment)) return "server";
+	return "client";
+}
+function isServerViteEnvironment(environment) {
+	if (isUnmanagedViteEnvironment(environment)) return false;
+	const consumer = environment?.config?.consumer;
+	if (consumer) return consumer === "server";
+	return environment?.name !== void 0 && environment.name !== "client";
+}
+function isUnmanagedViteEnvironment(environment) {
+	return !!environment?.name && UNMANAGED_VITE_ENVIRONMENTS.has(environment.name);
+}
+function transformMarklessRequest(server, url, environment, options) {
+	return server.environments[viteEnvironmentName(environment, options)]?.transformRequest(url);
+}
+function hasInProcessModuleRunner(environment) {
+	return !!environment && isRunnableDevEnvironment(environment);
+}
+function fetchableDevEnvironment(environment) {
+	if (!environment) return;
+	const maybeFetchable = environment;
+	if (typeof maybeFetchable.dispatchFetch === "function") return maybeFetchable;
+}
+//#endregion
 //#region src/vite/hmr.ts
 const SOURCE_FILE_EXTENSION = /\.tsrx(?:[?#].*)?$/;
 const RESOLVED_DEV_ERROR_CLIENT_ID = `\0${MARKLESS_DEV_ERROR_CLIENT_ID}`;
+const VITE_ID_PREFIX = "/@id/";
+const VITE_NULL_BYTE = "__x00__";
 function createViteHmr(options) {
 	let server;
 	const invalidSources = /* @__PURE__ */ new Set();
 	let invalidSourceRecheck;
 	let recheckingInvalidSources = false;
 	const preflightByFile = /* @__PURE__ */ new Map();
+	const unreportedInvalidations = /* @__PURE__ */ new Map();
+	let hotUpdatePasses = 0;
+	let hotUpdateCycle;
+	function beginHotUpdatePass() {
+		hotUpdatePasses += 1;
+		if (hotUpdateCycle) return;
+		let finish;
+		hotUpdateCycle = {
+			settled: new Promise((resolve) => {
+				finish = resolve;
+			}),
+			finish
+		};
+	}
+	function endHotUpdatePass() {
+		hotUpdatePasses -= 1;
+		if (hotUpdatePasses > 0) return;
+		const cycle = hotUpdateCycle;
+		hotUpdateCycle = void 0;
+		cycle?.finish();
+	}
+	function settledHotUpdate() {
+		if (process.env.MARKLESS_NO_BARRIER) return void 0;
+		return hotUpdateCycle?.settled;
+	}
+	function recordUnreportedInvalidation(environment, modules) {
+		const pending = unreportedInvalidations.get(environment.name);
+		if (!pending) return;
+		for (const module of modules) if (module.id) pending.add(module.id);
+	}
+	function installRunnerInvalidationGate(nextServer) {
+		for (const [name, environment] of Object.entries(nextServer.environments ?? {})) {
+			if (name === options.clientEnvironment || hasInProcessModuleRunner(environment)) continue;
+			const fetchModule = typeof environment.fetchModule === "function" ? environment.fetchModule.bind(environment) : void 0;
+			if (!fetchModule) continue;
+			unreportedInvalidations.set(name, /* @__PURE__ */ new Set());
+			environment.fetchModule = async (id, importer, fetchOptions) => {
+				const pending = unreportedInvalidations.get(name);
+				const module = pending?.size ? await fetchedModuleNode(environment, id) : void 0;
+				if (!module?.id || !pending?.delete(module.id)) return fetchModule(id, importer, fetchOptions);
+				environment.moduleGraph.invalidateModule(module, /* @__PURE__ */ new Set(), Date.now(), true, true);
+				return fetchModule(id, importer, {
+					...fetchOptions,
+					cached: false
+				});
+			};
+		}
+	}
+	function installServerRenderBarrier(nextServer) {
+		for (const environment of Object.values(nextServer.environments ?? {})) {
+			const fetchEnv = fetchableDevEnvironment(environment);
+			if (!fetchEnv) continue;
+			const dispatchFetch = fetchEnv.dispatchFetch.bind(fetchEnv);
+			fetchEnv.dispatchFetch = async (request) => {
+				await settledHotUpdate();
+				return dispatchFetch(request);
+			};
+		}
+	}
 	function preflight(sourceId, source) {
 		const cached = preflightByFile.get(sourceId);
 		if (cached?.source === source) return cached.verdict;
@@ -185,7 +1156,7 @@ function createViteHmr(options) {
 		invalidSourceRecheck = void 0;
 	}
 	function addInvalidSource(id) {
-		if (!isAbsolute(id) || !SOURCE_FILE_EXTENSION.test(id)) return;
+		if (!isAbsolute$1(id) || !SOURCE_FILE_EXTENSION.test(id)) return;
 		invalidSources.add(id);
 		startInvalidSourceRecheck();
 	}
@@ -242,6 +1213,8 @@ function createViteHmr(options) {
 	return {
 		configureServer(nextServer) {
 			server = nextServer;
+			installRunnerInvalidationGate(nextServer);
+			installServerRenderBarrier(nextServer);
 			nextServer.httpServer?.once("close", cleanup);
 			nextServer.watcher?.once?.("close", cleanup);
 			if (options.enabled) installFetchViteClient(nextServer, options);
@@ -265,65 +1238,104 @@ function createViteHmr(options) {
 			});
 		},
 		async hotUpdate(environment, ctx) {
-			if (!environment) return;
-			const env = marklessEnvironment(environment);
-			if (env === "lib") return;
-			const hot = clientHot(server, options, environment);
-			if (!hot?.send) return;
-			if (!options.enabled) {
-				hot.send({ type: "full-reload" });
-				return [];
-			}
-			const files = changedFiles(ctx.modules ?? []);
-			const root = server?.config?.root;
-			if (ctx.file && SOURCE_FILE_EXTENSION.test(ctx.file)) {
-				const prefix = root && `${root}/`;
-				files.add(prefix && ctx.file.startsWith(prefix) ? `/${ctx.file.slice(prefix.length)}` : ctx.file);
+			beginHotUpdatePass();
+			try {
+				return await runHotUpdate(environment, ctx);
+			} finally {
+				endHotUpdatePass();
 			}
-			if (!files.size) return;
-			let sendMessages = true;
-			if (ctx.file && SOURCE_FILE_EXTENSION.test(ctx.file) && ctx.read) {
-				const sourceId = parsePath(ctx.file).pathname;
-				let editedSource;
-				try {
-					editedSource = await ctx.read();
-				} catch {}
-				if (editedSource !== void 0) {
-					const verdict = await preflight(sourceId, editedSource);
-					sendMessages = !verdict.messagesSent;
-					verdict.messagesSent = true;
-					if (verdict.error) {
-						if (sendMessages) {
-							addInvalidSource(verdict.error.id);
-							hot.send({
-								type: "custom",
-								event: MARKLESS_DEV_ERROR_EVENT,
-								data: verdict.error
-							});
-						}
-						return [];
+		}
+	};
+	async function runHotUpdate(environment, ctx) {
+		if (!environment) return;
+		const env = marklessEnvironment(environment);
+		if (env === "lib") return;
+		const hot = clientHot(server, options, environment);
+		if (!hot?.send) return;
+		const targets = invalidationTargets(server, options, environment, env);
+		const runnerHots = moduleRunnerHots(targets, hot);
+		const reloadModuleRunner = () => {
+			for (const runnerHot of runnerHots) runnerHot.send?.({ type: "full-reload" });
+		};
+		if (!options.enabled) {
+			hot.send({ type: "full-reload" });
+			reloadModuleRunner();
+			return [];
+		}
+		const files = changedFiles(ctx.modules ?? []);
+		const root = server?.config?.root;
+		if (ctx.file && SOURCE_FILE_EXTENSION.test(ctx.file)) {
+			const prefix = root && `${root}/`;
+			files.add(prefix && ctx.file.startsWith(prefix) ? `/${ctx.file.slice(prefix.length)}` : ctx.file);
+		}
+		if (!files.size) return;
+		let sendMessages = true;
+		let editedSource;
+		if (ctx.file && SOURCE_FILE_EXTENSION.test(ctx.file) && ctx.read) {
+			const sourceId = parsePath(ctx.file).pathname;
+			try {
+				editedSource = await ctx.read();
+			} catch {}
+			if (editedSource !== void 0) {
+				const verdict = await preflight(sourceId, editedSource);
+				sendMessages = !verdict.messagesSent;
+				verdict.messagesSent = true;
+				if (verdict.error) {
+					if (sendMessages) {
+						addInvalidSource(verdict.error.id);
+						hot.send({
+							type: "custom",
+							event: MARKLESS_DEV_ERROR_EVENT,
+							data: verdict.error
+						});
 					}
+					return [];
 				}
-				if (editedSource !== void 0 && sendMessages && deleteInvalidSource(sourceId)) hot.send({
-					type: "custom",
-					event: MARKLESS_DEV_ERROR_CLEAR_EVENT,
-					data: { id: sourceId }
-				});
-			}
-			const invalidationEnvironments = moduleGraphEnvironments(environment, env === "server" ? server?.environments?.[options.clientEnvironment] : void 0);
-			for (const file of files) for (const candidate of hmrCandidates(file, ctx.file)) for (const id of options.invalidateGeneratedModules?.(candidate, env) ?? []) for (const targetEnvironment of invalidationEnvironments) {
-				const module = targetEnvironment.moduleGraph?.getModuleById?.(id);
-				if (!module) continue;
-				targetEnvironment.moduleGraph?.invalidateModule?.(module, /* @__PURE__ */ new Set(), ctx.timestamp, true);
 			}
-			if (sendMessages) hot.send({
-				type: "full-reload",
-				path: firstChangedFile(files),
-				triggeredBy: ctx.file
+			if (editedSource !== void 0 && sendMessages && deleteInvalidSource(sourceId)) hot.send({
+				type: "custom",
+				event: MARKLESS_DEV_ERROR_CLEAR_EVENT,
+				data: { id: sourceId }
 			});
-			return [];
 		}
-	};
+		if (!sendMessages) return [];
+		const invalidationEnvironments = [...targets.keys()];
+		const invalidationScopes = generatedModuleScopes(targets);
+		const invalidatedGeneratedIds = /* @__PURE__ */ new Set();
+		for (const file of files) {
+			const candidates = editedSource !== void 0 && ctx.file ? [ctx.file] : hmrCandidates(file, ctx.file);
+			for (const candidate of candidates) for (const scope of invalidationScopes) {
+				const invalidatedIds = await options.invalidateGeneratedModules?.(candidate, scope, candidate === ctx.file ? editedSource : void 0);
+				for (const id of invalidatedIds ?? []) {
+					invalidatedGeneratedIds.add(id);
+					for (const targetEnvironment of invalidationEnvironments) {
+						const module = targetEnvironment.moduleGraph?.getModuleById?.(id);
+						if (!module) continue;
+						const invalidated = /* @__PURE__ */ new Set();
+						targetEnvironment.moduleGraph?.invalidateModule?.(module, invalidated, ctx.timestamp, true);
+						recordUnreportedInvalidation(targetEnvironment, invalidated);
+					}
+				}
+			}
+		}
+		if (invalidatedGeneratedIds.size > 0) options.invalidatePrerenderSnapshots?.([...invalidatedGeneratedIds].sort());
+		if (ctx.file) for (const targetEnvironment of invalidationEnvironments) for (const module of targetEnvironment.moduleGraph?.getModulesByFile?.(ctx.file) ?? []) {
+			const invalidated = /* @__PURE__ */ new Set();
+			targetEnvironment.moduleGraph?.invalidateModule?.(module, invalidated, ctx.timestamp, true, true);
+			recordUnreportedInvalidation(targetEnvironment, invalidated);
+		}
+		reloadModuleRunner();
+		hot.send({
+			type: "full-reload",
+			path: firstChangedFile(files),
+			triggeredBy: ctx.file
+		});
+		return [];
+	}
+}
+async function fetchedModuleNode(environment, id) {
+	const resolved = id.startsWith(VITE_ID_PREFIX) ? id.slice(5).replace(VITE_NULL_BYTE, "\0") : id;
+	return environment.moduleGraph.getModuleById(resolved) ?? await environment.moduleGraph.getModuleByUrl(id).catch(() => void 0);
 }
 function hasErrorCode(error, code) {
 	return typeof error === "object" && error !== null && "code" in error && error.code === code;
@@ -357,7 +1369,31 @@ function injectDevClients(html, base) {
 	return `${tags}${html}`;
 }
 function clientHot(server, options, environment) {
-	return marklessEnvironment(environment) === "server" ? server?.environments?.[options.clientEnvironment]?.hot : environment?.hot;
+	if (!environment || marklessEnvironment(environment) === "server") return server?.environments?.[options.clientEnvironment]?.hot;
+	return environment.hot;
+}
+function invalidationTargets(server, options, environment, env) {
+	const targets = new Map([[environment, env]]);
+	const clientEnvironment = server?.environments?.[options.clientEnvironment];
+	if (clientEnvironment) targets.set(clientEnvironment, "client");
+	for (const [name, candidate] of Object.entries(server?.environments ?? {})) {
+		if (name === options.clientEnvironment || targets.has(candidate)) continue;
+		if (!(candidate.config?.consumer === "server" && !isServerViteEnvironment(candidate)) && marklessEnvironment(candidate) !== "server") continue;
+		targets.set(candidate, "server");
+	}
+	return targets;
+}
+function generatedModuleScopes(targets) {
+	const scopes = new Set(targets.values());
+	return ["client", "server"].filter((scope) => scopes.has(scope));
+}
+function moduleRunnerHots(targets, clientChannel) {
+	const hots = /* @__PURE__ */ new Set();
+	for (const [environment, scope] of targets) {
+		if (scope !== "server" || !environment.hot || environment.hot === clientChannel) continue;
+		hots.add(environment.hot);
+	}
+	return [...hots];
 }
 function changedFiles(modules) {
 	const files = /* @__PURE__ */ new Set();
@@ -377,14 +1413,79 @@ function hmrCandidates(file, absoluteFile) {
 	if (absoluteFile) candidates.add(absoluteFile);
 	return candidates;
 }
-function moduleGraphEnvironments(environment, clientEnvironment) {
-	if (!clientEnvironment || clientEnvironment === environment) return [environment];
-	return [environment, clientEnvironment];
-}
 function firstChangedFile(files) {
 	for (const file of files) return file;
 }
 //#endregion
+//#region src/vite/dev-prerender.ts
+const APP_PLACEHOLDER = "<div id=\"app\"></div>";
+function createDevPrerender(input) {
+	let server;
+	let runner;
+	let renderDataHashKey = "initial";
+	let snapshot;
+	const renderDataHashes = /* @__PURE__ */ new Map();
+	let invalidationGeneration = 0;
+	function updateHashes(hashes) {
+		let changed = false;
+		for (const [id, hash] of hashes) {
+			if (renderDataHashes.get(id) === hash) continue;
+			renderDataHashes.set(id, hash);
+			changed = true;
+		}
+		if (changed) updateHashKey();
+	}
+	function invalidate(renderDataIds) {
+		invalidationGeneration += 1;
+		for (const id of renderDataIds) renderDataHashes.set(id, `invalidated-${invalidationGeneration}`);
+		updateHashKey();
+	}
+	function updateHashKey() {
+		renderDataHashKey = [...renderDataHashes].sort(([left], [right]) => left.localeCompare(right)).map(([id, hash]) => `${encodeURIComponent(id)}:${hash}`).join("|");
+		snapshot = void 0;
+	}
+	async function renderSnapshot() {
+		const key = renderDataHashKey;
+		if (snapshot?.key === key) return snapshot.value;
+		const value = renderPage();
+		snapshot = {
+			key,
+			value
+		};
+		const rendered = await value;
+		return key === renderDataHashKey ? rendered : renderSnapshot();
+	}
+	async function renderPage() {
+		const environment = server?.environments[input.serverEnvironment];
+		if (!environment) throw new Error(`MARKLESS_DEV_PRERENDER_ENVIRONMENT_MISSING: ${input.serverEnvironment}`);
+		runner ??= createServerModuleRunner(environment);
+		const built = await runner.import(input.entry);
+		if (!built.default) throw new Error("MARKLESS_PRERENDER_ENTRY_MISSING");
+		const output = await evaluateBuiltPageClosure(built.default);
+		return assemblePrerenderPageParts(built.default, output, {});
+	}
+	return {
+		invalidate,
+		updateHashes,
+		async renderHtml(html) {
+			try {
+				if (!html.includes(APP_PLACEHOLDER)) throw new Error("MARKLESS_PRERENDER_CONTAINER_MISSING: expected exact #app dev placeholder");
+				const page = await renderSnapshot();
+				return (page.head ? html.replace("</head>", `${page.head}</head>`) : html).replace(APP_PLACEHOLDER, page.container);
+			} catch (error) {
+				const environment = server?.environments[input.serverEnvironment];
+				input.reportError(environment, error);
+				return injectDevClients(renderMarklessDevErrorDocument(normalizeMarklessDevError(error, { id: input.entry }), { base: input.base }), input.base);
+			}
+		},
+		configureServer(nextServer) {
+			server = nextServer;
+			nextServer.httpServer?.once("close", () => void runner?.close());
+			nextServer.watcher?.once?.("close", () => void runner?.close());
+		}
+	};
+}
+//#endregion
 //#region src/vite/index.ts
 const MARKLESS_SKIP_DUPLICATE_BUILDS = Symbol("markless-skip-duplicate-builds");
 const TSRX_INPUT_FILE = /\.tsrx(?:[?#].*)?$/;
@@ -392,19 +1493,33 @@ function markless(options = {}) {
 	let command = "build";
 	const bundleGraphAdders = /* @__PURE__ */ new Set();
 	const transformedTsrxSources = /* @__PURE__ */ new Map();
+	const prerenderRecordsBySource = /* @__PURE__ */ new Map();
 	const rolldownOptions = { ...options };
+	const prerender = process.env.MARKLESS_PRERENDER === "1";
+	const explicitPrerenderWake = process.env.MARKLESS_PRERENDER_WAKE;
+	rolldownOptions.prerender = false;
+	rolldownOptions.prerenderWakeChannel = prerender ? explicitPrerenderWake !== "0" : explicitPrerenderWake === "1";
+	const stagePrerenderWake = rolldownOptions.prerenderWakeChannel;
+	rolldownOptions.productionResumeModuleUrls = /* @__PURE__ */ new Map();
+	rolldownOptions.productionPrerenderWakeModuleUrls = /* @__PURE__ */ new Map();
+	let prerenderEntry = null;
+	let resolvedRoot = "";
+	let clientOutDir = "dist";
 	rolldownOptions.bundleGraphAdders = bundleGraphAdders;
 	const hmrOptions = {
 		base: "/",
 		clientEnvironment: viteEnvironmentName("client", options),
 		enabled: false,
-		invalidateGeneratedModules: (parent, environment) => marklessPlugin.api.invalidateGeneratedModules(parent, environment)
+		invalidateGeneratedModules: (parent, environment, nextSource) => marklessPlugin.api.invalidateGeneratedModules(parent, environment, nextSource),
+		invalidatePrerenderSnapshots: void 0
 	};
+	let devPrerender;
 	const devTags = createDevTags();
 	rolldownOptions.devInjections = devTags.tags;
 	const basePlugin = createMarklessRolldownPlugin({
 		environment: getBuildEnvironment,
-		options: rolldownOptions
+		options: rolldownOptions,
+		prerenderRecordsBySource
 	});
 	const hmr = createViteHmr(hmrOptions);
 	const marklessPlugin = {
@@ -436,15 +1551,33 @@ function markless(options = {}) {
 				__MARKLESS_DEV_ENABLED__: devDefine
 			};
 			configDefaults(config, options, rolldownOptions);
+			if (prerender || stagePrerenderWake) {
+				prerenderEntry = ssrTsrxInput(config, options);
+				rolldownOptions.prerender = prerender && prerenderEntry !== null;
+			}
 		},
 		configResolved(resolvedConfig) {
+			resolvedRoot = resolvedConfig.root;
+			clientOutDir = resolvedConfig.build?.outDir ?? "dist";
 			const serve = resolvedConfig.command === "serve";
 			hmrOptions.base = resolvedConfig.base;
 			hmrOptions.enabled = serve && options.hmr !== false;
 			rolldownOptions.dev = serve;
 			rolldownOptions.rootDir = resolvedConfig.root;
 			rolldownOptions.publicPath = (fileName) => joinURL(resolvedConfig.base, fileName);
-			if (serve) devTags.registerViteTags(resolvedConfig.base);
+			if (serve) {
+				devTags.registerViteTags(resolvedConfig.base);
+				if (prerender && prerenderEntry) {
+					devPrerender = createDevPrerender({
+						base: resolvedConfig.base,
+						entry: resolve(resolvedConfig.root, prerenderEntry),
+						serverEnvironment: viteEnvironmentName("server", options),
+						reportError: (environment, error) => hmr.reportError(environment, error)
+					});
+					rolldownOptions.updateDevPrerenderHashes = devPrerender.updateHashes;
+					hmrOptions.invalidatePrerenderSnapshots = devPrerender.invalidate;
+				}
+			}
 		},
 		configEnvironment(name, config) {
 			if (command === "serve") return;
@@ -465,26 +1598,72 @@ function markless(options = {}) {
 		},
 		buildApp: {
 			order: "pre",
-			handler(builder) {
-				return buildMarklessEnvironments(builder, options);
+			async handler(builder) {
+				if ((prerender || stagePrerenderWake) && prerenderEntry) {
+					const source = resolve(resolvedRoot, prerenderEntry);
+					prerenderRecordsBySource.set(source, await deriveBuiltPrerenderRecords({
+						entry: source,
+						serverPlugin: createMarklessRolldownPlugin({
+							environment: "server",
+							options: {
+								...rolldownOptions,
+								rootDir: resolvedRoot,
+								dev: false
+							}
+						})
+					}));
+				}
+				await buildMarklessEnvironments(builder, options);
+				if (prerender && prerenderEntry) {
+					const source = resolve(resolvedRoot, prerenderEntry);
+					const clientEnvironment = builder.environments[viteEnvironmentName("client", options)];
+					await emitPrerenderedPage({
+						root: clientEnvironment?.config.root ?? resolvedRoot,
+						entry: resolve(resolvedRoot, prerenderEntry),
+						outDir: clientEnvironment?.config.build?.outDir ?? clientOutDir,
+						resumeModuleUrl: rolldownOptions.productionResumeModuleUrls?.get(source),
+						prerenderWakeModuleUrl: rolldownOptions.productionPrerenderWakeModuleUrls?.get(source),
+						serverPlugin: createMarklessRolldownPlugin({
+							environment: "server",
+							options: {
+								...rolldownOptions,
+								rootDir: resolvedRoot,
+								dev: false
+							}
+						})
+					});
+				}
 			}
 		},
 		configureServer(server) {
 			server.config.logger?.info("markless diagnostics available - window.__MARKLESS_DEBUG__ records containers, lifecycles, and event routing; markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package.");
-			rolldownOptions.devServer = { transformRequest: (url, environment) => transformMarklessRequest(server, url, environment, options) };
+			rolldownOptions.devServer = {
+				transformRequest: (url, environment) => transformMarklessRequest(server, url, environment, options),
+				invalidateModule: (id, environment) => {
+					const target = server.environments[viteEnvironmentName(environment, options)];
+					const module = target?.moduleGraph?.getModuleById?.(id);
+					if (!module) return false;
+					target.moduleGraph.invalidateModule(module, /* @__PURE__ */ new Set(), Date.now(), true);
+					return true;
+				}
+			};
 			hmr.configureServer(server);
+			devPrerender?.configureServer(server);
 		},
-		transformIndexHtml() {
+		transformIndexHtml(html) {
 			const hmrResult = hmr.transformIndexHtml();
 			const injection = executionLogActivationInjection(rolldownOptions.executionLog);
-			if (!injection) return hmrResult;
-			const tag = {
+			const tags = [...Array.isArray(hmrResult) ? hmrResult : [], ...injection ? [{
 				tag: injection.tag,
 				injectTo: injection.location,
 				attrs: injection.attributes,
 				children: injection.children
-			};
-			return Array.isArray(hmrResult) ? [...hmrResult, tag] : [tag];
+			}] : []];
+			if (!devPrerender) return tags.length > 0 ? tags : void 0;
+			return devPrerender.renderHtml(html).then((renderedHtml) => ({
+				html: renderedHtml,
+				tags
+			}));
 		},
 		resolveId: {
 			order: "pre",
@@ -502,7 +1681,10 @@ function markless(options = {}) {
 			try {
 				return await runHook(basePlugin.transform, this, code, id, transformOptions);
 			} catch (error) {
-				if (rolldownOptions.dev === true && TSRX_INPUT_FILE.test(id)) hmr.reportError(this.environment, error);
+				if (rolldownOptions.dev === true && TSRX_INPUT_FILE.test(id)) {
+					const environment = this.environment;
+					hmr.reportError(environment.mode === "dev" ? environment : void 0, error);
+				}
 				throw error;
 			}
 		} },
@@ -572,22 +1754,23 @@ function firstTsrxInput(input) {
 	return null;
 }
 function withSsrSymbolInput(input, ssrSymbolInput) {
+	const symbolInput = withQuery(ssrSymbolInput, { "markless-symbols": null });
 	if (isRolldownInputRecord(input)) {
 		if (Object.keys(input).some((name) => /symbol/i.test(name))) return input;
 		return {
 			...input,
-			symbols: ssrSymbolInput
+			symbols: symbolInput
 		};
 	}
 	if (typeof input === "string") {
 		const name = input.endsWith(".html") ? "index" : "app";
-		return input === ssrSymbolInput ? { symbols: ssrSymbolInput } : {
+		return input === ssrSymbolInput ? { symbols: symbolInput } : {
 			[name]: input,
-			symbols: ssrSymbolInput
+			symbols: symbolInput
 		};
 	}
-	if (Array.isArray(input)) return Object.fromEntries([...input.map((entry, index) => [`input${index}`, entry]), ["symbols", ssrSymbolInput]]);
-	return { symbols: ssrSymbolInput };
+	if (Array.isArray(input)) return Object.fromEntries([...input.map((entry, index) => [`input${index}`, entry]), ["symbols", symbolInput]]);
+	return { symbols: symbolInput };
 }
 function isRolldownInputRecord(input) {
 	return !!input && typeof input === "object" && !Array.isArray(input);