@markless/bundler 0.8.0 → 0.10.0

package/dist/{route-pack-groups-BLS6xeVV.js → route-pack-groups-ByQmKKom.js}

@@ -1,139 +1,10 @@
-import { joinURL, parsePath, withQuery, withoutLeadingSlash } from "ufo";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
+import { withQuery } from "ufo";
+import { INLINE_RESUMER_PAGE_TOKEN, PRERENDER_INLINE_EVENT_NAMES_TOKEN, createInlineResumerDebugRegistrationSource, createInlineResumerSelfWakeSource, createInlineResumerSource, createPrerenderInlineResumerSource, createPrerenderSettleInlineResumerSource } from "@markless/web/inline/resumer";
+import { minifySync, transformSync } from "rolldown/experimental";
 import { MARKLESS_COMPONENT_PART_BRAND } from "@markless/web/render-to-string";
-import { ASYNC_PROTOCOL_VERSION, PROTOCOL_EVENT_ACTION_KIND, protocolEventActionKind } from "@markless/serializer";
-import { isAbsolute, resolve } from "pathe";
-import { emitSymbolResolverModule } from "@markless/compiler";
-//#region src/build/preload-plan.ts
-const DEFAULT_MIN_PROBABILITY = 0;
-const JAVASCRIPT_MODULE_RE = /\.(?:mjs|js)(?:[?#].*)?$/;
-const PRIORITY_RANK = {
-	high: 2,
-	auto: 1,
-	low: 0
-};
-function planModulePreloadUrls(input) {
-	return planModulePreloads(input).map((preload) => preload.href);
-}
-function planModulePreloads(input) {
-	const minProbability = input.minProbability ?? DEFAULT_MIN_PROBABILITY;
-	const maxPreloads = input.maxPreloads ?? Number.POSITIVE_INFINITY;
-	const graph = parseBundleGraph(input.bundleGraph);
-	const planned = /* @__PURE__ */ new Map();
-	const bestVisitByNode = /* @__PURE__ */ new Map();
-	let order = 0;
-	const addModule = (name, probability, priority, fetchPriority) => {
-		if (!isPreloadableModuleName(name)) return;
-		const href = preloadHref(input.base, name);
-		const existing = planned.get(href);
-		const nextRank = PRIORITY_RANK[priority];
-		const existingRank = existing ? PRIORITY_RANK[existing.priority] : -1;
-		if (existing && (existingRank > nextRank || existingRank === nextRank && existing.probability >= probability)) return;
-		planned.set(href, {
-			fetchPriority,
-			href,
-			name,
-			order: existing?.order ?? order++,
-			priority,
-			probability
-		});
-	};
-	const visit = (name, probability, priority, fetchPriority, seen, suppressed = false, suppressRootOnly = false) => {
-		if (probability < minProbability || planned.size >= maxPreloads) return;
-		if (!suppressed) {
-			const priorityRank = PRIORITY_RANK[priority];
-			const previousBest = bestVisitByNode.get(name);
-			if (previousBest && (previousBest.priorityRank > priorityRank || previousBest.priorityRank === priorityRank && previousBest.probability >= probability)) return;
-			bestVisitByNode.set(name, {
-				priorityRank,
-				probability
-			});
-		}
-		if (seen.has(name)) return;
-		const nextSeen = new Set(seen);
-		nextSeen.add(name);
-		const record = graph.get(name);
-		if (!record) {
-			if (!suppressed) addModule(name, probability, priority, fetchPriority);
-			return;
-		}
-		for (const dep of record.deps.filter((item) => item.kind === "static")) visit(dep.name, probability * dep.probability, priority, fetchPriority, nextSeen, suppressed && !suppressRootOnly);
-		if (!suppressed) addModule(name, probability, priority, fetchPriority);
-		for (const dep of record.deps.filter((item) => item.kind === "dynamic")) {
-			if (input.lazyChunks?.has(dep.name)) continue;
-			const edgeProbability = JAVASCRIPT_MODULE_RE.test(name) ? dep.probability : 1;
-			visit(dep.name, probability * edgeProbability, priority, fetchPriority, nextSeen, false);
-		}
-	};
-	for (const root of input.roots) {
-		const normalized = normalizeRoot(root);
-		visit(normalized.name, 1, normalized.priority, normalized.fetchPriority, /* @__PURE__ */ new Set(), normalized.edges === "dynamic-only" || normalized.edges === "dependencies-only", normalized.edges === "dependencies-only");
-	}
-	return [...planned.values()].sort((left, right) => {
-		const priority = PRIORITY_RANK[right.priority] - PRIORITY_RANK[left.priority];
-		if (priority !== 0) return priority;
-		return left.order - right.order;
-	}).slice(0, maxPreloads).map(({ order: _order, ...preload }) => preload);
-}
-function parseBundleGraph(graph) {
-	const records = /* @__PURE__ */ new Map();
-	if (!graph) return records;
-	let index = 0;
-	while (index < graph.length) {
-		const name = graph[index++];
-		if (typeof name !== "string") continue;
-		const deps = [];
-		let probability = 1;
-		let kind = "static";
-		while (typeof graph[index] === "number") {
-			const marker = graph[index++];
-			if (marker < 0) {
-				probability = -marker / 10;
-				kind = "dynamic";
-				continue;
-			}
-			const dep = graph[marker];
-			if (typeof dep === "string") deps.push({
-				name: dep,
-				kind,
-				probability
-			});
-		}
-		records.set(name, {
-			name,
-			deps
-		});
-	}
-	return records;
-}
-function preloadHref(base, name) {
-	if (!base || /^(?:[a-z]+:)?\/\//i.test(name)) return name;
-	return joinURL(base, name);
-}
-function isPreloadableModuleName(name) {
-	return JAVASCRIPT_MODULE_RE.test(name) || isViteDevModuleUrl(name);
-}
-function isViteDevModuleUrl(name) {
-	return (name.startsWith("/") || name.startsWith("@id/")) && /(?:^|[?&])import(?:[&#]|$)/.test(name);
-}
-function normalizeRoot(root) {
-	if (typeof root === "string") return {
-		name: root,
-		priority: "auto",
-		fetchPriority: "auto"
-	};
-	const priority = root.priority ?? "auto";
-	return {
-		name: root.name,
-		priority,
-		edges: root.edges,
-		fetchPriority: root.fetchPriority ?? priorityToFetchPriority(priority)
-	};
-}
-function priorityToFetchPriority(priority) {
-	if (priority === "auto") return "auto";
-	return priority;
-}
-//#endregion
+import { ASYNC_PROTOCOL_VERSION, protocolBoundSymbolPrefix } from "@markless/serializer";
 //#region src/execution-log.ts
 const MARKLESS_EXECUTION_LOG_MODULE_ID = "virtual:markless:dev-log";
 const MARKLESS_EXECUTION_LOG_GLOBAL = "__mxLog";
@@ -415,6 +286,532 @@ function executionLogActivationInjection(mode) {
 	};
 }
 //#endregion
+//#region ../web/src/debug-channel.ts
+function installDebugChannelLayer(root, initialPhase, initiallyActive = true) {
+	const global = globalThis;
+	const previous = global.__MARKLESS_DEBUG__?.version === 1 ? global.__MARKLESS_DEBUG__ : void 0;
+	let priorRoot;
+	try {
+		priorRoot = previous?.explainInteraction(root, "__markless_debug_root__");
+	} catch {}
+	const priorContainer = priorRoot && "containerId" in priorRoot ? previous?.containers.find((entry) => entry.id === priorRoot.containerId) : void 0;
+	const seed = `${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+	const id = priorContainer?.id ?? `container:${seed}`;
+	const rootKey = priorContainer?.root.key ?? `root:${seed}`;
+	const rootRef = new WeakRef(root);
+	const events = /* @__PURE__ */ new WeakMap();
+	const delegatedEvents = /* @__PURE__ */ new Set();
+	const keys = /* @__PURE__ */ new WeakMap();
+	const invalidated = /* @__PURE__ */ new WeakSet();
+	const routerSources = global[Symbol.for("markless.debug.channel.v1.router-sources")] ??= /* @__PURE__ */ new Set();
+	const ownViolations = [];
+	let phase = initialPhase;
+	let lifecycle = initiallyActive ? "active" : "registered";
+	let boundarySnapshots = Object.freeze([]);
+	let nextElement = 1;
+	let nextSequence = (previous?.violations.at(-1)?.sequence ?? 0) + 1;
+	let dropped = 0;
+	let pruned = false;
+	const freeze = (value) => Object.freeze(value);
+	const contains = (element) => {
+		const currentRoot = rootRef.deref();
+		return !!currentRoot && (currentRoot === element || currentRoot.contains?.(element) === true);
+	};
+	const keyFor = (element) => {
+		let key = keys.get(element);
+		if (!key) {
+			key = `${rootKey}:element:${nextElement++}`;
+			keys.set(element, key);
+		}
+		return key;
+	};
+	const eligibleAnchor = (element) => {
+		const anchor = element.closest?.("a[href]");
+		if (!anchor?.hasAttribute("data-markless-router-link") || anchor.hasAttribute("download")) return false;
+		const target = anchor.getAttribute("target");
+		if (target && target !== "_self" || anchor.relList?.contains("external")) return false;
+		try {
+			const base = global.location?.href ?? "http://localhost/";
+			return new URL(anchor.href ?? "", base).origin === new URL(base).origin;
+		} catch {
+			return false;
+		}
+	};
+	const none = (element, eventName, reason) => freeze({
+		kind: "none",
+		eventName,
+		reason,
+		containerId: id,
+		elementKey: keyFor(element)
+	});
+	const explain = (element, eventName) => {
+		if (lifecycle === "disposed" && (contains(element) || keys.has(element))) return none(element, eventName, "container-disposed");
+		if (!contains(element)) try {
+			return previous?.explainInteraction(element, eventName) ?? freeze({
+				kind: "none",
+				eventName,
+				reason: "outside-known-container"
+			});
+		} catch {
+			return freeze({
+				kind: "none",
+				eventName,
+				reason: "outside-known-container"
+			});
+		}
+		if (element.isConnected === false) return none(element, eventName, "element-disconnected");
+		if (eligibleAnchor(element)) {
+			const source = eventName === "navigate" && routerSources.has("navigation-event") ? "navigation-event" : eventName === "click" && routerSources.has("spa-click-listener") ? "spa-click-listener" : eventName === "click" && routerSources.has("ssr-link-bridge") ? "ssr-link-bridge" : void 0;
+			if (source) return freeze({
+				kind: "router-delegation",
+				source,
+				containerId: id,
+				elementKey: keyFor(element),
+				eventName
+			});
+		}
+		const interaction = events.get(element)?.get(eventName);
+		if (interaction) return freeze({ ...interaction });
+		if (delegatedEvents.has(eventName)) return freeze({
+			kind: "inline-resumer",
+			source: "ssr-inline",
+			containerId: id,
+			elementKey: keyFor(element),
+			eventName
+		});
+		if (invalidated.has(element)) return none(element, eventName, "not-registered");
+		try {
+			const prior = previous?.explainInteraction(element, eventName);
+			if (prior && prior.kind !== "none") return prior;
+		} catch {}
+		return none(element, eventName, "not-registered");
+	};
+	const cloneJson = (value, seen = /* @__PURE__ */ new Set()) => {
+		if (value === null) return null;
+		if (typeof value === "boolean" || typeof value === "string") return value;
+		if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+		if (!value || typeof value !== "object" || seen.has(value)) return void 0;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			const copy = value.map((entry) => cloneJson(entry, seen));
+			return copy.some((entry) => entry === void 0) ? void 0 : freeze(copy);
+		}
+		if (Object.getPrototypeOf(value) !== Object.prototype) return void 0;
+		const copy = {};
+		for (const [name, entry] of Object.entries(value)) {
+			const cloned = cloneJson(entry, seen);
+			if (cloned === void 0) return void 0;
+			copy[name] = cloned;
+		}
+		return freeze(copy);
+	};
+	const pushViolation = (input) => {
+		const cloned = input.details === void 0 ? void 0 : cloneJson(input.details);
+		const details = cloned && !Array.isArray(cloned) && typeof cloned === "object" ? cloned : void 0;
+		const { details: _details, ...metadata } = input;
+		ownViolations.push(freeze({
+			...metadata,
+			...details ? { details } : {},
+			sequence: nextSequence++,
+			timestamp: Date.now()
+		}));
+		if (input.details !== void 0 && !details) ownViolations.push(freeze({
+			code: "MARKLESS_DEBUG_DETAILS_DROPPED",
+			message: "Debug violation details were not JSON-safe and were dropped.",
+			sequence: nextSequence++,
+			timestamp: Date.now()
+		}));
+		while (ownViolations.length > 100) {
+			ownViolations.shift();
+			dropped++;
+		}
+	};
+	const channel = freeze({
+		version: 1,
+		get containers() {
+			const inherited = previous?.containers.filter((entry) => entry.id !== id) ?? [];
+			if (pruned || lifecycle === "disposed") return freeze([...inherited]);
+			const currentRoot = rootRef.deref();
+			const connected = !!currentRoot && currentRoot.isConnected !== false;
+			const snapshot = freeze({
+				id,
+				phase,
+				lifecycle: connected ? lifecycle : "disposed",
+				root: freeze({
+					key: rootKey,
+					connected
+				}),
+				boundaries: freeze([...boundarySnapshots])
+			});
+			if (!connected) pruned = true;
+			return freeze([...inherited, snapshot]);
+		},
+		get violations() {
+			return freeze([...previous?.violations ?? [], ...ownViolations].slice(-100));
+		},
+		violationCapacity: 100,
+		get droppedViolationCount() {
+			return (previous?.droppedViolationCount ?? 0) + dropped;
+		},
+		explainInteraction: explain
+	});
+	Object.defineProperty(global, "__MARKLESS_DEBUG__", {
+		configurable: true,
+		enumerable: false,
+		value: channel,
+		writable: false
+	});
+	return {
+		start(nextPhase, active = true) {
+			phase = nextPhase === "ssr-resume" && phase === "csr" ? "csr" : nextPhase;
+			if (active) lifecycle = "active";
+			return id;
+		},
+		activate: () => void (lifecycle === "disposed" || (lifecycle = "active")),
+		dispose() {
+			lifecycle = "disposed";
+			boundarySnapshots = freeze([]);
+		},
+		invalidate(element) {
+			events.delete(element);
+			invalidated.add(element);
+		},
+		record(element, eventName, input) {
+			if (lifecycle === "disposed") return;
+			let byName = events.get(element);
+			if (!byName) events.set(element, byName = /* @__PURE__ */ new Map());
+			const symbolIds = "symbolIds" in input ? freeze([...input.symbolIds]) : void 0;
+			byName.set(eventName, freeze({
+				...input,
+				...symbolIds ? { symbolIds } : {},
+				containerId: id,
+				elementKey: keyFor(element),
+				eventName
+			}));
+		},
+		delegated(eventNames) {
+			if (lifecycle === "disposed") return;
+			for (const eventName of eventNames) delegatedEvents.add(eventName);
+		},
+		violation: pushViolation,
+		router: (source) => void routerSources.add(source),
+		boundaries(value) {
+			boundarySnapshots = freeze(value.map((entry) => freeze({ ...entry })));
+		},
+		disposed: () => lifecycle === "disposed"
+	};
+}
+function __marklessDebugBootstrapSource() {
+	return `((root,phase,active)=>{const controls=(${installDebugChannelLayer.toString()})(root,phase,active);return Object.freeze({record:(element,eventName,input)=>controls.record(element,eventName,input),delegated:(eventNames)=>controls.delegated(eventNames),router:(source)=>controls.router(source),activate:()=>controls.activate()})})`;
+}
+//#endregion
+//#region ../serializer/src/protocol-event-names.ts
+const PROTOCOL_VISIBLE_EVENT_NAME = "visible";
+const PROTOCOL_IDLE_EVENT_NAME$1 = "idle";
+//#endregion
+//#region ../serializer/src/protocol-locator-paths.ts
+/**
+* The container attribute that lets resume find each located element by its
+* position under its parent, so a node a third-party script adds or swaps
+* elsewhere cannot shift it. Format: protocol-locator-paths-format.ts.
+*/
+const PROTOCOL_LOCATOR_PATHS_ATTRIBUTE = "data-markless-paths";
+//#endregion
+//#region ../serializer/src/protocol-event-host.ts
+/**
+* The attribute the server writes on each served element that hosts an event
+* record. The inline boot reads it from the event target up, so it finds a
+* press's handler and sync policy without parsing a payload or knowing the
+* element's position. Grammar: entries joined by `;`, each
+* `name[:ref][!policy]`, where `ref` is the record's index in its region's event
+* list (or `-` for an event an external delegate owns) and `policy` is `p`, `s`,
+* `ps` or an index into the container's sync-policy table.
+*/
+const PROTOCOL_EVENT_HOST_ATTRIBUTE = "m:on";
+//#endregion
+//#region ../serializer/src/protocol-page-markers.ts
+const PROTOCOL_CONTAINER_START_COMMENT = "markless:page-start";
+const PROTOCOL_CONTAINER_END_COMMENT = "markless:page-end";
+const PROTOCOL_BLOCK_START_COMMENT = /^markless:(?:branch|arm-branch|async):/;
+//#endregion
+//#region ../serializer/src/protocol-stream-open.ts
+const PROTOCOL_STREAM_OPEN_PROPERTY = "__mStreamOpen";
+//#endregion
+//#region ../web/src/inline/defer.ts
+const PROTOCOL_EVENT_HOST_SELECTOR = PROTOCOL_EVENT_HOST_ATTRIBUTE.replace(":", "\\:");
+/**
+* The one startup helper deferred triggers share. Serialized whole into a served
+* page that has one; a client mount and the runtime call it directly. Hosts are
+* the elements whose event host attribute (`hostSelector`, escaped for a CSS
+* attribute selector) names the lane's event with a record;
+* `ownsRoot` adds the container itself, which hands records the runtime owns
+* (arms, rows) to the runtime.
+*/
+function createMarklessDefer(loadModule, pageStart, pageEnd, pathsAttribute, hostSelector, streamOpenProperty) {
+	const scope = globalThis;
+	const clockOf = (root) => root.__mClock || {
+		frame: (run) => requestAnimationFrame(run),
+		idle: (run) => scope.scheduler?.postTask ? scope.scheduler.postTask(run, { priority: "background" }) : typeof requestIdleCallback === "function" ? requestIdleCallback(run, { timeout: 2e3 }) : setTimeout(run, 200)
+	};
+	const census = (root) => {
+		const live = [root];
+		const walker = document.createTreeWalker(root, 129);
+		for (let next = walker.nextNode(); next; next = walker.nextNode()) if (next.nodeType !== 8) live.push(next);
+		else if (next.data === pageStart) live.length = 1;
+		else if (next.data === pageEnd) break;
+		const paths = pathsAttribute && root.getAttribute?.(pathsAttribute);
+		const order = paths && paths.split("|")[3];
+		let signature = 0;
+		if (order) for (const element of live.slice(1)) {
+			const name = element.localName ?? element.tagName ?? "";
+			signature = signature * 31 + name.length * 32 + (name.charCodeAt(0) | 32) | 0;
+		}
+		if (paths && (parseInt(paths) !== live.length || order && order !== (signature >>> 0).toString(36))) root.__marklessShifted = 1;
+		return live;
+	};
+	const idle = (root, run) => {
+		const clock = clockOf(root);
+		const next = () => clock.idle(() => root.__marklessArmRegistering?.size ? next() : run());
+		const loaded = () => clock.frame(() => scope.__mArm?.idle ? scope.__mArm.idle(next) : next());
+		const open = Reflect.get(document, streamOpenProperty);
+		if (open) open.then(loaded);
+		else if (document.readyState === "complete") loaded();
+		else addEventListener("load", loaded, { once: true });
+	};
+	const trigger = (target, lane, ownsRoot, eventName) => {
+		const root = target;
+		const url = document.currentScript?.getAttribute("data-markless-resume-module");
+		if (!root || !url) return;
+		const life = root.__mL ||= {};
+		const fired = root.__mFired ||= /* @__PURE__ */ new WeakSet();
+		const claimed = /* @__PURE__ */ new WeakSet();
+		let pending = 0;
+		const claim = (host) => {
+			if (fired.has(host) || claimed.has(host) || root.__mL !== life) return;
+			const input = {
+				root,
+				event: {
+					type: eventName,
+					target: host,
+					bubbles: false
+				},
+				element: host
+			};
+			const queue = root.__marklessDispatch;
+			if (!queue && root.__marklessDelegatedDispatch === true) return idle(root, () => claim(host));
+			claimed.add(host);
+			if (lane !== "visible") fired.add(host);
+			root.__marklessCensus ||= census(root);
+			root.__marklessDelegatedDispatch ||= eventName;
+			pending++;
+			(queue ? Promise.resolve(queue(input)) : (root.__mResume ||= loadModule(url)).then((module) => root.__mL === life && module.resumeContainerEvent(input))).then(() => {
+				if (root.__asyncResumeRuntimeStarted) return;
+				fired.add(host);
+				if (!--pending && root.__marklessDelegatedDispatch === eventName) root.__marklessDelegatedDispatch = void 0;
+			});
+		};
+		const hosts = ownsRoot ? [root] : [];
+		hosts.push(...root.querySelectorAll(`[${hostSelector}^="${eventName}:"],[${hostSelector}*=";${eventName}:"]`));
+		if (lane === "idle") return idle(root, () => hosts.forEach(claim));
+		const observer = new IntersectionObserver((entries) => {
+			if (root.__mL !== life) return observer.disconnect();
+			for (const entry of entries) if (entry.isIntersecting) {
+				observer.unobserve(entry.target);
+				claim(entry.target);
+			}
+		});
+		for (const host of hosts) observer.observe(host);
+	};
+	return Object.assign(trigger, { idle });
+}
+const INLINE_DEFER_LOADER_SOURCE = "(url) => import(/* @vite-ignore */ url)";
+/** An expression that installs the helper once per document and evaluates to it; a build passes the factory minified. */
+function inlineDeferSource(factory = createMarklessDefer.toString()) {
+	return `(globalThis.__mDefer||=(${factory})(${INLINE_DEFER_LOADER_SOURCE},${JSON.stringify(PROTOCOL_CONTAINER_START_COMMENT)},${JSON.stringify(PROTOCOL_CONTAINER_END_COMMENT)},${JSON.stringify(PROTOCOL_LOCATOR_PATHS_ATTRIBUTE)},${JSON.stringify(PROTOCOL_EVENT_HOST_SELECTOR)},${JSON.stringify(PROTOCOL_STREAM_OPEN_PROPERTY)}))`;
+}
+/** One lane's registration, appended only to a served page whose records name that lane's event. */
+function createInlineDeferTriggerSource(lane, ownsRoot) {
+	const eventName = lane === "idle" ? PROTOCOL_IDLE_EVENT_NAME$1 : PROTOCOL_VISIBLE_EVENT_NAME;
+	return `;${inlineDeferSource()}(document.currentScript?.closest('[data-async-container]'),${JSON.stringify(lane)},${ownsRoot ? 1 : 0},${JSON.stringify(eventName)});`;
+}
+//#endregion
+//#region src/inline-resumer.ts
+const compiledSources = /* @__PURE__ */ new Map();
+function compileInlineResumerSources(options) {
+	const cacheKey = `${options.debug ? "debug" : "production"}:${options.executionLog}`;
+	let compiled = compiledSources.get(cacheKey);
+	if (!compiled) {
+		compiled = compileInlineResumerSourceVariants(options);
+		compiledSources.set(cacheKey, compiled);
+	}
+	return compiled;
+}
+async function compileInlineResumerSourceVariants(options) {
+	const shared = {
+		debug: options.debug,
+		executionLog: options.executionLog
+	};
+	const [event, syncPolicy, graphSyncPolicyOwner, graphSyncPolicyConsumer] = await Promise.all([
+		compileInlineResumerSource({
+			...shared,
+			graphSyncPolicy: false,
+			sharedGraphPolicy: false,
+			syncPolicy: false
+		}),
+		compileInlineResumerSource({
+			...shared,
+			graphSyncPolicy: false,
+			sharedGraphPolicy: false,
+			syncPolicy: true
+		}),
+		compileInlineResumerSource({
+			...shared,
+			graphSyncPolicy: true,
+			sharedGraphPolicy: true,
+			syncPolicy: true
+		}),
+		compileInlineResumerSource({
+			...shared,
+			graphSyncPolicy: true,
+			sharedGraphPolicy: false,
+			syncPolicy: true
+		})
+	]);
+	const defer = await compileDeferFactorySource();
+	return {
+		...shared,
+		event,
+		syncPolicy,
+		graphSyncPolicyOwner,
+		graphSyncPolicyConsumer,
+		defer
+	};
+}
+async function compileDeferFactorySource() {
+	const binding = "var __marklessDeferFactory=";
+	const transformed = transformSync("markless-defer.js", `${binding}${createMarklessDefer.toString()};`, {
+		lang: "js",
+		sourceType: "script",
+		target: "es2020"
+	});
+	assertOxcResult("transform", transformed.errors);
+	const minified = minifySync("markless-defer.js", transformed.code, {
+		compress: true,
+		mangle: { toplevel: false },
+		module: false
+	});
+	assertOxcResult("minify", minified.errors);
+	const code = minified.code.trim().replace(/;$/, "");
+	if (!code.startsWith(binding)) throw new Error("MARKLESS_INLINE_DEFER_FACTORY_UNWRAPPABLE");
+	return code.slice(27);
+}
+async function compileInlineResumerSource(options) {
+	const source = createInlineResumerSource({
+		...options,
+		...options.debug ? {
+			debugBootstrapSource: __marklessDebugBootstrapSource(),
+			debugRegistrationSource: createInlineResumerDebugRegistrationSource()
+		} : {}
+	});
+	const transformed = transformSync("markless-inline-resumer.js", source, {
+		lang: "js",
+		sourceType: "script",
+		target: "es2020"
+	});
+	assertOxcResult("transform", transformed.errors);
+	const minified = minifySync("markless-inline-resumer.js", transformed.code, {
+		compress: true,
+		mangle: { toplevel: true },
+		module: false
+	});
+	assertOxcResult("minify", minified.errors);
+	const code = minified.code.trim();
+	if (!code.includes(INLINE_RESUMER_PAGE_TOKEN)) throw new Error("MARKLESS_INLINE_RESUMER_PAGE_TOKEN_FOLDED");
+	return code;
+}
+function assertOxcResult(phase, errors) {
+	if (errors.length === 0) return;
+	throw new Error(`MARKLESS_INLINE_RESUMER_${phase.toUpperCase()}_FAILED:\n${errors.map((error) => error.message).join("\n")}`);
+}
+const compiledPrerenderSources = /* @__PURE__ */ new Map();
+function compilePrerenderInlineResumerSources() {
+	let compiled = compiledPrerenderSources.get("production");
+	if (!compiled) {
+		compiled = compilePrerenderVariants();
+		compiledPrerenderSources.set("production", compiled);
+	}
+	return compiled;
+}
+async function compilePrerenderVariants() {
+	const [prerender, prerenderSelfWake, prerenderSettle] = await Promise.all([
+		compilePrerenderInlineResumerSource(false),
+		compilePrerenderInlineResumerSource(true),
+		compilePrerenderInlineResumerSource("settle")
+	]);
+	return {
+		prerender,
+		prerenderSelfWake,
+		prerenderSettle
+	};
+}
+async function compilePrerenderInlineResumerSource(selfWake) {
+	const source = parameterizedPrerenderInlineResumerSource(selfWake);
+	const transformed = transformSync("markless-prerender-inline-resumer.js", source, {
+		lang: "js",
+		sourceType: "script",
+		target: "es2020"
+	});
+	assertOxcResult("transform", transformed.errors);
+	const minified = minifySync("markless-prerender-inline-resumer.js", transformed.code, {
+		compress: true,
+		mangle: { toplevel: true },
+		module: false
+	});
+	assertOxcResult("minify", minified.errors);
+	const code = minified.code.trim();
+	if (code.split(PRERENDER_INLINE_EVENT_NAMES_TOKEN).length !== 2) throw new Error("MARKLESS_PRERENDER_INLINE_RESUMER_EVENT_NAMES_TOKEN_LOST");
+	return code;
+}
+function parameterizedPrerenderInlineResumerSource(selfWake) {
+	const placeholder = [PRERENDER_INLINE_EVENT_NAMES_TOKEN];
+	const literal = JSON.stringify(placeholder);
+	const plain = selfWake === "settle" ? createPrerenderSettleInlineResumerSource(placeholder, void 0) : createPrerenderInlineResumerSource(placeholder, void 0);
+	if (plain.split(literal).length !== 2) throw new Error("MARKLESS_PRERENDER_INLINE_RESUMER_EVENT_NAMES_UNPLACEABLE");
+	return `${plain.replace(literal, PRERENDER_INLINE_EVENT_NAMES_TOKEN)}${selfWake === true ? createInlineResumerSelfWakeSource(void 0) : ""}`;
+}
+//#endregion
+//#region src/shared-inline-sources.ts
+const SHARED_INLINE_RESUMER_SOURCES = "inlineResumerSources";
+const SHARED_PRERENDER_BOOT = "prerenderBoot";
+const PREFIX = "virtual:markless:inline-sources-";
+const EXECUTION_LOG_MODES = /* @__PURE__ */ new Set([
+	"auto",
+	"never",
+	"always"
+]);
+function sharedInlineSourcesModuleId(options) {
+	return `${PREFIX}${options.debug ? "debug" : "production"}-${options.executionLog}`;
+}
+function sharedInlineSourcesOptions(id) {
+	const bare = id.startsWith("\0") ? id.slice(1) : id;
+	if (!bare.startsWith(PREFIX)) return null;
+	const [flavour, executionLog] = bare.slice(32).split("-");
+	if (flavour !== "debug" && flavour !== "production" || !EXECUTION_LOG_MODES.has(executionLog)) return null;
+	return {
+		debug: flavour === "debug",
+		executionLog
+	};
+}
+function isSharedInlineSourcesModuleId(id) {
+	return sharedInlineSourcesOptions(id) !== null;
+}
+async function sharedInlineSourcesModuleSource(id) {
+	const options = sharedInlineSourcesOptions(id);
+	if (!options) return null;
+	const [sources, prerender] = await Promise.all([compileInlineResumerSources(options), compilePrerenderInlineResumerSources()]);
+	return [`export const ${SHARED_INLINE_RESUMER_SOURCES} = ${JSON.stringify(sources)};`, `export const ${SHARED_PRERENDER_BOOT} = ${JSON.stringify(prerender)};`].join("\n");
+}
+//#endregion
 //#region src/scalar-plan-loader.ts
 function emitScalarPlanLoader(actions, routes) {
 	const ordered = routes.filter((route) => route.prefix.length > 0).toSorted((left, right) => right.prefix.length - left.prefix.length);
@@ -482,9 +879,9 @@ function emitSymbolRouteTable(input) {
 function boundEntry(boundSymbols, keyLists) {
 	const entries = Object.entries(boundSymbols);
 	const [firstKey, firstId] = entries[0];
-	const head = `bound:${encodeURIComponent(firstKey)}:`;
+	const head = `${protocolBoundSymbolPrefix(firstKey)}:`;
 	const suffix = firstId.startsWith(head) ? firstId.slice(head.length) : void 0;
-	if (suffix === void 0 || entries.some(([key, id]) => id !== `bound:${encodeURIComponent(key)}:${suffix}`)) return JSON.stringify(boundSymbols);
+	if (suffix === void 0 || entries.some(([key, id]) => protocolBoundSymbolPrefix(key) !== `bound:${encodeURIComponent(key)}` || id !== `${protocolBoundSymbolPrefix(key)}:${suffix}`)) return JSON.stringify(boundSymbols);
 	const keys = JSON.stringify(entries.map(([key]) => key));
 	let index = keyLists.indexOf(keys);
 	if (index < 0) index = keyLists.push(keys) - 1;
@@ -503,9 +900,6 @@ const SYMBOL_VIRTUAL_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}symbol:`;
 function symbolVirtualModuleId(filename, symbolId) {
 	return `${SYMBOL_VIRTUAL_PREFIX}${encodeURIComponent(filename)}:${encodeURIComponent(symbolId)}`;
 }
-function symbolEntryVirtualModuleId(filename, symbolId) {
-	return `${symbolVirtualModuleId(filename, symbolId)}:entry`;
-}
 function encodedSymbolSource(filename) {
 	return encodeURIComponent(filename);
 }
@@ -625,8 +1019,9 @@ function emitSourceModule(input) {
 	const emitsSsrBody = !!input.publicSsrModuleSource && !(input.environment === "client" && (symbolsOnly || !input.prerenderRecords && !input.dev));
 	const csrRootName = input.environment !== "server" && !symbolsOnly && !input.prerenderRecords && input.publicRenderRootExportName ? csrRootLocalName(input.publicRenderRootExportName) : null;
 	return [
-		!input.publicSsrModuleSource && !input.publicRenderModuleSource || symbolsOnly || !input.renderDataId || input.environment === "client" && !input.publicRenderModuleSource && !input.prerenderRecords && !input.dev && !canonicalRenderData ? "" : canonicalRenderData ? emitsSsrBody ? `import { marklessPrerenderData, marklessRenderData } from ${singleQuoted(input.renderDataId)};` : `import { marklessPrerenderData } from ${singleQuoted(input.renderDataId)};` : `import { marklessRenderData } from ${singleQuoted(input.renderDataId)};`,
+		!input.publicSsrModuleSource && !input.publicRenderModuleSource || symbolsOnly || !input.renderDataId || input.environment === "client" && !input.publicRenderModuleSource && !input.prerenderRecords && !input.dev && !canonicalRenderData ? "" : canonicalRenderData ? emitsSsrBody ? `import { marklessPrerenderData, marklessRenderData } from ${singleQuoted(input.renderDataId)};` : input.lazyFullRenderDataId ? "" : `import { marklessPrerenderData } from ${singleQuoted(input.renderDataId)};` : `import { marklessRenderData } from ${singleQuoted(input.renderDataId)};`,
 		symbolsOnly ? "" : `import { state as payloadState, view as payloadView, runtimeDemandMap as payloadRuntimeDemandMap } from ${singleQuoted(input.payloadId)};`,
+		sharedInlineSources(input) ? `import { ${SHARED_INLINE_RESUMER_SOURCES} as marklessInlineResumerSources, ${SHARED_PRERENDER_BOOT} as marklessPrerenderBoot } from ${singleQuoted(input.sharedInlineSourcesModuleId)};` : null,
 		input.environment === "client" && input.directCsr === true && input.hasComputedState === true ? ["import { installMarklessDerivedReconcile } from '@markless/web/fns/reconcile-plane';", "installMarklessDerivedReconcile();"].join("\n") : null,
 		input.environment === "client" && input.hasComputedState === true ? emitRosterResumeLoaderInstall() : null,
 		input.environment === "client" && input.hasOverlayMarks === true ? emitOverlayLoaderInstall() : null,
@@ -662,6 +1057,7 @@ function emitSourceModule(input) {
 			storageSeeds: input.storageSeeds,
 			inlineResumerSources: input.inlineResumerSources,
 			prerenderBoot: input.prerenderBoot,
+			sharedInlineSources: sharedInlineSources(input),
 			resumeModuleUrl: input.resumeModuleUrl,
 			prerenderWakeModuleUrl: input.prerenderWakeModuleUrl,
 			rootExportName: input.publicRenderRootExportName,
@@ -670,6 +1066,7 @@ function emitSourceModule(input) {
 			ssrExportName: input.publicRenderSsrExportName,
 			ssrComponents: input.publicRenderSsrComponentExports ?? [],
 			canonicalRenderData,
+			...canonicalRenderData && !emitsSsrBody && input.lazyFullRenderDataId ? { lazyFullRenderDataId: input.lazyFullRenderDataId } : {},
 			prerenderRecords: input.prerenderRecords,
 			dev: input.dev
 		}),
@@ -796,10 +1193,16 @@ function componentRowLoader(input) {
 	if (input.linkedRowComponents || demandsKeyedRepeatModule(input.runtimeDemandMap, ROW_COMPONENT_MINT_RUNTIME_MODULE_ID)) return emitRowComponentMintLoaderInstall();
 	return input.linkedRowSlotReaders || demandsKeyedRepeatModule(input.runtimeDemandMap, ROW_SLOT_MINT_RUNTIME_MODULE_ID) ? emitRowSlotMintLoaderInstall() : void 0;
 }
+function rowBranchesLoader(runtimeDemandMap, linked = false) {
+	return linked || demandsKeyedRepeatModule(runtimeDemandMap, ROW_BRANCH_MINT_RUNTIME_MODULE_ID) ? "globalThis.__marklessRowBranches ??= () => import('@markless/web/fns/row-branch-mint').then((branches) => branches.marklessRowBranches());" : null;
+}
 function clientRowMintLoader(input) {
-	const mint = demandsRowComponentMint(input.runtimeDemandMap) ? emitRowComponentMintLoaderInstall() : componentRowLoader(input) ?? (input.linkedRowTemplates || demandsRowMint(input.runtimeDemandMap) ? emitRowMintLoaderInstall() : null);
-	const nested = nestedRepeatsLoader(input.runtimeDemandMap, input.linkedNestedRepeats);
-	return mint && nested ? `${mint}\n${nested}` : mint ?? nested;
+	const lines = [
+		demandsRowComponentMint(input.runtimeDemandMap) ? emitRowComponentMintLoaderInstall() : componentRowLoader(input) ?? (input.linkedRowTemplates || demandsRowMint(input.runtimeDemandMap) ? emitRowMintLoaderInstall() : null),
+		nestedRepeatsLoader(input.runtimeDemandMap, input.linkedNestedRepeats),
+		rowBranchesLoader(input.runtimeDemandMap, input.linkedRowBranches)
+	].filter((line) => line !== null);
+	return lines.length > 0 ? lines.join("\n") : null;
 }
 function emitRowSlotMintLoaderInstall() {
 	return ["if (!globalThis.__marklessRowMint?.components) globalThis.__marklessRowMint = (...input) =>", "	import('@markless/web/fns/row-slot-mint').then((mint) => mint.marklessRowSlotMint(...input));"].join("\n");
@@ -819,6 +1222,7 @@ const ROW_MINT_RUNTIME_MODULE_ID = "web/fns/row-mint";
 const NESTED_REPEATS_RUNTIME_MODULE_ID = "web/fns/nested-repeats";
 const ROW_COMPONENT_MINT_RUNTIME_MODULE_ID = "web/fns/row-component-mint";
 const ROW_SLOT_MINT_RUNTIME_MODULE_ID = "web/fns/row-slot-mint";
+const ROW_BRANCH_MINT_RUNTIME_MODULE_ID = "web/fns/row-branch-mint";
 /** True when the compiler recorded an `overlay` mark for this module. */
 function demandsOverlay(runtimeDemandMap) {
 	const records = runtimeDemandMap?.payloadRecords;
@@ -833,7 +1237,7 @@ function emitResumeModule(input) {
 		runtimeDemandMap: input.servedScalarPlans
 	} : input);
 	const stagedPrerender = (input.prerenderTriggerGroups?.length ?? 0) > 0;
-	const resumeContainerEvent = emitQueuedResumeContainerEvent(emitResumeContainerEvent(resumeSymbolLoader, input.needsFullResume ?? false, input.storageCells !== true && input.payloadState?.version === ASYNC_PROTOCOL_VERSION, servedPlansOnly ? "scalar" : composedLeanMode(input.symbolRoutes.length > 0, leanResumeMode(input.runtimeDemandMap)), scalarSpecializations, input.runtimeDemandMap, input.executionLog !== "never", input.prerenderDataId, stagedPrerender, componentRowLoader(input) ? input.lazyRenderDataId ?? input.renderDataId : void 0, input.symbolRoutes.length > 0 || servedPlansOnly, (input.closurePlanRoutes ?? []).some((route) => "importSource" in route) && scalarSpecializations.length > 0 && !input.prerenderDataId, input.streamsArms === true));
+	const resumeContainerEvent = emitQueuedResumeContainerEvent(emitResumeContainerEvent(resumeSymbolLoader, input.needsFullResume ?? false, input.storageCells !== true && input.payloadState?.version === ASYNC_PROTOCOL_VERSION, servedPlansOnly ? "scalar" : composedLeanMode(input.symbolRoutes.length > 0, leanResumeMode(input.runtimeDemandMap)), scalarSpecializations, input.runtimeDemandMap, input.executionLog !== "never", input.prerenderDataId, stagedPrerender, componentRowLoader(input) ? input.servedRenderDataId ?? input.lazyRenderDataId ?? input.renderDataId : void 0, input.symbolRoutes.length > 0 || servedPlansOnly, (input.closurePlanRoutes ?? []).some((route) => "importSource" in route) && scalarSpecializations.length > 0 && !input.prerenderDataId, input.streamsArms === true));
 	const closureImports = [
 		"marklessClosureRouted",
 		"marklessPrimeClosure",
@@ -855,6 +1259,7 @@ function emitResumeModule(input) {
 		input.hasIdleEvents ? emitIdleTriggerInstall() : null,
 		componentRowLoader(input) ?? (input.linkedRowTemplates || demandsRowMint(input.runtimeDemandMap) ? emitRowMintLoaderInstall() : null),
 		nestedRepeatsLoader(input.runtimeDemandMap, input.linkedNestedRepeats),
+		rowBranchesLoader(input.runtimeDemandMap, input.linkedRowBranches),
 		scalarSpecializations.length > 0 ? [
 			"import { marklessDecodeScalarCell, marklessReadScalarCell, marklessScalarSpecializedError } from '@markless/web/fns/scalar-specialized';",
 			resumeContainerEvent.includes("marklessScalarServedOwner") ? `import { marklessScalarLocate, marklessScalarServedOwner, marklessScalarServedPrime${resumeContainerEvent.includes("marklessScalarServedRecord") ? ", marklessScalarServedRecord" : ""} } from '@markless/web/fns/scalar-served';` : "",
@@ -863,6 +1268,7 @@ function emitResumeModule(input) {
 			"import { marklessUpdateText } from '@markless/web/fns/update-text';"
 		].join("\n") : "",
 		scalarSpecializations.length > 0 || stagedPrerender ? "import { marklessFindElementAtDomOrderIndex } from '@markless/web/fns/dom-order';" : "",
+		input.prerenderTriggerGroups?.some((group) => group.hostPath) ? "import { marklessElementAt } from '@markless/web/fns/element-address';" : null,
 		"",
 		input.executionLog === "never" ? "" : emitExecutionLogLoader(),
 		input.installResumeSummary && input.executionLog !== "never" ? "if (globalThis.__mxLog) globalThis.__mxLoadLog().then(log => log.installMarklessExecutionLog());" : null,
@@ -891,21 +1297,21 @@ function emitQueuedResumeContainerEvent(source, { censusRepair = true } = {}) {
 		"	if (input.eventIndex >= 0) input = { ...input, eventRecord: (root.__mE ||= JSON.parse(root.querySelector('script[type=\"markless/view\"]').textContent).events)[input.eventIndex] };",
 		censusRepair ? "	if (root.__marklessShifted) return import('@markless/web/fns/served-census-repair').then((census) => (census.marklessRepairCensus(root), resumeContainerEvent(input)));" : "",
 		"	if (!root.__marklessDispatch) {",
-		"		let handler = marklessResumeContainerEvent, tail = Promise.resolve(), done = tail, lastEvent = null, lastEventTime = undefined, seen = new WeakMap();",
+		"		let handler = marklessResumeContainerEvent, tail = Promise.resolve(), done = tail, lastEvent = null, lastEventTime = undefined, seen = new WeakMap(), life = root.__mL;",
 		"		root.__marklessRegisterDispatch = next => {",
 		"			const fallback = handler;",
 		"			handler = input => next(input, fallback);",
 		"		};",
 		"		root.__marklessDispatch = next => {",
 		"			const event = next.event, eventTime = event?.timeStamp;",
-		"			if (event && next.eventRecord && next.element) event.__marklessPressHost ??= next.element;",
+		"			if (event && next.eventRecord && next.element) event.__marklessPressPath ??= [next.element];",
 		"			if ((event === lastEvent && eventTime === lastEventTime) || (seen.has(event) && seen.get(event) === eventTime)) return done;",
 		"			if (Object(event) === event) seen.set(event, eventTime);",
 		"			lastEvent = event;",
 		"			lastEventTime = eventTime;",
 		"			let release;",
 		"			const started = new Promise(resolve => release = resolve);",
-		"			const run = () => (root.__marklessReleaseDispatch = release, handler(next));",
+		"			const run = () => root.__mL === life ? (root.__marklessReleaseDispatch = release, handler(next)) : release();",
 		"			done = tail.then(run, run);",
 		"			done.then(release, release);",
 		"			tail = started;",
@@ -924,7 +1330,7 @@ function emitLazySymbolRouteFunction(routes, functionName, fallbackName = "loadS
 	return emitSymbolRouteTable({
 		routes: [...routes].sort((left, right) => right.prefix.length - left.prefix.length).map((route) => "importSource" in route ? {
 			...route,
-			importSource: symbolRouteImportSource$1(route.importSource, includeScalarActionPlans)
+			importSource: symbolRouteImportSource(route.importSource, includeScalarActionPlans)
 		} : route),
 		functionName,
 		fallbackName,
@@ -958,21 +1364,29 @@ function emitClosurePlanRoute(routes, functionName, actions) {
 		`function ${functionName}(symbolId) {`,
 		...ordered.flatMap((route) => [
 			`	if (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
-			"importSource" in route ? `		return import(${JSON.stringify(symbolRouteImportSource$1(route.importSource))}).then((mod) => mod.loadClosureActionPlan?.(symbolId.slice(${route.prefix.length})));` : route.prefix.length > 0 ? `		return ${functionName}(symbolId.slice(${route.prefix.length}));` : `		return ${localLookup};`,
+			"importSource" in route ? `		return import(${JSON.stringify(symbolRouteImportSource(route.importSource))}).then((mod) => mod.loadClosureActionPlan?.(symbolId.slice(${route.prefix.length})));` : route.prefix.length > 0 ? `		return ${functionName}(symbolId.slice(${route.prefix.length}));` : `		return ${localLookup};`,
 			"	}"
 		]),
 		`	return ${localLookup};`,
 		"}"
 	].filter(Boolean).join("\n");
 }
-function symbolRouteImportSource$1(importSource, includeScalarActionPlans = false) {
+function symbolRouteImportSource(importSource, includeScalarActionPlans = false) {
 	if (includeScalarActionPlans) return scalarPlanSourceReference(importSource);
 	return importSource.includes("?") ? `${importSource}&markless-symbols` : `${importSource}?markless-symbols`;
 }
+function sharedInlineSources(input) {
+	return input.environment === "server" && !!input.sharedInlineSourcesModuleId && !!input.inlineResumerSources && !!input.prerenderBoot;
+}
+function sharedPrerenderBootSource(boot) {
+	if (!boot.settle) return "marklessPrerenderBoot";
+	const { boot: _boot, ...settle } = boot.settle;
+	return `{ ...marklessPrerenderBoot, settle: { ...${JSON.stringify(settle)}, boot: marklessPrerenderBoot.prerenderSettle } }`;
+}
 function emitCompiledAppDefault(input) {
 	const renderCsrEntry = input.csrRootName ? [`	renderCsr: ${input.csrRootName},`] : [];
 	const symbolLoaderEntry = input.environment !== "server" && input.rootExportName === null ? [`\tloadSymbol: ${input.symbolLoaderName},`] : input.prerenderRecords === true ? [`\tloadSymbol: ${input.symbolLoaderName},`] : [];
-	const renderDataEntry = input.canonicalRenderData ? ["	renderData: marklessPrerenderData,"] : [];
+	const renderDataEntry = !input.canonicalRenderData ? [] : input.lazyFullRenderDataId ? [`\trenderData: () => import(${singleQuoted(input.lazyFullRenderDataId)}).then((data) => data.marklessPrerenderData),`] : ["	renderData: marklessPrerenderData,"];
 	const servesSsr = !!input.ssrExportName && (input.environment !== "client" || input.prerenderRecords || input.dev);
 	const renderSsrEntry = servesSsr ? [
 		"	renderSsr(props, marklessRenderContext) {",
@@ -982,8 +1396,8 @@ function emitCompiledAppDefault(input) {
 	const renderSsrComponentsEntry = servesSsr && input.ssrComponents.length > 0 ? [`	renderSsrComponents: { ${input.ssrComponents.map((component) => `${JSON.stringify(component.exportName)}: { renderSsr: ${component.ssrFunctionName} }`).join(", ")} },`] : [];
 	const resumeModuleEntry = input.resumeModuleUrl && input.environment !== "client" ? [`	resumeModuleUrl: ${JSON.stringify(input.resumeModuleUrl)},`] : [];
 	const prerenderWakeModuleEntry = input.prerenderWakeModuleUrl && input.environment !== "client" ? [`\tprerenderWakeModuleUrl: ${JSON.stringify(input.prerenderWakeModuleUrl)},`] : [];
-	const inlineResumerEntry = input.inlineResumerSources && input.environment !== "client" ? [`\tinlineResumerSources: ${JSON.stringify(input.inlineResumerSources)},`] : [];
-	const prerenderBootEntry = input.prerenderBoot && input.environment !== "client" ? [`\tprerenderBoot: ${JSON.stringify(input.prerenderBoot)},`] : [];
+	const inlineResumerEntry = input.inlineResumerSources && input.environment !== "client" ? [input.sharedInlineSources ? "	inlineResumerSources: marklessInlineResumerSources," : `\tinlineResumerSources: ${JSON.stringify(input.inlineResumerSources)},`] : [];
+	const prerenderBootEntry = input.prerenderBoot && input.environment !== "client" ? [input.sharedInlineSources ? `\tprerenderBoot: ${sharedPrerenderBootSource(input.prerenderBoot)},` : `\tprerenderBoot: ${JSON.stringify(input.prerenderBoot)},`] : [];
 	const headInjectionEntry = input.headInjections?.length && input.environment !== "client" ? [`	headInjections: ${JSON.stringify(input.headInjections)},`] : [];
 	const storageSeedEntry = input.storageSeeds?.length && input.environment !== "client" ? [`\tstorageSeeds: ${JSON.stringify(input.storageSeeds)},`] : [];
 	const modulePreloadEntry = input.resumeModuleUrl && input.environment === "server" ? [`	modulePreloads: [{ href: ${JSON.stringify(input.resumeModuleUrl)}, fetchPriority: "high" }],`] : [];
@@ -1062,21 +1476,32 @@ function emitComponentExports(input) {
 	});
 }
 function emitResumeContainerEvent(loadSymbolName, needsFullResume, storageFreePayload, leanMode, scalarSpecializations, runtimeDemandMap, executionLogEnabled, prerenderDataId, stagedPrerender = false, componentRowRenderDataId, servedOnly = false, routedClosures = false, streamsArms = false) {
-	const armsOpen = (indent) => streamsArms ? [`${indent}const marklessArms = (await import('@markless/web/fns/streamed-arms')).marklessStreamedArms(handoff.root, ${loadSymbolName});`] : [];
+	const lifeOpen = (indent) => `${indent}const marklessLife = handoff.root.__mL;`;
+	const lifeCheck = (indent) => `${indent}if (handoff.root.__mL !== marklessLife) return;`;
+	const armsOpen = (indent) => streamsArms ? [
+		`${indent}const marklessArmsModule = await import('@markless/web/fns/streamed-arms');`,
+		lifeCheck(indent),
+		`${indent}const marklessArms = marklessArmsModule.marklessStreamedArms(handoff.root, ${loadSymbolName});`
+	] : [];
 	const armsStarted = (indent) => streamsArms ? [`${indent}marklessArms.started();`] : [];
 	const wakeLoadSymbol = streamsArms ? "marklessArms.loadSymbol" : loadSymbolName;
 	const resumeEntry = storageFreePayload ? STORAGE_FREE_RESUME_ENTRY_SPECIFIER : RESUME_ENTRY_SPECIFIER;
 	const renderDataEntry = (indent, expression) => componentRowRenderDataId ? [`${indent}renderData: () => ${expression},`] : [];
 	const fullResumeHandoff = stagedPrerender && prerenderDataId ? [
 		"async function marklessFullResumeHandoff(handoff) {",
+		lifeOpen("	"),
 		"	handoff.root.__asyncResumeRuntimeStarted = true;",
 		"	const group = await marklessLoadPrerenderTriggerGroup(handoff);",
 		"	const { mergePrerenderPayloadRecords, resumePrerenderTriggerGroup } = await import('@markless/web/fns/prerender-trigger-resume');",
+		lifeCheck("	"),
 		"	if (!group) {",
 		"		const { derivePrerenderResumeRecords, renderPrerenderBoundary, resumeFromPrerenderRecords } = await import('@markless/web/fns/prerender-resume');",
+		lifeCheck("		"),
 		"		handoff.root.__marklessFullResumeRuntime ??= (async () => {",
 		"			const marklessPrerenderData = await marklessLoadPrerenderData();",
-		`\t\t\tconst fallbackRecords = mergePrerenderPayloadRecords(await derivePrerenderResumeRecords(marklessPrerenderData, ${loadSymbolName}), handoff.root);`,
+		`\t\t\tconst derivedRecords = await derivePrerenderResumeRecords(marklessPrerenderData, ${loadSymbolName});`,
+		lifeCheck("			"),
+		"			const fallbackRecords = mergePrerenderPayloadRecords(derivedRecords, handoff.root);",
 		"			return (await resumeFromPrerenderRecords({",
 		"				...fallbackRecords,",
 		"				root: handoff.root,",
@@ -1086,6 +1511,7 @@ function emitResumeContainerEvent(loadSymbolName, needsFullResume, storageFreePa
 		"			})).runtime;",
 		"		})();",
 		"		const marklessFullRuntime = await handoff.root.__marklessFullResumeRuntime;",
+		"		if (!marklessFullRuntime) return;",
 		"		await marklessFullRuntime.dispatch(handoff.event, { syncPolicyAlreadyApplied: handoff.syncPolicyAlreadyApplied === true, ignoreUnmatched: true });",
 		"		return;",
 		"	}",
@@ -1098,11 +1524,13 @@ function emitResumeContainerEvent(loadSymbolName, needsFullResume, storageFreePa
 		"}"
 	].join("\n") : prerenderDataId ? [
 		"async function marklessFullResumeHandoff(handoff) {",
+		lifeOpen("	"),
 		"	handoff.root.__marklessLinkedRenderDataBoot = true;",
 		"	handoff.root.__asyncResumeRuntimeStarted = true;",
 		"	const runtime = await (handoff.root.__marklessFullResumeRuntime ??= (async () => {",
 		"		const { derivePrerenderResumeRecords, mergePrerenderPayloadRecords, renderPrerenderBoundary, resumeFromPrerenderRecords } = await import('@markless/web/fns/prerender-resume');",
 		`\t\tconst records = await derivePrerenderResumeRecords(marklessPrerenderData, ${loadSymbolName});`,
+		lifeCheck("		"),
 		"		const mergedRecords = mergePrerenderPayloadRecords(records, handoff.root);",
 		...armsOpen("		"),
 		streamsArms ? "		const resumed = await resumeFromPrerenderRecords({" : "		return (await resumeFromPrerenderRecords({",
@@ -1117,13 +1545,16 @@ function emitResumeContainerEvent(loadSymbolName, needsFullResume, storageFreePa
 			"		return resumed.runtime;"
 		] : ["		})).runtime;"],
 		"	})());",
+		"	if (!runtime) return;",
 		"	await runtime.dispatch(handoff.event, { syncPolicyAlreadyApplied: handoff.syncPolicyAlreadyApplied === true, ignoreUnmatched: true });",
 		"}"
 	].join("\n") : [
 		"async function marklessFullResumeHandoff(handoff) {",
+		lifeOpen("	"),
 		"	handoff.root.__asyncResumeRuntimeStarted = true;",
 		...armsOpen("	"),
 		`	const { resumeFromPayloadDocument } = await import(${singleQuoted(resumeEntry)});`,
+		lifeCheck("	"),
 		"	const { runtime } = await resumeFromPayloadDocument({",
 		"		document: handoff.document,",
 		"		root: handoff.root,",
@@ -1145,7 +1576,9 @@ function emitResumeContainerEvent(loadSymbolName, needsFullResume, storageFreePa
 	].join("\n");
 	if (leanMode !== "none") {
 		const row = [
+			"	const marklessLife = input.root.__mL;",
 			"	const { resumeScalarRowEventFromPayloadDocument } = await import('@markless/web/event-only-lean/row');",
+			"	if (input.root.__mL !== marklessLife) return;",
 			"	await resumeScalarRowEventFromPayloadDocument({",
 			...[
 				"		document: input.root,",
@@ -1210,10 +1643,9 @@ function emitPrerenderTriggerGroupLoader(groups) {
 		"	let within = false, done = false;",
 		"	const between = node => { for (const child of node.childNodes ?? []) { if (child === start) { within = true; continue; } if (child === end) { done = true; return; } if (within) armNodes.push(child); else between(child); if (done) return; } };",
 		"	between(input.root);",
-		"	let host = armNodes[hostPath[0]];",
-		"	for (let index = 1; host && index < hostPath.length; index++) host = host.childNodes?.[hostPath[index]];",
+		"	const host = marklessElementAt({ childNodes: armNodes }, hostPath);",
 		"	const target = input.event?.target;",
-		"	return host?.nodeType === 1 && (host === target || (!!target?.nodeType && typeof host.contains === \"function\" && host.contains(target)));",
+		"	return !!host && (host === target || (!!target?.nodeType && typeof host.contains === \"function\" && host.contains(target)));",
 		"}",
 		"function marklessLoadPrerenderTriggerGroup(input) {",
 		...groups.map((group) => {
@@ -1429,7 +1861,7 @@ function emitScalarAction(action, loadSymbolName, resolution) {
 		] : [],
 		...emitScalarWrite(action),
 		`	const symbol = await Promise.resolve(${loadSymbolName}(${JSON.stringify(action.symbolId)}));`,
-		"	await Promise.resolve(symbol({ graph: { ...graph, write() {}, update(update) { const value = graph.read(update.graphNodeId, update.path ?? []); return update.returnValue === \"previous\" || update.returnValue === \"next\" ? value : undefined; } }, event: input.event, element: host, getElementHandle: () => undefined }));",
+		"	await Promise.resolve(symbol({ graph: { ...graph, write: (write) => write.value, update(update) { const value = graph.read(update.graphNodeId, update.path ?? []); return update.returnValue === \"previous\" || update.returnValue === \"next\" ? value : undefined; } }, event: input.event, element: host, getElementHandle: () => undefined }));",
 		"	if (state.dirty) {",
 		"		state.dirty = false;",
 		...action.textUpdates.map((update, index) => `		textTarget${index}.textContent = marklessUpdateText({ domUpdate: { hostNodeId: ${JSON.stringify(update.hostNodeId)} }, value: ${JSON.stringify(update.prefix ?? "")} + (state.value == null ? '' : String(state.value))${update.suffix ? ` + ${JSON.stringify(update.suffix)}` : ""} }, ${JSON.stringify(update.hostNodeId)}).value;`),
@@ -1504,7 +1936,7 @@ function emitLoadSymbol(input, sourceReaderName) {
 function emitDirectSourceSymbolLoader(symbols, readerName = "readMarklessSourceSymbol") {
 	return [
 		"function loadSymbol(symbolId) {",
-		...symbols.flatMap((symbol) => [`	if (symbolId === ${JSON.stringify(symbol.id)}) return import(${singleQuoted(symbol.lazyChunk ?? symbol.chunk)})`, `		.then((mod) => ${readerName}(mod, ${JSON.stringify(symbol.exportName)}));`]),
+		...symbols.flatMap((symbol) => [`	if (symbolId === ${JSON.stringify(symbol.id)}) return import(${singleQuoted(symbol.chunk)})`, `		.then((mod) => ${readerName}(mod, ${JSON.stringify(symbol.exportName)}));`]),
 		"	return Promise.reject(new Error(`Unknown async symbol ${symbolId}`));",
 		"}",
 		emitSourceSymbolExportReader(readerName)
@@ -1529,869 +1961,194 @@ function stringHash(value) {
 function singleQuoted(value) {
 	return `'${String(value).replace(/[\\']/g, "\\$&").replace(/\n/g, "\\n").replace(/\r/g, "\\r")}'`;
 }
-const MARKLESS_BUILD_PREFIX = `build/`;
-const MARKLESS_BUNDLE_GRAPH = `${MARKLESS_BUILD_PREFIX}bundle-graph.json`;
-const MARKLESS_EXECUTION_SIZES = `${MARKLESS_BUILD_PREFIX}execution-sizes.json`;
-const MARKLESS_EXECUTION_DEMAND = `${MARKLESS_BUILD_PREFIX}execution-demand.json`;
-const MARKLESS_INTERACTION_CLOSURES = `${MARKLESS_BUILD_PREFIX}interaction-closures.json`;
-const MARKLESS_BYTE_ATTRIBUTION = `${MARKLESS_BUILD_PREFIX}byte-attribution.json`;
-const MARKLESS_BUILD_METADATA_FILES = [
-	MARKLESS_BUNDLE_GRAPH,
-	MARKLESS_EXECUTION_SIZES,
-	MARKLESS_EXECUTION_DEMAND,
-	MARKLESS_INTERACTION_CLOSURES,
-	MARKLESS_BYTE_ATTRIBUTION
-];
-const MARKLESS_PUBLIC_BUILD_METADATA_FILES = [MARKLESS_EXECUTION_SIZES];
-const WEB_RUNTIME_CAPABILITY_GROUPS = [
-	{
-		name: "markless-direct-renderer",
-		test: fileBasenamePattern("direct")
-	},
-	{
-		name: "markless-resume-branches",
-		test: fileBasenamePattern("resume-branches", "resume-arm-records-lazy")
-	},
-	{
-		name: "markless-resume-behaviors",
-		test: fileBasenamePattern("resume-behaviors")
-	},
-	{
-		name: "markless-resume-repeats",
-		test: fileBasenamePattern("resume-keyed-repeats", "resume-keyed-repeats-lazy", "repeat-runtime")
-	},
-	{
-		name: "markless-resume-async",
-		test: fileBasenamePattern("resume-async-boundaries", "resume-async-wiring")
-	},
-	{
-		name: "markless-resume-shared-patch",
-		test: fileBasenamePattern("resume-shared-patch")
-	},
-	{
-		name: "markless-resume-runtime",
-		test: fileBasenamePattern("resume-runtime")
-	},
-	{
-		name: "markless-resume-runtime-start",
-		test: fileBasenamePattern("resume-runtime-start")
-	},
-	{
-		name: "markless-resume-runtime-shared",
-		test: fileBasenamePattern("resume-runtime-shared")
-	},
-	{
-		name: "markless-resume-events",
-		test: fileBasenamePattern("resume-events")
-	},
-	{
-		name: "markless-resume-handoff",
-		test: fileBasenamePattern("resume-handoff")
-	},
-	{
-		name: "markless-resume-locators",
-		test: fileBasenamePattern("resume-locators", "resume-census")
-	},
-	{
-		name: "markless-resume-errors",
-		test: fileBasenamePattern("resume-errors")
-	},
-	{
-		name: "markless-resume-sync-computed",
-		test: fileBasenamePattern("resume-sync-computed")
-	},
-	{
-		name: "markless-resume-sync-demand",
-		test: fileBasenamePattern("resume-sync-demand")
-	},
-	{
-		name: "markless-payload-full",
-		test: fileBasenamePattern("payload-full", "payload-full-storage-free")
-	},
-	{
-		name: "markless-payload-resume",
-		test: fileBasenamePattern("payload-resume", "payload-resume-lazy")
-	},
-	{
-		name: "markless-inline-payload-document",
-		test: /[/\\]web[/\\]src[/\\]inline[/\\]payload-document\.ts(?:[?#].*)?$/
-	},
-	{
-		name: "markless-payload-document",
-		test: fileBasenamePattern("payload-document", "payload-document-common", "payload-resume-registry")
-	},
-	{
-		name: "markless-payload-graph-construct",
-		test: fileBasenamePattern("payload-graph-construct")
-	},
-	{
-		name: "markless-dom-journal",
-		test: fileBasenamePattern("dom-journal")
-	},
-	{
-		name: "markless-protocol-decode",
-		test: fileBasenamePattern("protocol-client", "protocol-client-storage", "protocol-state", "storage-record-client")
-	},
-	{
-		name: "markless-value-decode",
-		test: fileBasenamePattern("value-decode-client", "value-decode-client-lazy", "value-decode-extensions")
-	},
-	{
-		name: "markless-payload-leaves",
-		test: fileBasenamePattern("payload", "payload-document")
-	},
-	{
-		name: "markless-dev-log",
-		test: EXECUTION_LOG_CHUNK_MODULE_PATTERN
-	},
-	{
-		name: "markless-resume-core",
-		test: fileBasenamePattern("resume")
-	},
-	{
-		name: "markless-runtime-graph-core",
-		test: fileBasenamePattern("graph-core")
-	},
-	{
-		name: "markless-runtime-graph-collections",
-		test: fileBasenamePattern("graph-collections")
-	},
-	{
-		name: "markless-runtime-graph-computed",
-		test: fileBasenamePattern("graph-computed")
-	},
-	{
-		name: "markless-runtime-graph-async",
-		test: fileBasenamePattern("graph-async")
-	},
-	{
-		name: "markless-runtime-graph-scheduler",
-		test: fileBasenamePattern("graph-scheduler")
-	},
-	{
-		name: "markless-runtime-graph-shared",
-		test: fileBasenamePattern("graph-shared")
-	},
-	{
-		name: "markless-graph",
-		test: /[/\\](?:runtime[/\\]src[/\\](?!graph-(?:core|collections|computed|async|scheduler|shared)\.ts)|core[/\\]src[/\\]runtime)[/\\]?/
-	},
-	{
-		name: "markless-serializer",
-		test: /[/\\]serializer[/\\]src[/\\](?!protocol-validation)/
-	}
-];
-function fileBasenamePattern(...names) {
-	return new RegExp(`[/\\\\](?:${names.join("|")})\\.ts(?:[?#].*)?$`);
-}
-const MARKLESS_RUNTIME_GROUPS = [...WEB_RUNTIME_CAPABILITY_GROUPS, {
-	name: "markless-runtime",
-	test: /[/\\]@markless[/\\]runtime[/\\]/
-}];
-function outputDefaults(output, environment) {
-	if (environment === "lib") return output;
-	const next = {
-		...output,
-		hoistTransitiveImports: false
-	};
-	if (environment === "server") {
-		next.entryFileNames ??= "[name].js";
-		next.chunkFileNames ??= "chunk-[hash].js";
-		next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
-		return next;
-	}
-	next.entryFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
-	next.chunkFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
-	next.minifyInternalExports = true;
-	next.strictExecutionOrder = true;
-	next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
-	return next;
-}
-function marklessCodeSplitting(codeSplitting) {
-	if (typeof codeSplitting === "boolean") throw new Error("@markless/bundler requires output.codeSplitting to be an object so runtime chunks can be grouped.");
-	return {
-		...codeSplitting,
-		groups: [...MARKLESS_RUNTIME_GROUPS, ...codeSplitting?.groups ?? []]
-	};
-}
 //#endregion
-//#region src/bound-resolver.ts
-function adaptImportedCaptureResolver(source, hasImportedRows) {
-	if (!hasImportedRows) return source;
-	const original = "	return (context) => base({ ...context, capture: createCaptureContext(context, bound) });";
-	const replacement = [
-		"	return async (context) => {",
-		"		const pendingCallbacks = [];",
-		"		const capture = createCaptureContext(context, bound);",
-		"		const result = await base({ ...context, graph: createBoundGraph(context, bound, capture, pendingCallbacks), capture });",
-		"		await Promise.all(pendingCallbacks);",
-		"		return result;",
-		"	};"
-	].join("\n");
-	const helper = [
-		"function createBoundGraph(context, bound, capture, pendingCallbacks) {",
-		"	const legacySlots = new Map(bound.captureSlots.flatMap((slot) => slot.legacyGraphRead ? [[JSON.stringify([slot.legacyGraphRead.graphNodeId, slot.legacyGraphRead.path ?? []]), slot]] : []));",
-		"	let lastCallback = Promise.resolve();",
-		"	return {",
-		"		...context.graph,",
-		"		read(graphNodeId, path = []) {",
-		"			const slot = legacySlots.get(JSON.stringify([graphNodeId, path]));",
-		"			if (!slot) return context.graph.read(graphNodeId, path);",
-		"			if (slot.route.kind === callbackRoute) return (...args) => {",
-		"				const pending = lastCallback.then(() => capture.invoke(slot.slotId, args));",
-		"				lastCallback = pending.catch(() => {});",
-		"				pendingCallbacks.push(pending);",
-		"				return pending;",
-		"			};",
-		"			return capture.read(slot.slotId);",
-		"		},",
-		"	};",
-		"}",
-		""
-	].join("\n");
-	return source.replace(original, replacement).replace("function createCaptureContext(context, bound) {", `${helper}function createCaptureContext(context, bound) {`);
-}
-//#endregion
-//#region src/trigger-groups.ts
-const EVENT_STAGES_BROWSER_TRIGGER = {
-	[PROTOCOL_EVENT_ACTION_KIND.event]: true,
-	[PROTOCOL_EVENT_ACTION_KIND.externalDelegate]: false
-};
-function triggerGroupVirtualModuleId(filename, index) {
-	return `virtual:markless:trigger-group:${encodeURIComponent(filename)}:${index}`;
-}
-function triggerGroupVirtualModuleSourceFile(moduleId) {
-	const bare = moduleId.startsWith("\0") ? moduleId.slice(1) : moduleId;
-	const match = /^virtual:markless:trigger-group:([^:]+):\d+$/.exec(bare);
-	if (!match?.[1]) return null;
-	try {
-		return decodeURIComponent(match[1]);
-	} catch {
-		return null;
+//#region src/build/machine-paths.ts
+const rootsByBuildRoot = /* @__PURE__ */ new Map();
+function machinePathRoots(root) {
+	const cached = rootsByBuildRoot.get(root);
+	if (cached) return cached;
+	const roots = /* @__PURE__ */ new Set();
+	for (const start of [normalize(root), realpathOrSelf(root)]) {
+		roots.add(start);
+		for (let directory = start; dirname(directory) !== directory; directory = dirname(directory)) if (existsSync(join(directory, "pnpm-workspace.yaml")) || existsSync(join(directory, ".git"))) {
+			roots.add(directory);
+			break;
+		}
 	}
-}
-function emitPrerenderTriggerGroupModule(input) {
-	const armRendererModuleId = input.armRendererModuleId ?? input.group.armRendererModuleId;
-	const ids = new Set(input.group.symbolIds);
-	const boundRows = input.boundRows.filter((row) => ids.has(row.id));
-	let source = emitSymbolResolverModule({
-		symbols: input.symbols.filter((symbol) => ids.has(symbol.id)),
-		boundSymbols: boundRows,
-		literalImports: input.literalImports,
-		bundlerVisibleImports: input.literalImports
-	});
-	const routes = (input.symbolRoutes ?? []).map((route) => route.boundSymbols ? {
-		...route,
-		boundSymbols: Object.fromEntries(Object.entries(route.boundSymbols).filter(([, rowId]) => ids.has(rowId)))
-	} : route);
-	if (routes.length > 0) {
-		source = source.replaceAll("loadSymbol(", "marklessLoadLocalSymbol(");
-		source += "\n" + emitSymbolRouteTable({
-			routes: routes.map((route) => "importSource" in route ? {
-				...route,
-				importSource: symbolRouteImportSource(route.importSource)
-			} : route),
-			functionName: "loadSymbol",
-			fallbackName: "marklessLoadLocalSymbol",
-			reboundName: "marklessLoadSymbolRebound",
-			exported: true
-		});
+	const found = [...roots].filter((path) => path !== "/");
+	rootsByBuildRoot.set(root, found);
+	return found;
+}
+/** `text` with every checkout path removed, as spelled raw, URI-encoded, or as a bundler-minted identifier. */
+function withoutMachinePaths(text, root) {
+	if (!root) return text;
+	const asIdentifier = (value) => value.replace(/[^\w$]/g, "_");
+	let stripped = text;
+	for (const suffix of ["/", ""]) for (const path of machinePathRoots(root)) {
+		const encoded = encodeURIComponent(`${path}${suffix}`);
+		for (const spelling of [
+			`${path}${suffix}`,
+			encoded,
+			encoded.replaceAll("%", "_"),
+			asIdentifier(encoded),
+			asIdentifier(`${path}${suffix}`)
+		]) stripped = stripped.split(spelling).join("");
 	}
-	return [
-		armRendererModuleId ? [
-			`import { prepareBoundaryArm as marklessPrepareBoundaryArm, renderBoundaryArm as marklessRenderBoundaryArm } from ${JSON.stringify(armRendererModuleId)};`,
-			"export function prepareBoundaryArm(boundaryId, status, graph) {",
-			"	return marklessPrepareBoundaryArm(boundaryId, status, graph, loadSymbol);",
-			"}",
-			"export function renderBoundaryArm(boundaryId, status, graph) {",
-			"	return marklessRenderBoundaryArm(boundaryId, status, graph, loadSymbol);",
-			"}"
-		].join("\n") : "",
-		adaptImportedCaptureResolver(source, boundRows.some((row) => row.loaderSymbolId !== void 0)),
-		`export const groupId=${JSON.stringify(input.group.id)};`,
-		`export const state=${JSON.stringify(input.group.state)};`,
-		`export const view=${JSON.stringify(input.group.view)};`,
-		`export const graphNodeIds=${JSON.stringify(input.group.graphNodeIds)};`
-	].join("\n");
-}
-function emitPrerenderBoundaryRendererModule(renderDataId) {
-	return [
-		`import { marklessPrerenderData } from ${JSON.stringify(renderDataId)};`,
-		"import { renderPrerenderBoundary } from '@markless/web/fns/prerender-resume';",
-		"const marklessPreparedBoundaryArms = new WeakMap();",
-		"export async function prepareBoundaryArm(boundaryId, status, graph, loadSymbol) {",
-		"	const rendered = await renderPrerenderBoundary(marklessPrerenderData, boundaryId, status, graph, loadSymbol);",
-		"	if (!marklessPreparedBoundaryArms.has(graph)) marklessPreparedBoundaryArms.set(graph, new Map());",
-		"	marklessPreparedBoundaryArms.get(graph).set(`${boundaryId}:${status}`, rendered);",
-		"}",
-		"export function renderBoundaryArm(boundaryId, status, graph) {",
-		"	const key = `${boundaryId}:${status}`;",
-		"	const prepared = marklessPreparedBoundaryArms.get(graph);",
-		"	const rendered = prepared?.get(key);",
-		"	if (!rendered) throw new Error(`Markless prerender arm ${key} was not prepared.`);",
-		"	prepared.delete(key);",
-		"	return rendered;",
-		"}"
-	].join("\n");
-}
-function symbolRouteImportSource(importSource) {
-	return importSource.includes("?") ? `${importSource}&markless-symbols` : `${importSource}?markless-symbols`;
+	return stripped;
 }
-function planPrerenderTriggerGroups(input) {
-	const symbols = new Map(input.symbolResolver.symbols.map((symbol) => [symbol.id, symbol]));
-	const bounds = new Map(input.boundRows.map((row) => [row.id, row]));
-	const completeView = input.completeView ?? input.view;
-	const completeBoundaries = new Map(completeView.asyncBoundaries.map((boundary) => [boundary.id, boundary]));
-	const selfWakeBoundaries = unsettledAsyncBoundaryIndexes(input.state, input.view);
-	const groups = [
-		...selfWakeBoundaries.length > 0 ? [{
-			event: {
-				hostNodeId: "self-wake",
-				eventName: "self-wake",
-				symbolIds: []
-			},
-			selfWakeBoundaries
-		}] : [],
-		...input.view.events.filter((event) => EVENT_STAGES_BROWSER_TRIGGER[protocolEventActionKind(event)]).map((event) => ({ event })),
-		...(input.view.branches ?? []).flatMap((branch, branchIndex) => {
-			const events = /* @__PURE__ */ new Map();
-			for (const arm of branch.armRecords ?? []) for (const event of arm.events) {
-				const key = `${event.eventName}:${event.hostPath.join(".")}`;
-				const route = events.get(key) ?? {
-					eventName: event.eventName,
-					hostPath: event.hostPath,
-					symbolIds: /* @__PURE__ */ new Set()
-				};
-				for (const symbolId of event.symbolIds ?? []) route.symbolIds.add(symbolId);
-				events.set(key, route);
-			}
-			return [...events.values()].map((route) => ({
-				event: {
-					hostNodeId: `branch:${branch.id}:${route.hostPath.join(".")}`,
-					eventName: route.eventName,
-					symbolIds: [...route.symbolIds]
-				},
-				branch,
-				branchIndex,
-				hostPath: route.hostPath
-			}));
-		})
-	].flatMap(({ event, branch, branchIndex, hostPath, selfWakeBoundaries }) => {
-		const closureView = selfWakeBoundaries ? completeView : input.view;
-		const host = branch ? void 0 : input.view.locators.find((locator) => locator.hostNodeId === event.hostNodeId);
-		if (!host && !branch && !selfWakeBoundaries) return [];
-		const compilerGroup = input.triggerGroups.groups.find((group) => group.hostNodeId === event.hostNodeId && group.eventName === event.eventName);
-		const graphNodeIds = /* @__PURE__ */ new Set();
-		const symbolIds = new Set(event.symbolIds ?? []);
-		const selected = {
-			domUpdates: /* @__PURE__ */ new Set(),
-			behaviors: /* @__PURE__ */ new Set(),
-			branches: /* @__PURE__ */ new Set(),
-			boundaries: /* @__PURE__ */ new Set(),
-			repeats: /* @__PURE__ */ new Set(),
-			elementHandles: /* @__PURE__ */ new Set()
-		};
-		if (branch && branchIndex !== void 0) {
-			selected.branches.add(branchIndex);
-			if (branch.symbolId) symbolIds.add(branch.symbolId);
-			for (const read of branch.testReads ?? []) graphNodeIds.add(read.graphNodeId);
-			for (const arm of branch.armRecords ?? []) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
-		}
-		const adoptedBoundaryIds = /* @__PURE__ */ new Set();
-		const escalatedHostNodeIds = /* @__PURE__ */ new Set();
-		for (const boundaryIndex of selfWakeBoundaries ?? []) {
-			const servedBoundary = input.view.asyncBoundaries[boundaryIndex];
-			selected.boundaries.add(boundaryIndex);
-			collectSettledBoundaryClosure(input, completeBoundaries.get(servedBoundary.id) ?? servedBoundary, graphNodeIds, symbolIds);
-		}
-		closureView.behaviors.forEach((behavior, index) => {
-			if (selfWakeBoundaries) return;
-			const recordId = `behavior:${behavior.hostNodeId}:${behavior.symbolId ?? ""}`;
-			if ((behavior.inputGraphReads?.length ?? 0) > 0 && !compilerGroup?.payloadRecordIds.includes(recordId)) return;
-			selected.behaviors.add(index);
-			if (behavior.symbolId) symbolIds.add(behavior.symbolId);
-		});
-		let changed = true;
-		while (changed) {
-			const before = closureSize(graphNodeIds, symbolIds, selected);
-			const currentSymbolIds = Array.from(symbolIds);
-			for (const symbolId of currentSymbolIds) {
-				const bound = bounds.get(symbolId);
-				if (bound) {
-					symbolIds.add(bound.loaderSymbolId ?? bound.baseSymbolId);
-					for (const slot of bound.captureSlots) {
-						if (slot.route.kind === "graph-reference") graphNodeIds.add(slot.route.graphNodeId);
-						if (slot.route.kind === "callback-route") symbolIds.add(slot.route.callbackSymbolId);
-					}
-				}
-				const symbol = symbols.get(symbolId);
-				if (!symbol) continue;
-				if ("reads" in symbol) for (const read of symbol.reads ?? []) graphNodeIds.add(read.graphNodeId);
-				if ("writes" in symbol) for (const write of symbol.writes ?? []) graphNodeIds.add(write.graphNodeId);
-				if (symbol.kind === "async-computed-runner" || symbol.kind === "sync-computed-derive") {
-					graphNodeIds.add(symbol.graphNodeId);
-					for (const dependency of symbol.dependencies ?? []) graphNodeIds.add(dependency.graphNodeId);
-				}
-				if ("elementHandleCalls" in symbol) for (const call of symbol.elementHandleCalls ?? []) closureView.elementHandles.forEach((handle, index) => {
-					if (handle.name === call.handleName) selected.elementHandles.add(index);
-				});
-				if ("elementHandleReads" in symbol) for (const read of symbol.elementHandleReads ?? []) closureView.elementHandles.forEach((handle, index) => {
-					if (handle.handleId === read.handleId || handle.name === read.handleName) selected.elementHandles.add(index);
-				});
-			}
-			closeComputedGraph(graphNodeIds, input.state);
-			for (const computed of input.state.computed) if (computed.deriveSymbolId && graphNodeIds.has(computed.graphNodeId)) symbolIds.add(computed.deriveSymbolId);
-			for (const graphNodeId of graphNodeIds) {
-				const runnerSymbolId = closureView.asyncRunners?.[graphNodeId];
-				if (runnerSymbolId) symbolIds.add(runnerSymbolId);
-			}
-			selectViewSubscribers(closureView, graphNodeIds, symbolIds, selected);
-			const escalatedBranchIds = /* @__PURE__ */ new Set();
-			for (const index of selected.branches) {
-				const record = closureView.branches?.[index];
-				if (record?.escalates) escalatedBranchIds.add(record.id);
-			}
-			for (const index of selected.boundaries) {
-				const served = closureView.asyncBoundaries[index];
-				for (const arm of boundaryArmRecordSets(completeBoundaries.get(served.id) ?? served)) collectEscalatedArmBranchIds(arm, escalatedBranchIds);
-			}
-			for (const branchId of escalatedBranchIds) collectEscalatedBranchClosure(input, branchId, graphNodeIds, symbolIds, escalatedHostNodeIds);
-			if (!selfWakeBoundaries) input.view.asyncBoundaries.forEach((servedBoundary, index) => {
-				if (adoptedBoundaryIds.has(servedBoundary.id)) return;
-				const boundary = completeBoundaries.get(servedBoundary.id) ?? servedBoundary;
-				if (!settledArmReadGraphNodeIds(input, boundary).some((graphNodeId) => graphNodeIds.has(graphNodeId))) return;
-				adoptedBoundaryIds.add(servedBoundary.id);
-				selected.boundaries.add(index);
-				collectSettledBoundaryClosure(input, boundary, graphNodeIds, symbolIds);
-				collectSettledArmHostRecordClosure(completeView, boundary, graphNodeIds, symbolIds);
-			});
-			if (selfWakeBoundaries || adoptedBoundaryIds.size > 0) {
-				for (const symbol of symbols.values()) if (symbol.kind === "state-initializer" && graphNodeIds.has(symbol.graphNodeId)) symbolIds.add(symbol.id);
-			}
-			changed = closureSize(graphNodeIds, symbolIds, selected) !== before;
-		}
-		dropEscalatedHostRecords(closureView, selected, escalatedHostNodeIds);
-		const neededHosts = new Set(branch ? [] : [event.hostNodeId]);
-		for (const index of selected.domUpdates) neededHosts.add(closureView.domUpdates[index].hostNodeId);
-		for (const index of selected.behaviors) neededHosts.add(closureView.behaviors[index].hostNodeId);
-		for (const index of selected.repeats) neededHosts.add(closureView.keyedRepeats[index].parentHostNodeId);
-		for (const index of selected.elementHandles) neededHosts.add(closureView.elementHandles[index].hostNodeId);
-		const selectedBoundaryIds = new Set([...selected.boundaries].map((index) => closureView.asyncBoundaries[index].id));
-		const view = {
-			...input.view,
-			locators: closureView.locators.filter((locator) => neededHosts.has(locator.hostNodeId)),
-			events: branch || selfWakeBoundaries ? [] : [event],
-			domUpdates: closureView.domUpdates.filter((_, index) => selected.domUpdates.has(index)),
-			behaviors: closureView.behaviors.filter((_, index) => selected.behaviors.has(index)),
-			elementHandles: closureView.elementHandles.filter((_, index) => selected.elementHandles.has(index)),
-			keyedRepeats: closureView.keyedRepeats?.filter((_, index) => selected.repeats.has(index)),
-			branches: closureView.branches?.filter((_, index) => selected.branches.has(index)),
-			asyncBoundaries: closureView.asyncBoundaries.filter((boundary) => selectedBoundaryIds.has(boundary.id)).map((boundary) => adoptedBoundaryIds.has(boundary.id) ? completeBoundaries.get(boundary.id) ?? boundary : boundary),
-			...closureView.asyncRunners ? { asyncRunners: Object.fromEntries(Object.entries(closureView.asyncRunners).filter(([graphNodeId]) => graphNodeIds.has(graphNodeId))) } : {}
-		};
-		const graphIds = [...graphNodeIds].sort();
-		return [{
-			id: selfWakeBoundaries ? "self-wake" : branch ? `branch:${branch.id}:${event.eventName}:${hostPath.join(".")}` : `${event.hostNodeId}:${event.eventName}`,
-			hostNodeId: event.hostNodeId,
-			eventName: event.eventName,
-			hostIndex: host?.index ?? -1,
-			hostTagName: host?.tagName ?? "*",
-			...branch ? {
-				branchStartIndex: branch.startAnchor.index,
-				branchEndIndex: branch.endAnchor.index,
-				hostPath
-			} : {},
-			graphNodeIds: graphIds,
-			symbolIds: [...symbolIds].sort(),
-			state: filterState(input.state, new Set(graphIds)),
-			view,
-			...adoptedBoundaryIds.size > 0 ? { adoptsSettledArm: true } : {}
-		}];
+/** Emitted files whose contents spell a machine path, raw, URI-encoded, or inside a bundler-minted identifier. */
+function machinePathLeaks(bundle, roots) {
+	const asIdentifier = (value) => value.replace(/[^\w$]/g, "_");
+	const needles = roots.flatMap((path) => {
+		const encoded = encodeURIComponent(`${path}/`);
+		return [
+			`${path}/`,
+			encoded,
+			asIdentifier(encoded),
+			asIdentifier(`${path}/`)
+		];
 	});
-	const armRendererModuleId = groups.some((group) => group.id === "self-wake") ? triggerGroupVirtualModuleId(input.filename, groups.length) : void 0;
-	return groups.map(({ adoptsSettledArm, ...group }) => adoptsSettledArm && armRendererModuleId ? {
-		...group,
-		armRendererModuleId
-	} : group);
-}
-function settledArmReadGraphNodeIds(input, boundary) {
-	const graphNodeIds = /* @__PURE__ */ new Set();
-	for (const arm of boundaryArmRecordSets(boundary)) collectCompleteArmRecordClosure(arm, graphNodeIds, /* @__PURE__ */ new Set());
-	for (const edge of input.componentEdges ?? []) if (edge.asyncBoundaryId === boundary.id) {
-		for (const prop of edge.props) if (prop.kind === "graph-reference") graphNodeIds.add(prop.graphNodeId);
+	const leaks = [];
+	for (const [fileName, output] of Object.entries(bundle)) {
+		const item = output;
+		const contents = item.type === "chunk" ? item.code : typeof item.source === "string" ? item.source : item.source instanceof Uint8Array ? new TextDecoder().decode(item.source) : void 0;
+		if (contents && needles.some((needle) => contents.includes(needle))) leaks.push(fileName);
 	}
-	return [...graphNodeIds];
+	return leaks.sort();
 }
-function collectSettledBoundaryClosure(input, boundary, graphNodeIds, symbolIds) {
-	if (boundary.updateSymbolId) symbolIds.add(boundary.updateSymbolId);
-	for (const read of boundary.asyncReads) {
-		graphNodeIds.add(read.graphNodeId);
-		if (read.runnerSymbolId) symbolIds.add(read.runnerSymbolId);
-	}
-	for (const arm of boundaryArmRecordSets(boundary)) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
-	const settledEdgeIds = /* @__PURE__ */ new Set();
-	for (const edge of input.componentEdges ?? []) {
-		if (edge.asyncBoundaryId !== boundary.id) continue;
-		settledEdgeIds.add(edge.id);
-		for (const prop of edge.props) if (prop.kind === "graph-reference") graphNodeIds.add(prop.graphNodeId);
-	}
-	for (const row of input.boundRows) if (row.componentEdgePath.some((edgeId) => settledEdgeIds.has(edgeId))) symbolIds.add(row.id);
-}
-function collectSettledArmHostRecordClosure(completeView, boundary, graphNodeIds, symbolIds) {
-	const armHosts = /* @__PURE__ */ new Set();
-	for (const arm of boundaryArmRecordSets(boundary)) for (const locator of arm.locators ?? []) armHosts.add(locator.hostNodeId);
-	if (armHosts.size === 0) return;
-	for (const record of completeView.events) if (armHosts.has(record.hostNodeId)) for (const symbolId of record.symbolIds ?? []) symbolIds.add(symbolId);
-	for (const record of completeView.domUpdates) if (armHosts.has(record.hostNodeId)) {
-		graphNodeIds.add(record.graphNodeId);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-	}
-	for (const record of completeView.behaviors) if (armHosts.has(record.hostNodeId)) {
-		for (const read of record.inputGraphReads ?? []) graphNodeIds.add(read.graphNodeId);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-	}
-	for (const record of completeView.keyedRepeats ?? []) if (armHosts.has(record.parentHostNodeId)) {
-		if (record.collectionGraphNodeId) graphNodeIds.add(record.collectionGraphNodeId);
-		for (const rowEvent of record.rowEvents) for (const symbolId of rowEvent.symbolIds ?? []) symbolIds.add(symbolId);
+function realpathOrSelf(path) {
+	try {
+		return normalize(realpathSync(path));
+	} catch {
+		return normalize(path);
 	}
 }
-function dropEscalatedHostRecords(view, selected, hostNodeIds) {
-	if (hostNodeIds.size === 0) return;
-	const drop = (indexes, hostOf) => {
-		for (const index of indexes) if (hostNodeIds.has(hostOf(index) ?? "")) indexes.delete(index);
-	};
-	drop(selected.domUpdates, (index) => view.domUpdates[index]?.hostNodeId);
-	drop(selected.behaviors, (index) => view.behaviors[index]?.hostNodeId);
-	drop(selected.elementHandles, (index) => view.elementHandles[index]?.hostNodeId);
-	drop(selected.repeats, (index) => view.keyedRepeats?.[index]?.parentHostNodeId);
-}
-function collectEscalatedArmBranchIds(arm, branchIds) {
-	for (const branch of arm.branches ?? []) {
-		if (!branch.symbolId && (branch.testReads?.length ?? 0) > 0) branchIds.add(branch.id);
-		for (const nested of branch.armRecords ?? []) collectEscalatedArmBranchIds(nested, branchIds);
+function rootRelativeRegionComments(bundle, root) {
+	if (!root) return;
+	for (const output of Object.values(bundle)) {
+		const chunk = output;
+		if (chunk.type !== "chunk" || !chunk.code?.includes("//#region ")) continue;
+		chunk.code = chunk.code.replace(/^(\/\/#region (?:\\0)?)(.+)$/gm, (_, prefix, id) => `${prefix}${rootRelativeId(id, root)}`);
 	}
 }
-function collectEscalatedBranchClosure(input, branchSiteId, graphNodeIds, symbolIds, hostNodeIds) {
-	const renderData = input.renderData;
-	const branch = renderData?.branches.find((candidate) => candidate.branchSiteId === branchSiteId);
-	if (!renderData || !branch) return;
-	const chunks = new Map(renderData.chunks.map((chunk) => [chunk.id, chunk]));
-	const edgeIds = /* @__PURE__ */ new Set();
-	const walked = /* @__PURE__ */ new Set();
-	const walk = (chunkId) => {
-		if (!chunkId || walked.has(chunkId)) return;
-		walked.add(chunkId);
-		const chunk = chunks.get(chunkId);
-		if (!chunk) return;
-		for (const host of chunk.hosts) hostNodeIds.add(host.hostNodeId);
-		for (const slot of chunk.slots) if (slot.kind === "child-component") {
-			edgeIds.add(slot.componentEdgeId);
-			walk(slot.childTemplateId);
-			walk(slot.projectionChunkId);
-		} else if (slot.kind === "branch") for (const armId of slot.armTemplateIds) walk(armId);
-		else if (slot.kind === "repeat") {
-			walk(slot.rowTemplateId);
-			walk(slot.emptyTemplateId);
-		} else if (slot.kind === "async") {
-			walk(slot.armTemplateIds.try);
-			walk(slot.armTemplateIds.pending);
-			walk(slot.armTemplateIds.catch);
-		} else if (slot.kind === "dynamic-host") walk(slot.childChunkId);
-		else if ("residue" in slot && slot.residue.kind === "graph-read") graphNodeIds.add(slot.residue.graphNodeId);
-	};
-	for (const armId of branch.armChunkIds) walk(armId);
-	for (const symbol of input.symbolResolver.symbols) if (symbol.kind === "dom-update" && hostNodeIds.has(symbol.hostNodeId)) graphNodeIds.add(symbol.graphNodeId);
-	for (const symbol of input.symbolResolver.symbols) if ("hostNodeId" in symbol && hostNodeIds.has(symbol.hostNodeId) || symbol.kind === "callback-prop" && edgeIds.has(symbol.componentEdgeId) || (symbol.kind === "state-initializer" || symbol.kind === "sync-computed-derive" || symbol.kind === "async-computed-runner") && graphNodeIds.has(symbol.graphNodeId)) symbolIds.add(symbol.id);
-	for (const row of input.boundRows) if (row.componentEdgePath.some((edgeId) => edgeIds.has(edgeId))) symbolIds.add(row.id);
-}
-function boundaryArmRecordSets(boundary) {
-	return Array.isArray(boundary.armRecords) ? boundary.armRecords : boundary.armRecords ? [boundary.armRecords] : [];
-}
-function unsettledAsyncBoundaryIndexes(state, view) {
-	const computed = new Map(state.computed.map((record) => [record.graphNodeId, record]));
-	const runners = { ...view.asyncRunners };
-	for (const boundary of view.asyncBoundaries) for (const read of boundary.asyncReads) if (read.runnerSymbolId) runners[read.graphNodeId] ??= read.runnerSymbolId;
-	return view.asyncBoundaries.flatMap((boundary, index) => {
-		const reachable = new Set(boundary.asyncReads.map((read) => read.graphNodeId));
-		for (const graphNodeId of reachable) {
-			const record = computed.get(graphNodeId);
-			if (!record) continue;
-			if (runners[graphNodeId] && record.snapshot?.status !== "fulfilled" && record.snapshot?.status !== "rejected") return [index];
-			for (const dependency of record.dependencies ?? []) reachable.add(dependency.graphNodeId);
-		}
-		return [];
-	});
-}
-function selectViewSubscribers(view, graphNodeIds, symbolIds, selected) {
-	view.domUpdates.forEach((record, index) => {
-		if (!graphNodeIds.has(record.graphNodeId)) return;
-		selected.domUpdates.add(index);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-	});
-	view.behaviors.forEach((record, index) => {
-		if (!(record.inputGraphReads ?? []).some((read) => graphNodeIds.has(read.graphNodeId))) return;
-		selected.behaviors.add(index);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-	});
-	(view.branches ?? []).forEach((record, index) => {
-		if (!(record.testReads ?? []).some((read) => graphNodeIds.has(read.graphNodeId))) return;
-		selected.branches.add(index);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-		for (const arm of record.armRecords ?? []) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
-	});
-	view.asyncBoundaries.forEach((record, index) => {
-		if (!record.asyncReads.some((read) => graphNodeIds.has(read.graphNodeId))) return;
-		selected.boundaries.add(index);
-		if (record.updateSymbolId) symbolIds.add(record.updateSymbolId);
-		for (const read of record.asyncReads) if (read.runnerSymbolId) symbolIds.add(read.runnerSymbolId);
-		const arms = Array.isArray(record.armRecords) ? record.armRecords : record.armRecords ? [record.armRecords] : [];
-		for (const arm of arms) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
-	});
-	(view.keyedRepeats ?? []).forEach((record, index) => {
-		if (!record.collectionGraphNodeId || !graphNodeIds.has(record.collectionGraphNodeId)) return;
-		selected.repeats.add(index);
-		for (const rowEvent of record.rowEvents) for (const symbolId of rowEvent.symbolIds ?? []) symbolIds.add(symbolId);
-	});
-}
-function collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds) {
-	for (const event of arm.events ?? []) for (const symbolId of event.symbolIds ?? []) symbolIds.add(symbolId);
-	for (const update of arm.domUpdates ?? []) {
-		if (typeof update.graphNodeId === "string") graphNodeIds.add(update.graphNodeId);
-		if (typeof update.symbolId === "string") symbolIds.add(update.symbolId);
-	}
-	for (const behavior of arm.behaviors ?? []) {
-		for (const read of behavior.inputGraphReads ?? []) if (typeof read.graphNodeId === "string") graphNodeIds.add(read.graphNodeId);
-		if (typeof behavior.symbolId === "string") symbolIds.add(behavior.symbolId);
-	}
-	for (const repeat of arm.keyedRepeats ?? []) {
-		if (repeat.collectionGraphNodeId) graphNodeIds.add(repeat.collectionGraphNodeId);
-		for (const event of repeat.rowEvents) for (const symbolId of event.symbolIds ?? []) symbolIds.add(symbolId);
+//#endregion
+//#region src/module-id.ts
+const linkedPackagesByRoot = /* @__PURE__ */ new Map();
+const mintedSources = /* @__PURE__ */ new Map();
+const mintedIds = /* @__PURE__ */ new Map();
+function moduleIdFor(filename, root) {
+	if (!root || !isAbsolute(filename)) return filename;
+	const key = `${root}\0${filename}`;
+	let id = mintedIds.get(key);
+	if (id === void 0) {
+		const relativeId = relative(root, filename);
+		id = !relativeId.startsWith("..") && !relativeId.includes("node_modules/") ? relativeId : packageRootedModuleId(filename, root) ?? (outsideCheckout(filename, root) ? namedPackageModuleId(filename) : null) ?? relativeId;
+		mintedIds.set(key, id);
 	}
-	for (const branch of arm.branches ?? []) {
-		if (branch.symbolId) symbolIds.add(branch.symbolId);
-		for (const read of branch.testReads ?? []) graphNodeIds.add(read.graphNodeId);
-		for (const nested of branch.armRecords ?? []) collectCompleteArmRecordClosure(nested, graphNodeIds, symbolIds);
+	mintedSources.set(`${root}\0${id}`, filename);
+	return id;
+}
+/** The file a module id names, spelled the way the bundler resolved it. */
+function sourceForModuleId(moduleId, root) {
+	if (!root || isAbsolute(moduleId)) return moduleId;
+	return mintedSources.get(`${root}\0${moduleId}`) ?? realpathOf(resolve(root, moduleId));
+}
+function packageRootedModuleId(filename, root) {
+	const real = realpathOf(filename);
+	for (const linked of linkedPackages(root)) {
+		if (real === linked.real) return linked.id;
+		if (real.startsWith(`${linked.real}/`)) return `${linked.id}${real.slice(linked.real.length)}`;
 	}
+	return null;
 }
-function closeComputedGraph(graphNodeIds, state) {
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const computed of state.computed) {
-			const dependencies = computed.dependencies ?? [];
-			if (!graphNodeIds.has(computed.graphNodeId) && !dependencies.some((dependency) => graphNodeIds.has(dependency.graphNodeId))) continue;
-			if (!graphNodeIds.has(computed.graphNodeId)) {
-				graphNodeIds.add(computed.graphNodeId);
-				changed = true;
-			}
-			for (const dependency of dependencies) if (!graphNodeIds.has(dependency.graphNodeId)) {
-				graphNodeIds.add(dependency.graphNodeId);
-				changed = true;
-			}
+function outsideCheckout(filename, root) {
+	const real = realpathOf(filename);
+	return !machinePathRoots(root).some((checkout) => filename.startsWith(`${checkout}/`) || real.startsWith(`${checkout}/`));
+}
+function namedPackageModuleId(filename) {
+	const real = realpathOf(filename);
+	for (let directory = dirname(real); dirname(directory) !== directory; directory = dirname(directory)) {
+		let name;
+		try {
+			name = JSON.parse(readFileSync(join(directory, "package.json"), "utf8")).name;
+		} catch {
+			continue;
 		}
+		if (typeof name === "string" && name) return `node_modules/${name}${real.slice(directory.length)}`;
 	}
+	return null;
+}
+function linkedPackages(root) {
+	const cached = linkedPackagesByRoot.get(root);
+	if (cached) return cached;
+	const directory = join(root, "node_modules");
+	const packages = [];
+	for (const name of packageNames(directory)) try {
+		packages.push({
+			id: `node_modules/${name}`,
+			real: realpathOf(join(directory, name))
+		});
+	} catch {}
+	packages.sort((a, b) => b.real.length - a.real.length);
+	linkedPackagesByRoot.set(root, packages);
+	return packages;
 }
-function filterState(state, graphNodeIds) {
-	return {
-		...state,
-		cells: state.cells.filter((cell) => graphNodeIds.has(cell.graphNodeId)),
-		computed: state.computed.filter((computed) => graphNodeIds.has(computed.graphNodeId)),
-		storage: state.storage?.filter((cell) => graphNodeIds.has(cell.graphNodeId)),
-		sharedDefinitions: state.sharedDefinitions?.filter((definition) => definition.graphNodeIds.some((graphNodeId) => graphNodeIds.has(graphNodeId)))
-	};
-}
-function closureSize(graphNodeIds, symbolIds, selected) {
-	return graphNodeIds.size + symbolIds.size + Object.values(selected).reduce((total, records) => total + records.size, 0);
-}
-//#endregion
-//#region src/virtual-ids.ts
-const TSRX_SOURCE_FILE = /\.tsrx(?:[?#].*)?$/;
-const MARKLESS_SYMBOL_SOURCE_QUERY_RE = /[?&]markless-symbols(?:[&#]|$)/;
-const MARKLESS_RESUME_SOURCE_QUERY_RE = /[?&]markless-resume(?:[&#]|$)/;
-const MARKLESS_RENDER_DATA_SOURCE_QUERY_RE = /[?&]markless-render-data(?:[&#]|$)/;
-const MARKLESS_REACHED_FROM_SOURCE_QUERY = "markless-reached-from";
-const MARKLESS_REACHED_FROM_ROUTE = "route";
-const MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE = /[?&]markless-prerender-wake(?:[&#]|$)/;
-const MARKLESS_ROUTE_SOURCE_QUERY_RE = /[?&]markless-route(?:[&#]|$)/;
-const RESUME_VIRTUAL_ID_RE = /^virtual:markless:resume:([^:]+)$/;
-const PRERENDER_WAKE_VIRTUAL_ID_RE = /^virtual:markless:prerender-wake:([^:]+)$/;
-const SETTLE_VIRTUAL_ID_RE = /^virtual:markless:settle:([^:]+)$/;
-const SYMBOL_VIRTUAL_STRING_RE = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1/g;
-function stripBuildPrefix(fileName) {
-	return fileName.startsWith("build/") ? fileName.slice(MARKLESS_BUILD_PREFIX.length) : fileName;
-}
-function virtualModuleSourceForLoad(module, options) {
-	if (!options.dev || module.type !== "resolver") return module.source;
-	if (!module.source.includes("moduleUrls[row[0]]")) return module.source;
-	return module.source.replace(SYMBOL_VIRTUAL_STRING_RE, (_match, _quote, virtualId) => JSON.stringify(devBrowserVirtualModuleUrl(virtualId, options.publicPath)));
-}
-function devBrowserSourceModuleUrl(source, _root, publicPath) {
-	const path = withQuery(joinURL("@fs", withoutLeadingSlash(source)), { import: null });
-	return publicPath ? publicPath(path) : joinURL("/", path);
-}
-function devBrowserVirtualModuleUrl(virtualId, publicPath) {
-	const path = joinURL("@id", resolveVirtualId(virtualId).replace("\0", "__x00__"));
-	return publicPath ? publicPath(path) : joinURL("/", path);
-}
-function clientSymbolEntries(input, root) {
-	if (!input || typeof input !== "object" || Array.isArray(input)) return [];
-	const sources = [];
-	for (const [name, value] of Object.entries(input)) {
-		if (!/symbol/i.test(name)) continue;
-		for (const entry of inputEntryValues(value)) if (typeof entry === "string" && TSRX_SOURCE_FILE.test(entry)) sources.push(normalizeInputSource(entry, root));
+function packageNames(directory) {
+	let entries;
+	try {
+		entries = readdirSync(directory);
+	} catch {
+		return [];
 	}
-	return sources;
-}
-function inputEntryValues(value) {
-	return Array.isArray(value) ? value.flatMap(inputEntryValues) : [value];
-}
-function normalizeInputSource(source, root) {
-	const path = pathname(source);
-	if (isAbsolute(path)) return path;
-	return pathname(resolve(root ?? "", path));
-}
-function isSymbolOnlySourceRequest(id) {
-	return MARKLESS_SYMBOL_SOURCE_QUERY_RE.test(id);
-}
-function isScalarPlanSourceRequest(id) {
-	return isSymbolOnlySourceRequest(id) && new URLSearchParams(parsePath(id).search).has("markless-scalar-plans");
-}
-function isResumeSourceRequest(id) {
-	return MARKLESS_RESUME_SOURCE_QUERY_RE.test(id);
-}
-function isRenderDataSourceRequest(id) {
-	return MARKLESS_RENDER_DATA_SOURCE_QUERY_RE.test(id);
-}
-function renderDataReachedFromQuery(id) {
-	return new URLSearchParams(parsePath(id).search).get(MARKLESS_REACHED_FROM_SOURCE_QUERY) ?? void 0;
-}
-function isRouteNavigationSourceRequest(id) {
-	return MARKLESS_ROUTE_SOURCE_QUERY_RE.test(id) || isRenderDataSourceRequest(id) && renderDataReachedFromQuery(id) === void 0;
-}
-function materializedReachedRenderDataSource(source) {
-	return withQuery(source, {
-		"markless-render-data": null,
-		[MARKLESS_REACHED_FROM_SOURCE_QUERY]: MARKLESS_REACHED_FROM_ROUTE
-	});
-}
-function sharedReachedRenderDataRequest(id) {
-	if (!isRenderDataSourceRequest(id)) return void 0;
-	const reachedFrom = renderDataReachedFromQuery(id);
-	return reachedFrom === void 0 || reachedFrom === MARKLESS_REACHED_FROM_ROUTE ? void 0 : withQuery(id, { [MARKLESS_REACHED_FROM_SOURCE_QUERY]: MARKLESS_REACHED_FROM_ROUTE });
-}
-function isPrerenderWakeSourceRequest(id) {
-	return MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE.test(id);
-}
-function isClientPrimarySourceRequest(id) {
-	return !(MARKLESS_SYMBOL_SOURCE_QUERY_RE.test(id) || MARKLESS_RESUME_SOURCE_QUERY_RE.test(id) || MARKLESS_RENDER_DATA_SOURCE_QUERY_RE.test(id) || MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE.test(id) || MARKLESS_ROUTE_SOURCE_QUERY_RE.test(id));
-}
-function clientRouteArtifactReference(source) {
-	const symbolSource = source.includes("?") ? `${source}&markless-symbols` : `${source}?markless-symbols`;
-	const renderDataSource = source.includes("?") ? `${source}&markless-render-data` : `${source}?markless-render-data`;
-	return [
-		`const [symbolModule, renderDataModule] = await Promise.all([import(${JSON.stringify(symbolSource)}), import(${JSON.stringify(renderDataSource)})]);`,
-		"const marklessRouteArtifact = {",
-		"	renderData: renderDataModule.marklessPrerenderData,",
-		"	loadSymbol: symbolModule.loadSymbol,",
-		"};",
-		"export default marklessRouteArtifact;"
-	].join("\n");
-}
-function sourceForSymbolVirtualImporter(importer) {
-	if (!importer) return null;
-	return symbolVirtualModuleSourceFile(normalizeVirtualId(importer));
-}
-function sourceForResumeVirtualImporter(importer) {
-	if (!importer) return null;
-	const match = normalizeVirtualId(importer).match(RESUME_VIRTUAL_ID_RE);
-	return match?.[1] ? decodeURIComponent(match[1]) : null;
-}
-function resolverVirtualModuleSourceFile(id) {
-	const prefix = `${MARKLESS_VIRTUAL_PREFIX}resolver:`;
-	return id.startsWith(prefix) ? decodeURIComponent(id.slice(prefix.length)) : null;
-}
-function sourceForTriggerGroupVirtualImporter(importer) {
-	if (!importer) return null;
-	return triggerGroupVirtualModuleSourceFile(normalizeVirtualId(importer));
-}
-function sourceForPrerenderWakeVirtualImporter(importer) {
-	if (!importer) return null;
-	const match = normalizeVirtualId(importer).match(PRERENDER_WAKE_VIRTUAL_ID_RE);
-	return match?.[1] ? decodeURIComponent(match[1]) : null;
-}
-function sourceForSettleVirtualImporter(importer) {
-	if (!importer) return null;
-	const match = normalizeVirtualId(importer).match(SETTLE_VIRTUAL_ID_RE);
-	return match?.[1] ? decodeURIComponent(match[1]) : null;
-}
-function isRelativeImport(source) {
-	return source.startsWith("./") || source.startsWith("../");
-}
-function isMarklessRuntimeModule(id) {
-	const path = pathname(id);
-	return /[/\\](?:web|runtime|serializer)[/\\]src[/\\].+\.ts$/.test(path);
-}
-function executionLogRuntimeModuleId(id) {
-	const path = pathname(id);
-	const match = path.match(/[/\\](web|runtime|serializer)[/\\]src[/\\]([^?#]+)\.ts$/);
-	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : path;
-}
-function normalizeVirtualId(id) {
-	const bare = id.startsWith("\0") ? id.slice(1) : id;
-	if (!bare.startsWith("virtual:markless:")) return bare;
-	const queryIndex = bare.indexOf("?");
-	const segments = (queryIndex === -1 ? bare : bare.slice(0, queryIndex)).slice(17).split(":").map((segment) => {
+	return entries.flatMap((entry) => {
+		if (entry.startsWith(".")) return [];
+		if (!entry.startsWith("@")) return [entry];
 		try {
-			return encodeURIComponent(decodeURIComponent(segment));
+			return readdirSync(join(directory, entry)).map((scoped) => `${entry}/${scoped}`);
 		} catch {
-			return segment;
+			return [];
 		}
 	});
-	return `${MARKLESS_VIRTUAL_PREFIX}${segments.join(":")}`;
 }
-function emittedBundleModuleIds(bundle) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const output of Object.values(bundle)) {
-		if (!output || typeof output !== "object") continue;
-		const chunk = output;
-		if (chunk.type !== "chunk") continue;
-		if (typeof chunk.facadeModuleId === "string") ids.add(normalizeVirtualId(chunk.facadeModuleId));
-		if (Array.isArray(chunk.moduleIds)) {
-			for (const id of chunk.moduleIds) if (typeof id === "string") ids.add(normalizeVirtualId(id));
-		}
+function realpathOf(path) {
+	try {
+		return normalize(realpathSync(path));
+	} catch {
+		return normalize(path);
 	}
-	return ids;
 }
-function resolveVirtualId(id) {
-	if (id.startsWith("\0")) return id;
-	return `\0${id}`;
+/** A symbol module's execution-log identity: its virtual id with the source spelled root-relative. */
+function symbolExecutionLogId(virtualModuleId, root) {
+	const bare = virtualModuleId.startsWith("\0") ? virtualModuleId.slice(1) : virtualModuleId;
+	const source = symbolVirtualModuleSourceFile(bare);
+	if (source === null) return bare;
+	const encodedSymbolId = bare.slice(bare.lastIndexOf(":") + 1);
+	return symbolVirtualModuleId(moduleIdFor(source, root), decodeURIComponent(encodedSymbolId));
 }
-function pathname(id) {
-	return parsePath(id).pathname;
-}
-const CLIENT_ONLY_SOURCE_QUERY_KEYS = /* @__PURE__ */ new Set([
-	"markless-render-data",
-	"markless-reached-from",
-	"markless-symbols",
-	"markless-scalar-plans"
-]);
-function serverSharedSourceRequest(id, environment) {
-	if (environment !== "server") return void 0;
-	const { pathname: path, search } = parsePath(id);
-	if (!search || !TSRX_SOURCE_FILE.test(path)) return void 0;
-	const keys = [...new URLSearchParams(search).keys()];
-	return keys.length > 0 && keys.every((key) => CLIENT_ONLY_SOURCE_QUERY_KEYS.has(key)) ? path : void 0;
-}
-//#endregion
-//#region src/build/planned-landing.ts
-const MARKLESS_INTERACTION_CLOSURES_ASSET = MARKLESS_INTERACTION_CLOSURES;
-function plannedLandingFiles(bundle) {
-	const asset = bundle[MARKLESS_INTERACTION_CLOSURES_ASSET];
-	if (asset?.type !== "asset" || asset.source === void 0) return void 0;
-	const parsed = JSON.parse(typeof asset.source === "string" ? asset.source : new TextDecoder().decode(asset.source));
-	const planned = /* @__PURE__ */ new Map();
-	for (const route of parsed.routes) if (!route.fallback && route.files) planned.set(route.route, new Set(route.files.firstUse));
-	return planned;
+const EMBEDDED_SOURCE_RE = new RegExp(`^(${String.fromCharCode(0)}?(?:virtual:markless:[a-z-]+:|imported:))([^:?]*)(.*)$`, "s");
+/**
+* Any id a build writes into output, with the file it names spelled by `moduleIdFor`:
+* a bare path, `virtual:markless:<kind>:<source>...` or `imported:<source>:...`,
+* the source raw or URI-encoded. Other ids pass through unchanged.
+*/
+function rootRelativeId(id, root) {
+	if (!root) return id;
+	if (isAbsolute(id)) {
+		const query = id.search(/[?#]/);
+		return query < 0 ? moduleIdFor(id, root) : `${moduleIdFor(id.slice(0, query), root)}${id.slice(query)}`;
+	}
+	const match = EMBEDDED_SOURCE_RE.exec(id);
+	if (!match) return id;
+	const [, prefix, spelled, rest] = match;
+	let source;
+	try {
+		source = decodeURIComponent(spelled);
+	} catch {
+		return id;
+	}
+	if (!isAbsolute(source)) return id;
+	const moduleId = moduleIdFor(source, root);
+	return `${prefix}${spelled === source ? moduleId : encodeURIComponent(moduleId)}${rest}`;
 }
 //#endregion
 //#region src/build/warm-packs.ts
@@ -2417,7 +2174,8 @@ const PACK_COST_MODEL = {
 	fileOverheadGzipKb: .5,
 	lazySiblingOverheadGzipKb: 1,
 	minDeferredGzipKb: 1,
-	sourceGzipRatio: .25
+	sourceGzipRatio: .25,
+	packedModuleWrapperBytes: 64
 };
 function estimatedGzipKb(sourceLength, model = PACK_COST_MODEL) {
 	return sourceLength * model.sourceGzipRatio / 1024;
@@ -2622,7 +2380,77 @@ function planRoutePackGroups(input) {
 			}
 		}
 	}
-	return input.pagesLoadOneRoute ? splitFrameworkFromApp(splitStartupPacksByStaticReach(groups, roots, sources, owners, input), input) : groups;
+	for (const [id, pack] of alternativeDeferredPacks(input.modules, groups)) groups.set(id, pack);
+	return splitOversizedLazyPacks(input.pagesLoadOneRoute ? splitOversizedStartupPacks(splitFrameworkFromApp(splitStartupPacksByStaticReach(groups, roots, sources, owners, input), input), input) : groups, input);
+}
+function splitOversizedStartupPacks(groups, input) {
+	const cap = input.maxPackBytes;
+	if (!cap) return groups;
+	const packs = /* @__PURE__ */ new Map();
+	for (const [id, group] of groups) if (isStartupPack(group)) push(packs, group, id);
+	const sizeOf = (id) => (input.modules.get(id)?.size ?? 0) + PACK_COST_MODEL.packedModuleWrapperBytes;
+	const routeRoots = [...input.routes.values()].flat();
+	for (const [group, ids] of packs) {
+		if (ids.reduce((sum, id) => sum + sizeOf(id), 0) <= cap) continue;
+		const members = new Set(ids);
+		const order = [];
+		const seen = /* @__PURE__ */ new Set();
+		const visit = (start) => {
+			const stack = [[start, 0]];
+			seen.add(start);
+			while (stack.length) {
+				const top = stack[stack.length - 1];
+				const dependencies = input.modules.get(top[0])?.dependencies ?? [];
+				const next = dependencies.slice(top[1]).findIndex((dependency) => members.has(dependency) && !seen.has(dependency));
+				if (next < 0) {
+					order.push(top[0]);
+					stack.pop();
+					continue;
+				}
+				const dependency = dependencies[top[1] + next];
+				top[1] += next + 1;
+				seen.add(dependency);
+				stack.push([dependency, 0]);
+			}
+		};
+		for (const id of [...routeRoots.filter((id) => members.has(id)), ...[...ids].sort()]) if (!seen.has(id)) visit(id);
+		let piece = 1;
+		let filled = 0;
+		for (const id of order) {
+			const size = sizeOf(id);
+			if (filled > 0 && filled + size > cap) {
+				piece++;
+				filled = 0;
+			}
+			filled += size;
+			if (piece > 1) groups.set(id, `${group}~${piece}`);
+		}
+	}
+	return groups;
+}
+function splitOversizedLazyPacks(groups, input) {
+	const cap = input.maxPackBytes;
+	if (!cap) return groups;
+	const packs = /* @__PURE__ */ new Map();
+	for (const [id, group] of groups) if (!isStartupPack(group)) push(packs, group, id);
+	const sizeOf = (id) => (input.modules.get(id)?.size ?? 0) + PACK_COST_MODEL.packedModuleWrapperBytes;
+	for (const [group, ids] of packs) {
+		if (ids.reduce((sum, id) => sum + sizeOf(id), 0) <= cap) continue;
+		const bySource = /* @__PURE__ */ new Map();
+		for (const id of ids) push(bySource, input.modules.get(id)?.source ?? id, id);
+		let part = 0;
+		let filled = Infinity;
+		for (const [, members] of [...bySource].sort(([left], [right]) => left.localeCompare(right))) {
+			const size = members.reduce((sum, id) => sum + sizeOf(id), 0);
+			if (filled + size > cap) {
+				part++;
+				filled = 0;
+			}
+			filled += size;
+			for (const id of members) groups.set(id, part === 1 ? group : `${group}${PACK_PART_MARK}${part}`);
+		}
+	}
+	return groups;
 }
 function splitFrameworkFromApp(groups, input) {
 	const halves = /* @__PURE__ */ new Map();
@@ -2653,6 +2481,15 @@ function splitStartupPacksByStaticReach(groups, roots, sources, owners, input) {
 		return !!module && !module.navigationOnly && (!flagged || !!module.firstEvent);
 	};
 	const handler = (id) => !!input.modules.get(id)?.handler;
+	const seedSiblings = /* @__PURE__ */ new Map();
+	const seedSiblingsOf = (source) => {
+		let list = seedSiblings.get(source);
+		if (!list) seedSiblings.set(source, list = (sources.get(source) ?? []).filter(seed).map((id) => ({
+			id,
+			handler: handler(id)
+		})));
+		return list;
+	};
 	const closure = (route, start, path) => {
 		const reached = /* @__PURE__ */ new Set();
 		const handlers = /* @__PURE__ */ new Set();
@@ -2664,8 +2501,9 @@ function splitStartupPacksByStaticReach(groups, roots, sources, owners, input) {
 			if (!module) continue;
 			reached.add(id);
 			pending.push(...module.dependencies);
-			for (const sibling of module.source ? sources.get(module.source) ?? [] : []) if (seed(sibling) && sibling !== id) if (handler(sibling)) handlers.add(sibling);
-			else pending.push(sibling);
+			if (!module.source) continue;
+			for (const sibling of seedSiblingsOf(module.source)) if (sibling.id !== id) if (sibling.handler) handlers.add(sibling.id);
+			else pending.push(sibling.id);
 		}
 		return {
 			reached,
@@ -2673,11 +2511,13 @@ function splitStartupPacksByStaticReach(groups, roots, sources, owners, input) {
 		};
 	};
 	const staticReach = /* @__PURE__ */ new Set();
+	const ownHandlers = /* @__PURE__ */ new Map();
+	for (const [id, routes] of owners) if (routes.size === 1 && seed(id) && handler(id)) push(ownHandlers, [...routes][0], id);
 	for (const [route, ids] of input.routes) {
 		const visited = /* @__PURE__ */ new Set();
 		const first = closure(route, ids.filter((id) => seed(id) && !handler(id)), visited);
 		for (const id of first.reached) visited.add(id);
-		const candidates = [...first.handlers, ...[...owners].filter(([id, routes]) => routes.size === 1 && routes.has(route) && seed(id) && handler(id)).map(([id]) => id)];
+		const candidates = [...first.handlers, ...ownHandlers.get(route) ?? []];
 		while (candidates.length) {
 			const id = candidates.pop();
 			if (visited.has(id)) continue;
@@ -2723,6 +2563,14 @@ function startupPackOfLazy(name) {
 	return name.replace(new RegExp(`^(route|shared)${LAZY_PACK_MARK}`), "$1");
 }
 const LAZY_PACK_MARK = "-lazy";
+const PACK_PART_MARK = "-part";
+function packOfPiece(name) {
+	return name.replace(PACK_PIECES, "");
+}
+const PACK_PIECES = /(?:~\d+)+$/;
+function packOfPart(name) {
+	return name.replace(new RegExp(`${PACK_PART_MARK}\\d+$`), "");
+}
 const FRAMEWORK_PIECE = "~1";
 const ROUTE_KEY_SEPARATOR = "\n";
 const SHARED_MARK = "	";
@@ -2747,5 +2595,45 @@ function push(map, key, value) {
 	if (values) values.push(value);
 	else map.set(key, [value]);
 }
+/**
+* An app module that imports several deferred targets picks one per run (a table of loaders), so
+* each target, with the code only it reaches, gets a deferred pack of its own instead of the one
+* every deferred module shares: choosing one never downloads the others.
+*/
+function alternativeDeferredPacks(modules, groups) {
+	const deferred = (id) => groups.get(id) === MARKLESS_DEFERRED_PACK;
+	const alternatives = /* @__PURE__ */ new Set();
+	const entries = /* @__PURE__ */ new Set();
+	for (const [id, module] of modules) {
+		const targets = (module.dynamicDependencies ?? []).filter(deferred);
+		for (const target of targets) if (!deferred(id)) entries.add(target);
+		if (!module.app || targets.length < 2) continue;
+		for (const target of targets) if (modules.get(target)?.app) alternatives.add(target);
+	}
+	const packs = /* @__PURE__ */ new Map();
+	if (alternatives.size === 0) return packs;
+	const closure = (from, stop) => {
+		const reached = /* @__PURE__ */ new Set();
+		const pending = [from];
+		for (let id = pending.pop(); id !== void 0; id = pending.pop()) {
+			if (reached.has(id) || !deferred(id) || id !== from && stop(id)) continue;
+			reached.add(id);
+			const module = modules.get(id);
+			pending.push(...module?.dependencies ?? [], ...module?.dynamicDependencies ?? []);
+		}
+		return reached;
+	};
+	const shared = /* @__PURE__ */ new Set();
+	for (const entry of entries) if (!alternatives.has(entry)) for (const id of closure(entry, (id) => alternatives.has(id))) shared.add(id);
+	const owner = /* @__PURE__ */ new Map();
+	for (const root of alternatives) for (const id of closure(root, (id) => alternatives.has(id))) owner.set(id, owner.has(id) && owner.get(id) !== root ? null : root);
+	const labels = /* @__PURE__ */ new Map();
+	for (const [id, root] of owner) {
+		if (root === null || shared.has(id) || !modules.get(id)?.app) continue;
+		if (!labels.has(root)) labels.set(root, `${MARKLESS_DEFERRED_PACK}-alt${labels.size}`);
+		packs.set(id, labels.get(root));
+	}
+	return packs;
+}
 //#endregion
-export { MARKLESS_BUNDLE_GRAPH as $, isSymbolOnlySourceRequest as A, executionLogVirtualModuleSource as At, sourceForResumeVirtualImporter as B, isMarklessRuntimeModule as C, symbolVirtualModuleId as Ct, isResumeSourceRequest as D, MARKLESS_EXECUTION_LOG_GLOBAL as Dt, isRenderDataSourceRequest as E, EXECUTION_LOG_DISPATCH_MODULE_IDS as Et, resolveVirtualId as F, requalifyExecutionLogModuleHook as Ft, virtualModuleSourceForLoad as G, sourceForSymbolVirtualImporter as H, resolverVirtualModuleSourceFile as I, planModulePreloadUrls as It, planPrerenderTriggerGroups as J, emitPrerenderBoundaryRendererModule as K, serverSharedSourceRequest as L, planModulePreloads as Lt, normalizeVirtualId as M, injectExecutionLogModuleHook as Mt, pathname as N, isExecutionLogChunk as Nt, isRouteNavigationSourceRequest as O, MARKLESS_EXECUTION_LOG_MODULE_ID as Ot, renderDataReachedFromQuery as P, normalizeExecutionLogMode as Pt, MARKLESS_BUILD_PREFIX as Q, sharedReachedRenderDataRequest as R, isClientPrimarySourceRequest as S, symbolEntryVirtualModuleId as St, isRelativeImport as T, withoutFirstUse as Tt, sourceForTriggerGroupVirtualImporter as U, sourceForSettleVirtualImporter as V, stripBuildPrefix as W, adaptImportedCaptureResolver as X, triggerGroupVirtualModuleId as Y, MARKLESS_BUILD_METADATA_FILES as Z, clientSymbolEntries as _, prerenderWakeVirtualModuleSourceFile as _t, isStartupPack as a, outputDefaults as at, emittedBundleModuleIds as b, scopedSymbolExportName as bt, planRoutePackGroups as c, STORAGE_FREE_RESUME_ENTRY_SPECIFIER as ct, warmPacksSuffix as d, emitResumeModule as dt, MARKLESS_BYTE_ATTRIBUTION as et, MARKLESS_INTERACTION_CLOSURES_ASSET as f, emitSettleModule as ft, clientRouteArtifactReference as g, prerenderWakeVirtualModuleId as gt, TSRX_SOURCE_FILE as h, payloadModule as ht, isMarklessNavigationPack as i, MARKLESS_PUBLIC_BUILD_METADATA_FILES as it, materializedReachedRenderDataSource as j, hasExecutionLogModuleHook as jt, isScalarPlanSourceRequest as k, executionLogActivationInjection as kt, startupPackOfLazy as l, demandsOverlay as lt, MARKLESS_ROUTE_SOURCE_QUERY_RE as m, encodedSymbolSource as mt, MARKLESS_NAVIGATION_PACK_PREFIX as n, MARKLESS_EXECUTION_SIZES as nt, lazyStartupPackName as o, MARKLESS_VIRTUAL_PREFIX as ot, plannedLandingFiles as p, emitSourceModule as pt, emitPrerenderTriggerGroupModule as q, isMarklessDeferredPack as r, MARKLESS_INTERACTION_CLOSURES as rt, marklessDeferredChunkFileNames as s, RESUME_ENTRY_SPECIFIER as st, MARKLESS_DEFERRED_PACK as t, MARKLESS_EXECUTION_DEMAND as tt, warmEvaluatedImports as u, emitOverlayLoaderInstall as ut, devBrowserSourceModuleUrl as v, resumeVirtualModuleId as vt, isPrerenderWakeSourceRequest as w, symbolVirtualModuleSourceFile as wt, executionLogRuntimeModuleId as x, settleVirtualModuleId as xt, devBrowserVirtualModuleUrl as y, rewriteSymbolModuleExport as yt, sourceForPrerenderWakeVirtualImporter as z };
+export { EXECUTION_LOG_CHUNK_MODULE_PATTERN as $, emitSourceModule as A, symbolVirtualModuleSourceFile as B, MARKLESS_VIRTUAL_PREFIX as C, emitOverlayLoaderInstall as D, demandsOverlay as E, resumeVirtualModuleId as F, sharedInlineSourcesModuleId as G, emitSymbolRouteTable as H, rewriteSymbolModuleExport as I, compilePrerenderInlineResumerSources as J, sharedInlineSourcesModuleSource as K, scopedSymbolExportName as L, payloadModule as M, prerenderWakeVirtualModuleId as N, emitResumeModule as O, prerenderWakeVirtualModuleSourceFile as P, PROTOCOL_BLOCK_START_COMMENT as Q, settleVirtualModuleId as R, withoutMachinePaths as S, STORAGE_FREE_RESUME_ENTRY_SPECIFIER as T, MARKLESS_SCALAR_PLAN_SOURCE_QUERY as U, withoutFirstUse as V, isSharedInlineSourcesModuleId as W, createInlineDeferTriggerSource as X, INLINE_DEFER_LOADER_SOURCE as Y, inlineDeferSource as Z, sourceForModuleId as _, isStartupPack as a, hasExecutionLogModuleHook as at, machinePathRoots as b, packOfPart as c, normalizeExecutionLogMode as ct, startupPackOfLazy as d, EXECUTION_LOG_DISPATCH_MODULE_IDS as et, PACK_COST_MODEL as f, rootRelativeId as g, moduleIdFor as h, isMarklessNavigationPack as i, executionLogVirtualModuleSource as it, encodedSymbolSource as j, emitSettleModule as k, packOfPiece as l, requalifyExecutionLogModuleHook as lt, warmPacksSuffix as m, MARKLESS_NAVIGATION_PACK_PREFIX as n, MARKLESS_EXECUTION_LOG_MODULE_ID as nt, lazyStartupPackName as o, injectExecutionLogModuleHook as ot, warmEvaluatedImports as p, compileInlineResumerSources as q, isMarklessDeferredPack as r, executionLogActivationInjection as rt, marklessDeferredChunkFileNames as s, isExecutionLogChunk as st, MARKLESS_DEFERRED_PACK as t, MARKLESS_EXECUTION_LOG_GLOBAL as tt, planRoutePackGroups as u, symbolExecutionLogId as v, RESUME_ENTRY_SPECIFIER as w, rootRelativeRegionComments as x, machinePathLeaks as y, symbolVirtualModuleId as z };