@markless/bundler 0.3.3 → 0.5.0

package/dist/vite.js

@@ -1,28 +1,67 @@
-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-CZFm1uWH.js";
-import { d as outputDefaults, o as preflightTsrxModuleDiagnostics, p as createPreloadGraphAdder, t as createMarklessRolldownPlugin } from "./rolldown-FRjFod14.js";
+import { c as renderMarklessDevErrorDocument, n as MARKLESS_DEV_ERROR_CLIENT_ID, r as MARKLESS_DEV_ERROR_EVENT, s as normalizeMarklessDevError, t as MARKLESS_DEV_ERROR_CLEAR_EVENT } from "./dev-error-DRvO28Fd.js";
+import { Et as executionLogActivationInjection, I as sharedReachedRenderDataRequest, at as STORAGE_FREE_RESUME_ENTRY_SPECIFIER, it as RESUME_ENTRY_SPECIFIER, j as pathname, nt as outputDefaults, t as MARKLESS_DEFERRED_PACK } from "./route-pack-groups-BpefyjrE.js";
+import { n as includeOptimizedDeps, t as excludeSourceShippedDeps } from "./optimized-deps-BfzxSm6C.js";
+import { A as inlineDeferSource, E as preflightTsrxModuleDiagnostics, O as INLINE_DEFER_LOADER_SOURCE, T as prefetchChunkParses, _ as createPreloadGraphAdder, a as collapseInitFacadeImports, d as nativePackingEnabled, f as nativePackingPlugins, h as withUndemandedReExportDoors, k as createInlineDeferTriggerSource, l as marklessRuntimeSpecifierId, m as undemandedRuntimeModules, o as unwrapAsyncImportWrappers, p as isReExportDoor, t as createMarklessRolldownPlugin, u as DEPRECATED_NATIVE_PACKING_WARNING, v as runtimeModuleIdFromOrigin } from "./rolldown-BciZw5hZ.js";
+import { n as marklessRosterPositions, r as marklessRosterRenderContext, t as marklessRosterPositionSeeds } from "./shared-seed-slot-ihIVCD2S.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 { ASYNC_PROTOCOL_VERSION, STORAGE_SLOT_SYMBOL_KEY, escapeScriptJson, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName, storageCookieName, storageSlotEntryKeyFromGraphNodeId } from "@markless/serializer";
+import { isAbsolute, join, resolve } from "pathe";
+import { DEBUGGING_PLAYBOOK_HINT } from "@markless/compiler";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { isAbsolute as isAbsolute$1 } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createServerModuleRunner, isRunnableDevEnvironment } from "vite";
 import { tmpdir } from "node:os";
-import { PROTOCOL_EVENT_ACTION_KIND as PROTOCOL_EVENT_ACTION_KIND$1, protocolEventDispatchesMarkless } from "@markless/serializer/protocol";
+import { PROTOCOL_EVENT_ACTION_KIND as PROTOCOL_EVENT_ACTION_KIND$1, PROTOCOL_IDLE_EVENT_NAME as PROTOCOL_IDLE_EVENT_NAME$1, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_VISIBLE_EVENT_NAME, 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/served-census.ts
+/**
+* Pins the container's elements in DOM order as its census and returns them.
+* When the count differs from the one the server measured, a script outside
+* Markless changed the page first: the root is flagged for the resume module
+* to renumber the census, and no elements are returned, so nothing is matched
+* by a shifted index.
+*/
+function marklessServedCensus(root, attribute) {
+	const live = [root];
+	const walker = document.createTreeWalker(root, 1);
+	for (let next = walker.nextNode(); next; next = walker.nextNode()) live.push(next);
+	root.__marklessCensus ||= live;
+	const value = root.getAttribute?.(attribute);
+	return value && parseInt(value) !== live.length ? (root.__marklessShifted = 1, []) : live;
+}
+//#endregion
 //#region ../web/src/inline/resumer.ts
 PROTOCOL_EVENT_ACTION_KIND$1.event, PROTOCOL_EVENT_ACTION_KIND$1.externalDelegate;
+const INLINE_MODULE_LOADER_SOURCE = INLINE_DEFER_LOADER_SOURCE;
 function createInlineResumerSelfWakeSource(resumeModuleUrl) {
-	return `;(${runInlineResumerSelfWake.toString()})(${JSON.stringify(resumeModuleUrl)});`;
+	return `;(${runInlineResumerSelfWake.toString()})(${JSON.stringify(resumeModuleUrl)},${INLINE_MODULE_LOADER_SOURCE},${inlineDeferSource()});`;
+}
+function createInlineResumerStorageWakeSource(resumeModuleUrl, slotSymbolKey, renderedJson) {
+	return `;(${runInlineResumerStorageWake.toString()})(${JSON.stringify(slotSymbolKey)},${renderedJson},()=>(${runInlineResumerSelfWake.toString()})(${JSON.stringify(resumeModuleUrl)},${INLINE_MODULE_LOADER_SOURCE},${inlineDeferSource()}));`;
+}
+function runInlineResumerStorageWake(slotSymbolKey, rendered, wake) {
+	const slot = globalThis[Symbol.for(slotSymbolKey)];
+	if (slot && rendered.some(([key, value]) => Object.hasOwn(slot, key) && slot[key] !== value)) wake();
+}
+/**
+* The Escape primer, appended only to a page whose served HTML carries an
+* `overlay` mark.
+*
+* Appended rather than composed into the resumer body for the same reason the
+* self-wake is: the body is serialized whole, so a flag inside it would put the
+* text on every page in the world to serve the few that elevate anything. A page
+* with no mark ships a byte-identical resumer.
+*/
+function createInlineResumerOverlayPrimerSource(resumeModuleUrl) {
+	return `;(${runInlineResumerOverlayPrimer.toString()})(${JSON.stringify(resumeModuleUrl)},${INLINE_MODULE_LOADER_SOURCE});`;
 }
 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 plain = `(${runPrerenderInlineResumer.toString()})(${JSON.stringify(eventNames)},${JSON.stringify(resumeModuleUrl)},u=>import(u),${marklessServedCensus.toString()},${JSON.stringify(PROTOCOL_LOCATOR_PATHS_ATTRIBUTE)});`;
 	const logging = options?.executionLog !== void 0 && options.executionLog !== "never";
 	if (!options?.debug && !logging) return plain;
 	return `{
@@ -109,111 +148,69 @@ function runPrerenderInlineResumerDebugSetup(eventNames) {
 		controls?.activate();
 	} catch {}
 }
-function runPrerenderInlineResumer(eventNames, fallbackResumeModuleUrl, loadModule) {
+function runPrerenderInlineResumer(eventNames, fallbackResumeModuleUrl, loadModule, census, pathsAttribute) {
 	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) => {
+	let loaded;
+	const dispatch = (event) => {
 		root.__marklessDelegatedDispatch = true;
-		return loadModule(resumeModuleUrl).then((module) => module.resumeContainerEvent({
+		if (!root.__marklessCensus) census(root, pathsAttribute);
+		return (loaded ||= loadModule(resumeModuleUrl)).then((module) => module.resumeContainerEvent({
 			root,
 			event,
 			element: event.target,
 			eventRecord: null
 		}));
-	}, true);
+	};
+	eventNames.map(root.__marklessListen = (eventName) => root.addEventListener(eventName, dispatch, true));
 }
-function runInlineResumerSelfWake(fallbackResumeModuleUrl) {
+function runInlineResumerSelfWake(fallbackResumeModuleUrl, loadModule, defer) {
 	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
-				});
-			}
+	defer.idle(root, async () => {
+		if (root.__asyncResumeRuntimeStarted) return;
+		root.__marklessDelegatedDispatch = true;
+		await (await loadModule(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
+function runInlineResumerOverlayPrimer(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;
+	const prime = (event) => {
+		if (root.__marklessOverlayInstalled) {
+			removeEventListener("keydown", prime, true);
+			removeEventListener("pointerdown", prime, true);
+			return;
+		}
+		if (!root.querySelector("[overlay]:not([hidden])")) return;
+		if (event.key === "Escape") root.__marklessOverlayPrimedDismissal = "escape";
+		if (root.__marklessDelegatedDispatch === true) return;
+		if (!root.__marklessCensus) {
+			const census = [root];
+			const all = root.getElementsByTagName?.("*") ?? [];
+			for (let index = 0; index < all.length; index++) census.push(all[index]);
+			root.__marklessCensus = census;
+		}
+		setTimeout(() => {
+			if (root.__marklessDelegatedDispatch === true) return;
+			root.__marklessDelegatedDispatch = true;
+			loadModule(resumeModuleUrl).then((module) => module.resumeContainerEvent({
+				root,
+				event: 0
+			}));
 		});
-		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;
+	};
+	addEventListener("keydown", prime, true);
+	addEventListener("pointerdown", prime, true);
 }
 //#endregion
 //#region ../web/src/prerender/records.ts
@@ -225,7 +222,7 @@ async function prepareSsrResumeRecords(output) {
 		computed: serializeRuntimeAsyncSnapshots(rawState.computed ?? [])
 	};
 	const view = containerScopedView(output.view ?? emptyViewPayload());
-	await validateKeyedRepeatPayloadKeys({
+	if (view.keyedRepeats?.length) await (await import("./repeat-runtime-BDnaUYXM.js")).validateKeyedRepeatPayloadKeys({
 		state,
 		view
 	});
@@ -262,6 +259,34 @@ function emptyViewPayload() {
 	};
 }
 //#endregion
+//#region ../web/src/fns/roster-position.ts
+/**
+* The server render context with the roster channels on it. One counter per
+* render, held by the closure rather than by a module, so two page renders in
+* one process never share a count.
+*/
+function marklessSsrRosterPositionContext(renderContext) {
+	const context = renderContext ?? {};
+	if (typeof context.rosterPosition === "function") return renderContext;
+	const sharedSeeds = marklessRosterPositionSeeds(context.sharedSeeds);
+	return {
+		...context,
+		sharedSeeds,
+		...marklessRosterRenderContext(marklessRosterPositions(sharedSeeds), void 0)
+	};
+}
+/**
+* The counts this render minted, answered from the page it produced. A count is
+* asked before the members it counts have rendered, so this is where it becomes
+* a number — after composition, off the served view's own roster.
+*/
+async function marklessSsrRosterCounted(renderContext, surface) {
+	if (!marklessRosterPositions((renderContext ?? {}).sharedSeeds)?.counted) return surface;
+	const roster = await globalThis.__marklessRosterResume?.();
+	if (!roster) throw new Error("MARKLESS_ROSTER_COUNT_UNRESOLVED");
+	return roster.marklessResolveRosterCounts(surface);
+}
+//#endregion
 //#region ../web/src/prerender/evaluator.ts
 async function evaluateBuiltPageClosure(page, props) {
 	const renderContext = { prerender: true };
@@ -270,7 +295,192 @@ async function evaluateBuiltPageClosure(page, props) {
 	throw new TypeError("Prerender resume requires a compiled TSRX artifact.");
 }
 //#endregion
+//#region ../web/src/resume-anchor-census.ts
+function isArmBranchAnchorComment(comment) {
+	const text = comment.data ?? comment.textContent ?? "";
+	return text.startsWith("markless:arm-branch:") || text.startsWith("/markless:arm-branch:");
+}
+//#endregion
+//#region ../serializer/src/protocol-locator-paths-format.ts
+/**
+* The value of PROTOCOL_LOCATOR_PATHS_ATTRIBUTE: the served element count in decimal, the tag
+* table joined by `,`, `|`, then for every located element and each of its ancestors, in tree
+* order, four numbers: how many levels to step up from the previous entry to reach its parent (the
+* container is 0), its DOM-order index as a delta from the previous entry, its place among the
+* parent's element children, and its tag's place in the table; then `|` and each parent's served
+* element-child count, in the order entries first name that parent. Numbers are written low five
+* bits first: a digit from the first 32 here ends a number, one from the last 32 carries.
+*/
+const PROTOCOL_LOCATOR_PATHS_DIGITS = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-";
+//#endregion
+//#region ../web/src/locator-paths.ts
+const VOID_TAGS = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"source",
+	"track",
+	"wbr"
+]);
+const RAW_TEXT_TAGS = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"textarea",
+	"title",
+	"xmp",
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript"
+]);
+const FOREIGN_ROOTS = /* @__PURE__ */ new Set(["svg", "math"]);
+function servedElementTree(html) {
+	const elements = [{
+		tag: "",
+		parent: -1,
+		child: 0
+	}];
+	const childCounts = [0];
+	const commentElementIndexes = [];
+	const nameEnds = [0];
+	const stack = [];
+	let templateDepth = 0;
+	let foreignDepth = 0;
+	let at = 0;
+	let lowerHtml;
+	while (at < html.length) {
+		const open = html.indexOf("<", at);
+		if (open < 0) break;
+		if (html.startsWith("<!--", open)) {
+			const end = html.indexOf("-->", open + 4);
+			at = end < 0 ? html.length : end + 3;
+			const data = html.slice(open + 4, end < 0 ? html.length : end);
+			if (templateDepth === 0 && !isArmBranchAnchorComment({
+				nodeType: 8,
+				data
+			})) commentElementIndexes.push(elements.length);
+			continue;
+		}
+		const next = html[open + 1] ?? "";
+		if (next === "!" || next === "?") {
+			const end = html.indexOf(">", open);
+			at = end < 0 ? html.length : end + 1;
+			continue;
+		}
+		const closing = next === "/";
+		const nameStart = closing ? open + 2 : open + 1;
+		const nameMatch = /^[a-zA-Z][^\s/>]*/.exec(html.slice(nameStart, nameStart + 64));
+		if (!nameMatch) {
+			at = open + 1;
+			continue;
+		}
+		const name = nameMatch[0];
+		const lower = name.toLowerCase();
+		const tag = foreignDepth > 0 ? name : lower;
+		const tagEnd = endOfTag(html, nameStart + nameMatch[0].length);
+		at = tagEnd + 1;
+		if (closing) {
+			const match = stack.findLastIndex((entry) => entry.tag.toLowerCase() === lower);
+			if (match < 0) continue;
+			for (const popped of stack.splice(match)) {
+				if (popped.tag.toLowerCase() === "template") templateDepth--;
+				if (FOREIGN_ROOTS.has(popped.tag.toLowerCase())) foreignDepth--;
+			}
+			continue;
+		}
+		const selfClosing = foreignDepth > 0 && html[tagEnd - 1] === "/";
+		const parent = stack.length ? stack[stack.length - 1].index : 0;
+		let index = parent;
+		if (templateDepth === 0) {
+			index = elements.push({
+				tag,
+				parent,
+				child: childCounts[parent]++
+			}) - 1;
+			childCounts.push(0);
+			nameEnds.push(nameStart + name.length);
+		}
+		if (VOID_TAGS.has(lower) || selfClosing) continue;
+		if (RAW_TEXT_TAGS.has(lower)) {
+			const close = (lowerHtml ??= html.toLowerCase()).indexOf(`</${lower}`, at);
+			at = close < 0 ? html.length : endOfTag(html, close + 2 + lower.length) + 1;
+			continue;
+		}
+		if (lower === "template") templateDepth++;
+		if (FOREIGN_ROOTS.has(lower)) foreignDepth++;
+		stack.push({
+			tag,
+			index
+		});
+	}
+	return {
+		elements,
+		childCounts,
+		commentElementIndexes,
+		nameEnds
+	};
+}
+function endOfTag(html, from) {
+	let quote = "";
+	for (let at = from; at < html.length; at++) {
+		const char = html[at];
+		if (quote) {
+			if (char === quote) quote = "";
+		} else if (char === "\"" || char === "'") quote = char;
+		else if (char === ">") return at;
+	}
+	return html.length - 1;
+}
+/**
+* The attribute value for a container whose inner html is `containerHtml`, or
+* undefined when the html holds fewer elements than the locators name.
+* One entry per located element and each of its ancestors, so every entry is
+* one step from its parent; the format is documented on PROTOCOL_LOCATOR_PATHS_DIGITS.
+*/
+function servedLocatorPaths(containerHtml, locators) {
+	if (locators.length === 0) return void 0;
+	const { elements, childCounts } = servedElementTree(containerHtml);
+	const chain = /* @__PURE__ */ new Set();
+	for (const { index } of locators) {
+		if (index >= elements.length) return void 0;
+		for (let at = index; at > 0 && !chain.has(at); at = elements[at].parent) chain.add(at);
+	}
+	if (chain.size === 0) return void 0;
+	const tags = [];
+	const parents = [];
+	const stack = [0];
+	let entries = "";
+	let previous = 0;
+	for (const index of [...chain].sort((left, right) => left - right)) {
+		const { tag, parent, child } = elements[index];
+		let up = 0;
+		while (stack[stack.length - 1] !== parent) {
+			stack.pop();
+			up++;
+		}
+		if (!tags.includes(tag)) tags.push(tag);
+		if (!parents.includes(parent)) parents.push(parent);
+		entries += pathNumber(up) + pathNumber(index - previous) + pathNumber(child) + pathNumber(tags.indexOf(tag));
+		stack.push(index);
+		previous = index;
+	}
+	return `${elements.length}${tags.join(",")}|${entries}|${parents.map((parent) => pathNumber(childCounts[parent])).join("")}`;
+}
+function pathNumber(value) {
+	let digits = "";
+	for (; value >= 32; value = Math.floor(value / 32)) digits += PROTOCOL_LOCATOR_PATHS_DIGITS[32 + value % 32];
+	return digits + PROTOCOL_LOCATOR_PATHS_DIGITS[value];
+}
+//#endregion
 //#region ../web/src/render-to-string.ts
+const MARKLESS_COMPONENT_PART_BRAND = "marklessComponentPart";
 async function assemblePrerenderPageParts(component, output, options) {
 	const { state, view } = await prepareSsrResumeRecords(output);
 	const browserTriggers = hasBrowserTriggers(view, state);
@@ -280,27 +490,57 @@ async function assemblePrerenderPageParts(component, output, options) {
 	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) : "";
+	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, false, deferredTriggerSource(view) + (selfWake ? "" : storageWakeSource(state, resumeModuleUrl)), artifactInlineResumerSources(component)?.defer) : "";
 	return {
 		head: [
 			renderStorageSeedScript(artifactStorageSeeds(component), options.nonce),
 			renderHeadInjections(artifactHeadInjections(component), options.nonce),
 			renderModulePreloadLinks(modulePreloads, options.nonce)
 		].filter(Boolean).join(""),
-		container: [
-			`<div${renderContainerAttributes(options.containerId)}>`,
+		container: renderContainer(options.containerId, [
 			output.html,
-			options.armEmission ?? "",
-			resumerScript,
-			"</div>"
-		].filter(Boolean).join("")
+			options.armEmission,
+			resumerScript
+		], resumerScript ? view.locators : [])
 	};
 }
 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);
+	assertPageRenderable(component);
+	globalThis.__marklessRosterResume ??= () => import("./roster-resume-CpphsFl_.js");
+	const context = marklessSsrRosterPositionContext(renderContext);
+	if (typeof component === "function") return marklessSsrRosterCounted(context, await marklessSsrDeferredCounted(context, await component(props, context)));
+	if (component && typeof component.renderSsr === "function") return marklessSsrRosterCounted(context, await marklessSsrDeferredCounted(context, await component.renderSsr(props, context)));
 	throw new TypeError("renderToString(App) requires a compiled TSRX artifact.");
 }
+/**
+* The count-spending expressions this render handed over unevaluated. They are
+* answered first: the placeholder resolver that runs after them only has plain
+* count reads left to replace.
+*/
+async function marklessSsrDeferredCounted(renderContext, surface) {
+	const seeds = renderContext?.sharedSeeds;
+	const deferred = marklessRosterPositions(seeds)?.deferred;
+	if (!deferred || deferred.length === 0) return surface;
+	const roster = await globalThis.__marklessRosterResume?.();
+	if (!roster) throw new Error("MARKLESS_ROSTER_COUNT_UNRESOLVED");
+	return roster.marklessResolveDeferredCounts(surface, deferred);
+}
+/**
+* Refuses a bare component part used AS A PAGE. `renderSsrOutput` is the one
+* place a surface becomes a served page - composition reaches a part through
+* `marklessSsrComponentPart` and never comes here - so the refusal costs
+* composition nothing while a part-as-page can no longer be served inert.
+*/
+function assertPageRenderable(component) {
+	const partName = componentPartName(component);
+	if (partName === void 0) return;
+	throw new Error(`MARKLESS_COMPONENT_PART_AS_PAGE: "${partName}" is published as a bare render part, not a page. A non-root export carries none of its module's page wiring (no resume module, no preloads, no head injections), so a page rendered from it is served complete and inert: no client runtime is ever fetched and no gesture can dispatch. Render "${partName}" inside a page, or make it the module's root export - the root is published merged with the module surface.`);
+}
+function componentPartName(component) {
+	if (typeof component !== "object" || component === null) return void 0;
+	const name = component[MARKLESS_COMPONENT_PART_BRAND];
+	return typeof name === "string" ? name : void 0;
+}
 function artifactResumeModuleUrl(component) {
 	return typeof component === "object" ? component.resumeModuleUrl : void 0;
 }
@@ -319,18 +559,37 @@ function artifactHeadInjections(component) {
 function artifactStorageSeeds(component) {
 	return typeof component === "object" ? component.storageSeeds : void 0;
 }
+function artifactInlineResumerSources(component) {
+	return typeof component === "object" ? component.inlineResumerSources : 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) => [
+	return `<script${nonce ? ` nonce="${escapeAttribute(nonce)}"` : ""}>${escapeInlineScript(`(()=>{const s=globalThis[Symbol.for(${JSON.stringify(STORAGE_SLOT_SYMBOL_KEY)})]||={},c=document.cookie.split('; ');for(const[k,d,a,f,n]of ${escapeScriptJson(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>`;
+		seed.fallback,
+		storageCookieName(seed.driverKey)
+	])))}){let v=f;try{const e=c.find(e=>e.startsWith(n+'='));v=e?decodeURIComponent(e.slice(n.length+1)):localStorage.getItem(d)??f}catch{}s[k]=v;document.documentElement.setAttribute(a,v)}})()`)}<\/script>`;
+}
+function storageWakeSource(state, resumeModuleUrl) {
+	const rendered = (state.storage ?? []).flatMap((record) => {
+		const value = renderedCellValue(state.cells.find((cell) => cell.graphNodeId === record.graphNodeId));
+		return value === void 0 ? [] : [[storageSlotEntryKeyFromGraphNodeId(record.graphNodeId), value]];
+	});
+	if (rendered.length === 0) return "";
+	return createInlineResumerStorageWakeSource(resumeModuleUrl, STORAGE_SLOT_SYMBOL_KEY, escapeScriptJson(JSON.stringify(rendered)));
+}
+function renderedCellValue(cell) {
+	if (typeof cell?.directValue === "string") return cell.directValue;
+	const value = cell?.value;
+	if (typeof value === "string") return value;
+	const root = value?.root;
+	return typeof root === "string" ? root : void 0;
 }
 function renderHeadInjection(injection, nonce) {
 	const attributes = { ...injection.attributes };
@@ -359,7 +618,7 @@ function renderModulePreloadLinks(preloads, nonce) {
 	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);
+	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)) || branchServedArmEventNames(branch).length > 0) || view.asyncBoundaries.some((boundary) => boundaryArmEventNames(boundary).length > 0);
 }
 function hasUnsettledAsyncBoundaryRunner(view, state) {
 	const runners = { ...view.asyncRunners };
@@ -385,19 +644,46 @@ function boundaryArmEventNames(boundary) {
 	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 branchServedArmEventNames(branch) {
+	const armRecords = branch.servedArmRecords;
+	if (!armRecords) return [];
+	return [...armRecords.events.filter(protocolEventDispatchesMarkless).map((event) => event.eventName), ...(armRecords.keyedRepeats ?? []).flatMap((repeat) => repeat.rowEvents.map((event) => event.eventName))];
+}
+function eventHostIndexes(view, eventName) {
+	const hosts = new Set(view.events.filter((event) => event.eventName === eventName).map((event) => event.hostNodeId));
+	return view.locators.filter((locator) => hosts.has(locator.hostNodeId)).map((locator) => locator.index);
+}
+function deferredTriggerSource(view) {
+	const visible = eventHostIndexes(view, PROTOCOL_VISIBLE_EVENT_NAME);
+	const idle = eventHostIndexes(view, PROTOCOL_IDLE_EVENT_NAME$1);
+	if (browserEventNames({
+		...view,
+		events: []
+	}).includes(PROTOCOL_IDLE_EVENT_NAME$1)) idle.push(0);
+	return (visible.length > 0 ? createInlineDeferTriggerSource("visible", visible) : "") + (idle.length > 0 ? createInlineDeferTriggerSource("idle", idle) : "");
+}
 function browserEventNames(view) {
-	return [...new Set([
+	return [.../* @__PURE__ */ 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.branches ?? []).flatMap((branch) => [...(branch.armRecords ?? []).flatMap((arm) => arm.events.filter(protocolEventDispatchesMarkless).map((event) => event.eventName)), ...branchServedArmEventNames(branch)]),
 		...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>`;
+	])].filter((eventName) => eventName !== PROTOCOL_VISIBLE_EVENT_NAME);
+}
+function renderContainer(containerId, parts, locators) {
+	const inner = parts.filter(Boolean).join("");
+	const paths = servedLocatorPaths(inner, locators);
+	return `<div data-async-container${containerId ? `="${escapeAttribute(containerId)}"` : ""}${paths ? ` ${PROTOCOL_LOCATOR_PATHS_ATTRIBUTE}="${paths}"` : ""}>${inner}</div>`;
+}
+function renderInlineResumerScript(source, nonce, resumeModuleUrl, selfWake, settleModuleUrl, appendSelfWakeSource = true, overlayPrimer = false, appendedSource = "", deferFactory) {
+	const nonceAttribute = nonce ? ` nonce="${escapeAttribute(nonce)}"` : "";
+	const resumeModuleAttribute = resumeModuleUrl ? ` data-markless-resume-module="${escapeAttribute(resumeModuleUrl)}"` : "";
+	const settleModuleAttribute = settleModuleUrl ? ` data-markless-settle-module="${escapeAttribute(settleModuleUrl)}"` : "";
+	const selfWakeAttribute = selfWake ? " data-markless-self-wake" : "";
+	const selfWakeSource = selfWake && appendSelfWakeSource ? createInlineResumerSelfWakeSource(resumeModuleUrl) : "";
+	const overlayPrimerSource = overlayPrimer ? createInlineResumerOverlayPrimerSource(resumeModuleUrl) : "";
+	const [first, ...rest] = (source + selfWakeSource + overlayPrimerSource + appendedSource).split(inlineDeferSource());
+	return `<script data-async-resumer${nonceAttribute}${resumeModuleAttribute}${settleModuleAttribute}${selfWakeAttribute}>${escapeInlineScript(rest.length ? `${first}${inlineDeferSource(deferFactory)}${rest.join("globalThis.__mDefer")}` : first)}<\/script>`;
 }
 function escapeAttribute(value) {
 	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
@@ -427,7 +713,8 @@ async function emitPrerenderedPage(input) {
 	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 withHead = page.head ? html.replace("</head>", `${page.head}</head>`) : html;
+	await writeFile(htmlFile, withHead.replace(placeholder, page.container));
 }
 const SENTINEL_OPEN = "";
 const SENTINEL_CLOSE = "";
@@ -911,6 +1198,101 @@ async function withBuiltPrerenderPage(input, read) {
 	}
 }
 //#endregion
+//#region src/build/deferred-runtime.ts
+/**
+* Deferred packs for runtime no compiled demand names: each such dynamic-import target, plus what
+* only such targets reach. Modules reached from the same targets share one pack, so each target
+* stays its own chunk. A target other code imports statically still gets a pack: that importer
+* loads it through its static edge, while no preload plan follows a dynamic edge into it.
+*/
+function deferredRuntimePacks(input) {
+	const packs = /* @__PURE__ */ new Map();
+	if (input.undemanded.size === 0) return packs;
+	const undemanded = withUndemandedReExportDoors(input.modules, input.undemanded);
+	const reach = (roots, skipUndemanded) => {
+		const reached = /* @__PURE__ */ new Set();
+		const pending = [...roots];
+		while (pending.length) {
+			const id = pending.pop();
+			if (reached.has(id)) continue;
+			reached.add(id);
+			const module = input.modules.get(id);
+			if (!module) continue;
+			pending.push(...module.dependencies);
+			for (const target of module.dynamicDependencies) if (!skipUndemanded || !undemanded.has(target)) pending.push(target);
+		}
+		return reached;
+	};
+	const lazy = reach(undemanded, false);
+	const kept = reach([...input.modules.keys()].filter((id) => !lazy.has(id)), true);
+	const dynamicTargets = /* @__PURE__ */ new Set();
+	const behindUndemanded = /* @__PURE__ */ new Set();
+	for (const [id, module] of input.modules) {
+		for (const target of module.dynamicDependencies) dynamicTargets.add(target);
+		if (undemanded.has(id)) for (const dependency of module.dependencies) behindUndemanded.add(dependency);
+	}
+	const reachedBy = /* @__PURE__ */ new Map();
+	for (const target of [...undemanded].sort()) {
+		if (behindUndemanded.has(target) && !dynamicTargets.has(target)) continue;
+		const label = runtimeModuleIdFromOrigin(target.split("?")[0]) ?? "runtime";
+		for (const id of reach([target], false)) {
+			if (!input.modules.has(id) || kept.has(id) && !undemanded.has(id)) continue;
+			const labels = reachedBy.get(id) ?? [];
+			if (!labels.includes(label)) labels.push(label);
+			reachedBy.set(id, labels);
+		}
+	}
+	for (const [id, labels] of reachedBy) packs.set(id, `${MARKLESS_DEFERRED_PACK}-${labels.join("+").replace(/[^\w+-]/g, "-")}`);
+	return packs;
+}
+function deferredRuntimePlugin(demandMaps) {
+	let packs = /* @__PURE__ */ new Map();
+	return {
+		name: "markless:deferred-runtime",
+		options(input) {
+			return input.preserveEntrySignatures === false ? null : {
+				...input,
+				preserveEntrySignatures: "allow-extension"
+			};
+		},
+		buildEnd(error) {
+			packs = /* @__PURE__ */ new Map();
+			if (error) return;
+			const modules = /* @__PURE__ */ new Map();
+			for (const id of this.getModuleIds()) {
+				const info = this.getModuleInfo(id);
+				if (!info || "isExternal" in info && info.isExternal) continue;
+				modules.set(id, {
+					dependencies: info.importedIds,
+					dynamicDependencies: info.dynamicallyImportedIds,
+					reExportsOnly: isReExportDoor(info)
+				});
+			}
+			packs = deferredRuntimePacks({
+				modules,
+				undemanded: undemandedRuntimeModules({
+					demandMaps: demandMaps(),
+					moduleIds: modules.keys()
+				})
+			});
+		},
+		outputOptions(output) {
+			if (typeof output.codeSplitting !== "object") return null;
+			return {
+				...output,
+				codeSplitting: {
+					...output.codeSplitting,
+					groups: [{
+						name: (id) => packs.get(id) ?? null,
+						priority: 1e3,
+						includeDependenciesRecursively: false
+					}, ...output.codeSplitting.groups ?? []]
+				}
+			};
+		}
+	};
+}
+//#endregion
 //#region src/vite/dev-tags.ts
 function createDevTags() {
 	const tags = [];
@@ -1022,7 +1404,7 @@ if (window.__MARKLESS_DEV_ERROR__) show(window.__MARKLESS_DEV_ERROR__);
 }
 //#endregion
 //#region src/vite/environment.ts
-const UNMANAGED_VITE_ENVIRONMENTS = new Set(["nitro"]);
+const UNMANAGED_VITE_ENVIRONMENTS = /* @__PURE__ */ new Set(["nitro"]);
 function viteEnvironmentName(environment, options = {}) {
 	if (environment === "client") return options.clientEnvironment ?? "client";
 	if (environment === "server") return options.serverEnvironment ?? "ssr";
@@ -1048,6 +1430,19 @@ function isUnmanagedViteEnvironment(environment) {
 function transformMarklessRequest(server, url, environment, options) {
 	return server.environments[viteEnvironmentName(environment, options)]?.transformRequest(url);
 }
+const serverModuleRunners = /* @__PURE__ */ new WeakMap();
+function serverModuleRunner(server, environmentName) {
+	const environment = server.environments[environmentName];
+	if (!environment || !isRunnableDevEnvironment(environment)) throw new Error(`MARKLESS_DEV_MODULE_RUNNER_UNAVAILABLE: ${environmentName}`);
+	const byName = serverModuleRunners.get(server) ?? /* @__PURE__ */ new Map();
+	serverModuleRunners.set(server, byName);
+	const existing = byName.get(environmentName);
+	if (existing) return existing;
+	const runner = createServerModuleRunner(environment);
+	byName.set(environmentName, runner);
+	server.httpServer?.once("close", () => void runner.close());
+	return runner;
+}
 function hasInProcessModuleRunner(environment) {
 	return !!environment && isRunnableDevEnvironment(environment);
 }
@@ -1262,11 +1657,13 @@ function createViteHmr(options) {
 			reloadModuleRunner();
 			return [];
 		}
-		const files = changedFiles(ctx.modules ?? []);
+		const modules = new Set(ctx.modules ?? []);
+		if (ctx.file) for (const target of targets.keys()) for (const module of target.moduleGraph?.getModulesByFile?.(ctx.file) ?? []) modules.add(module);
+		const files = changedFiles([...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);
+			files.set(parsePath(ctx.file).pathname, prefix && ctx.file.startsWith(prefix) ? `/${ctx.file.slice(prefix.length)}` : ctx.file);
 		}
 		if (!files.size) return;
 		let sendMessages = true;
@@ -1302,8 +1699,8 @@ function createViteHmr(options) {
 		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 [sourceId] of files) {
+			const candidates = editedSource !== void 0 && ctx.file ? [ctx.file] : hmrCandidates(sourceId, ctx.file && SOURCE_FILE_EXTENSION.test(ctx.file) ? ctx.file : void 0);
 			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 ?? []) {
@@ -1373,7 +1770,7 @@ function clientHot(server, options, environment) {
 	return environment.hot;
 }
 function invalidationTargets(server, options, environment, env) {
-	const targets = new Map([[environment, env]]);
+	const targets = /* @__PURE__ */ 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 ?? {})) {
@@ -1396,10 +1793,10 @@ function moduleRunnerHots(targets, clientChannel) {
 	return [...hots];
 }
 function changedFiles(modules) {
-	const files = /* @__PURE__ */ new Set();
+	const files = /* @__PURE__ */ new Map();
 	for (const module of modules) for (const item of [module, ...module.importers ?? []]) {
 		const url = sourceUrl(item);
-		if (url) files.add(url);
+		if (url) files.set(parsePath(item.id ?? item.file ?? url).pathname, url);
 	}
 	return files;
 }
@@ -1409,12 +1806,12 @@ function sourceUrl(module) {
 	return null;
 }
 function hmrCandidates(file, absoluteFile) {
-	const candidates = new Set([file]);
+	const candidates = /* @__PURE__ */ new Set([file]);
 	if (absoluteFile) candidates.add(absoluteFile);
 	return candidates;
 }
 function firstChangedFile(files) {
-	for (const file of files) return file;
+	for (const file of files.values()) return file;
 }
 //#endregion
 //#region src/vite/dev-prerender.ts
@@ -1475,7 +1872,8 @@ function createDevPrerender(input) {
 			} 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);
+				const payload = normalizeMarklessDevError(error, { id: input.entry });
+				return injectDevClients(renderMarklessDevErrorDocument(payload, { base: input.base }), input.base);
 			}
 		},
 		configureServer(nextServer) {
@@ -1486,6 +1884,49 @@ function createDevPrerender(input) {
 	};
 }
 //#endregion
+//#region src/vite/dev-server-externals.ts
+function withDevServerExternals(context) {
+	const config = context.environment?.config;
+	if (config?.consumer !== "server") return context;
+	const noExternal = config.resolve?.noExternal;
+	const resolve = async (source, importer, options) => {
+		const resolved = await context.resolve(source, importer, options);
+		if (!isBareSpecifier(source) || matchesNoExternal(noExternal, source)) return resolved;
+		const id = typeof resolved === "string" ? resolved : resolved?.id;
+		if (!id || !isBuiltDependency(pathname(String(id)))) return resolved;
+		return {
+			...typeof resolved === "object" ? resolved : {},
+			id: String(id),
+			external: true
+		};
+	};
+	return new Proxy(context, { get(target, property) {
+		if (property === "resolve") return resolve;
+		const value = Reflect.get(target, property, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+function isBareSpecifier(source) {
+	return !source.startsWith(".") && !isAbsolute(source) && !source.startsWith("\0") && !source.startsWith("virtual:");
+}
+function isBuiltDependency(id) {
+	return id.includes("/node_modules/") && /\.[cm]?js$/.test(id);
+}
+function matchesNoExternal(noExternal, source) {
+	if (noExternal === true) return true;
+	if (noExternal === void 0) return false;
+	return (typeof noExternal === "string" || noExternal instanceof RegExp ? [noExternal] : noExternal).some((pattern) => typeof pattern === "string" ? source === pattern || source.startsWith(`${pattern}/`) : pattern.test(source));
+}
+//#endregion
+//#region src/vite/dev-runtime-imports.ts
+function installDevRuntimeImportResolution(server, clientEnvironment) {
+	for (const [name, environment] of Object.entries(server.environments ?? {})) {
+		if (name === clientEnvironment || typeof environment.fetchModule !== "function") continue;
+		const fetchModule = environment.fetchModule.bind(environment);
+		environment.fetchModule = (id, importer, options) => fetchModule(marklessRuntimeSpecifierId(id) ?? id, importer, options);
+	}
+}
+//#endregion
 //#region src/vite/index.ts
 const MARKLESS_SKIP_DUPLICATE_BUILDS = Symbol("markless-skip-duplicate-builds");
 const TSRX_INPUT_FILE = /\.tsrx(?:[?#].*)?$/;
@@ -1494,7 +1935,12 @@ function markless(options = {}) {
 	const bundleGraphAdders = /* @__PURE__ */ new Set();
 	const transformedTsrxSources = /* @__PURE__ */ new Map();
 	const prerenderRecordsBySource = /* @__PURE__ */ new Map();
-	const rolldownOptions = { ...options };
+	const { experimentalNativePacking: _deprecatedPacking, ...rest } = options;
+	const rolldownOptions = {
+		...rest,
+		packing: nativePackingEnabled(options),
+		chunkImportMap: options.experimentalNativePacking === true
+	};
 	const prerender = process.env.MARKLESS_PRERENDER === "1";
 	const explicitPrerenderWake = process.env.MARKLESS_PRERENDER_WAKE;
 	rolldownOptions.prerender = false;
@@ -1551,12 +1997,17 @@ function markless(options = {}) {
 				__MARKLESS_DEV_ENABLED__: devDefine
 			};
 			configDefaults(config, options, rolldownOptions);
+			if (devEnabled) {
+				includeOptimizedDeps(config, [RESUME_ENTRY_SPECIFIER, STORAGE_FREE_RESUME_ENTRY_SPECIFIER]);
+				excludeSourceShippedDeps(config);
+			}
 			if (prerender || stagePrerenderWake) {
 				prerenderEntry = ssrTsrxInput(config, options);
 				rolldownOptions.prerender = prerender && prerenderEntry !== null;
 			}
 		},
 		configResolved(resolvedConfig) {
+			if (options.experimentalNativePacking !== void 0) resolvedConfig.logger.warn(DEPRECATED_NATIVE_PACKING_WARNING);
 			resolvedRoot = resolvedConfig.root;
 			clientOutDir = resolvedConfig.build?.outDir ?? "dist";
 			const serve = resolvedConfig.command === "serve";
@@ -1636,9 +2087,10 @@ function markless(options = {}) {
 			}
 		},
 		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.");
+			server.config.logger?.info(`markless diagnostics available - window.__MARKLESS_DEBUG__ records containers, lifecycles, and event routing; ${DEBUGGING_PLAYBOOK_HINT}.`);
 			rolldownOptions.devServer = {
 				transformRequest: (url, environment) => transformMarklessRequest(server, url, environment, options),
+				importModule: (source) => serverModuleRunner(server, viteEnvironmentName("server", options)).import(source),
 				invalidateModule: (id, environment) => {
 					const target = server.environments[viteEnvironmentName(environment, options)];
 					const module = target?.moduleGraph?.getModuleById?.(id);
@@ -1648,6 +2100,7 @@ function markless(options = {}) {
 				}
 			};
 			hmr.configureServer(server);
+			installDevRuntimeImportResolution(server, viteEnvironmentName("client", options));
 			devPrerender?.configureServer(server);
 		},
 		transformIndexHtml(html) {
@@ -1679,7 +2132,8 @@ function markless(options = {}) {
 		transform: { async handler(code, id, transformOptions) {
 			if (rolldownOptions.dev === true && TSRX_INPUT_FILE.test(id)) transformedTsrxSources.set(parsePath(id).pathname, code);
 			try {
-				return await runHook(basePlugin.transform, this, code, id, transformOptions);
+				const context = rolldownOptions.dev === true ? withDevServerExternals(this) : this;
+				return await runHook(basePlugin.transform, context, code, id, transformOptions);
 			} catch (error) {
 				if (rolldownOptions.dev === true && TSRX_INPUT_FILE.test(id)) {
 					const environment = this.environment;
@@ -1693,7 +2147,52 @@ function markless(options = {}) {
 			return hmr.hotUpdate(this.environment, ctx);
 		}
 	};
-	return [marklessPlugin];
+	return [
+		marklessPlugin,
+		{
+			name: "markless:shared-render-data-reach",
+			enforce: "pre",
+			resolveId: {
+				filter: { id: /[?&]markless-reached-from=/ },
+				async handler(source, importer) {
+					const shared = sharedReachedRenderDataRequest(source);
+					return shared ? await this.resolve(shared, importer, { skipSelf: true }) : null;
+				}
+			}
+		},
+		{
+			name: "markless:init-facade-imports",
+			apply: "build",
+			enforce: "pre",
+			applyToEnvironment(environment) {
+				return environment.config.consumer === "client";
+			},
+			generateBundle: {
+				order: "post",
+				async handler(_options, bundle) {
+					await prefetchChunkParses(Object.values(bundle).filter((output) => output.type === "chunk" && output.code.includes("import(")));
+					collapseInitFacadeImports(bundle);
+					unwrapAsyncImportWrappers(bundle);
+				}
+			}
+		},
+		...nativePackingEnabled(options) ? nativePackingPlugins(() => resolvedRoot, () => basePlugin.api.runtimeDemandMaps(), () => basePlugin.api.runtimeDemandSources()).map((plugin) => ({
+			...plugin,
+			apply: "build",
+			enforce: "post",
+			sharedDuringBuild: true,
+			applyToEnvironment(environment) {
+				return environment.config.consumer === "client";
+			}
+		})) : [{
+			...deferredRuntimePlugin(() => basePlugin.api.runtimeDemandMaps()),
+			apply: "build",
+			enforce: "post",
+			applyToEnvironment(environment) {
+				return environment.config.consumer === "client";
+			}
+		}]
+	];
 }
 async function buildMarklessEnvironments(builder, options) {
 	const environments = buildEnvironments(builder, options);