@markless/bundler 0.9.0 → 0.10.0

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

@@ -1,140 +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";
@@ -662,6 +532,10 @@ const PROTOCOL_EVENT_HOST_ATTRIBUTE = "m:on";
 //#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(":", "\\:");
@@ -673,7 +547,7 @@ const PROTOCOL_EVENT_HOST_SELECTOR = PROTOCOL_EVENT_HOST_ATTRIBUTE.replace(":",
 * `ownsRoot` adds the container itself, which hands records the runtime owns
 * (arms, rows) to the runtime.
 */
-function createMarklessDefer(loadModule, pageStart, pageEnd, pathsAttribute, hostSelector) {
+function createMarklessDefer(loadModule, pageStart, pageEnd, pathsAttribute, hostSelector, streamOpenProperty) {
 	const scope = globalThis;
 	const clockOf = (root) => root.__mClock || {
 		frame: (run) => requestAnimationFrame(run),
@@ -699,18 +573,21 @@ function createMarklessDefer(loadModule, pageStart, pageEnd, pathsAttribute, hos
 		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());
-		if (document.readyState === "complete") loaded();
+		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)) return;
+			if (fired.has(host) || claimed.has(host) || root.__mL !== life) return;
 			const input = {
 				root,
 				event: {
@@ -727,7 +604,7 @@ function createMarklessDefer(loadModule, pageStart, pageEnd, pathsAttribute, hos
 			root.__marklessCensus ||= census(root);
 			root.__marklessDelegatedDispatch ||= eventName;
 			pending++;
-			(queue ? Promise.resolve(queue(input)) : (root.__mResume ||= loadModule(url)).then((module) => module.resumeContainerEvent(input))).then(() => {
+			(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;
@@ -737,6 +614,7 @@ function createMarklessDefer(loadModule, pageStart, pageEnd, pathsAttribute, hos
 		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);
@@ -749,7 +627,7 @@ function createMarklessDefer(loadModule, pageStart, pageEnd, pathsAttribute, hos
 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)}))`;
+	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) {
@@ -758,15 +636,7 @@ function createInlineDeferTriggerSource(lane, ownsRoot) {
 }
 //#endregion
 //#region src/inline-resumer.ts
-let oxcToolsPromise;
 const compiledSources = /* @__PURE__ */ new Map();
-function loadOxcTools() {
-	oxcToolsPromise ??= import("rolldown/experimental").then(({ minifySync, transformSync }) => ({
-		minifySync,
-		transformSync
-	}));
-	return oxcToolsPromise;
-}
 function compileInlineResumerSources(options) {
 	const cacheKey = `${options.debug ? "debug" : "production"}:${options.executionLog}`;
 	let compiled = compiledSources.get(cacheKey);
@@ -819,7 +689,6 @@ async function compileInlineResumerSourceVariants(options) {
 }
 async function compileDeferFactorySource() {
 	const binding = "var __marklessDeferFactory=";
-	const { minifySync, transformSync } = await loadOxcTools();
 	const transformed = transformSync("markless-defer.js", `${binding}${createMarklessDefer.toString()};`, {
 		lang: "js",
 		sourceType: "script",
@@ -844,7 +713,6 @@ async function compileInlineResumerSource(options) {
 			debugRegistrationSource: createInlineResumerDebugRegistrationSource()
 		} : {}
 	});
-	const { minifySync, transformSync } = await loadOxcTools();
 	const transformed = transformSync("markless-inline-resumer.js", source, {
 		lang: "js",
 		sourceType: "script",
@@ -888,7 +756,6 @@ async function compilePrerenderVariants() {
 }
 async function compilePrerenderInlineResumerSource(selfWake) {
 	const source = parameterizedPrerenderInlineResumerSource(selfWake);
-	const { minifySync, transformSync } = await loadOxcTools();
 	const transformed = transformSync("markless-prerender-inline-resumer.js", source, {
 		lang: "js",
 		sourceType: "script",
@@ -1012,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;
@@ -1033,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);
 }
@@ -1155,7 +1019,7 @@ 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,
@@ -1202,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
 		}),
@@ -1328,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");
@@ -1351,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;
@@ -1365,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",
@@ -1387,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';` : "",
@@ -1395,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,
@@ -1423,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;",
@@ -1456,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,
@@ -1490,14 +1364,14 @@ 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`;
 }
@@ -1512,7 +1386,7 @@ function sharedPrerenderBootSource(boot) {
 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) {",
@@ -1602,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,",
@@ -1626,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;",
 		"	}",
@@ -1638,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({",
@@ -1657,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,",
@@ -1685,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,",
@@ -1750,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) => {
@@ -1969,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;`),
@@ -2044,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)
@@ -2069,885 +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_SERVER_CHUNK_MAX_BYTES = 4194304;
-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[/\\]/
-}];
-const MARKLESS_SERVER_COMPILED_GROUP = {
-	name: "markless-server",
-	minShareCount: 2,
-	test: /\.tsrx(?:[?#]|$)|^\0?virtual:markless:/,
-	entriesAware: true,
-	maxSize: MARKLESS_SERVER_CHUNK_MAX_BYTES
-};
-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";
-		const splitting = marklessCodeSplitting(next.codeSplitting);
-		next.codeSplitting = {
-			...splitting,
-			groups: [...splitting.groups, MARKLESS_SERVER_COMPILED_GROUP]
-		};
-		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");
+	return stripped;
 }
-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`;
-}
-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 isCompilerStatefulModuleId(id) {
-	const bare = id.startsWith("\0") ? id.slice(1) : id;
-	return TSRX_SOURCE_FILE.test(bare) || bare.startsWith("virtual:markless:") || /[?&]markless-[a-z-]+(?:[=&#]|$)/.test(bare);
-}
-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}`;
 }
-function pathname(id) {
-	return parsePath(id).pathname;
+/** 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));
 }
-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
@@ -2973,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;
@@ -3178,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();
@@ -3209,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();
@@ -3220,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,
@@ -3281,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 = "	";
@@ -3305,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_BUILD_PREFIX as $, isScalarPlanSourceRequest as A, compileInlineResumerSources as At, sourceForPrerenderWakeVirtualImporter as B, hasExecutionLogModuleHook as Bt, isCompilerStatefulModuleId as C, symbolEntryVirtualModuleId as Ct, isRenderDataSourceRequest as D, isSharedInlineSourcesModuleId as Dt, isRelativeImport as E, withoutFirstUse as Et, renderDataReachedFromQuery as F, EXECUTION_LOG_DISPATCH_MODULE_IDS as Ft, stripBuildPrefix as G, planModulePreloadUrls as Gt, sourceForSettleVirtualImporter as H, isExecutionLogChunk as Ht, resolveVirtualId as I, MARKLESS_EXECUTION_LOG_GLOBAL as It, emitPrerenderTriggerGroupModule as J, virtualModuleSourceForLoad as K, planModulePreloads as Kt, resolverVirtualModuleSourceFile as L, MARKLESS_EXECUTION_LOG_MODULE_ID as Lt, materializedReachedRenderDataSource as M, INLINE_DEFER_LOADER_SOURCE as Mt, normalizeVirtualId as N, createInlineDeferTriggerSource as Nt, isResumeSourceRequest as O, sharedInlineSourcesModuleId as Ot, pathname as P, inlineDeferSource as Pt, MARKLESS_BUILD_METADATA_FILES as Q, serverSharedSourceRequest as R, executionLogActivationInjection as Rt, isClientPrimarySourceRequest as S, settleVirtualModuleId as St, isPrerenderWakeSourceRequest as T, symbolVirtualModuleSourceFile as Tt, sourceForSymbolVirtualImporter as U, normalizeExecutionLogMode as Ut, sourceForResumeVirtualImporter as V, injectExecutionLogModuleHook as Vt, sourceForTriggerGroupVirtualImporter as W, requalifyExecutionLogModuleHook as Wt, triggerGroupVirtualModuleId as X, planPrerenderTriggerGroups as Y, adaptImportedCaptureResolver as Z, clientSymbolEntries as _, prerenderWakeVirtualModuleId as _t, isStartupPack as a, MARKLESS_PUBLIC_BUILD_METADATA_FILES as at, emittedBundleModuleIds as b, rewriteSymbolModuleExport as bt, planRoutePackGroups as c, RESUME_ENTRY_SPECIFIER as ct, warmPacksSuffix as d, emitOverlayLoaderInstall as dt, MARKLESS_BUNDLE_GRAPH as et, MARKLESS_INTERACTION_CLOSURES_ASSET as f, emitResumeModule as ft, clientRouteArtifactReference as g, payloadModule as gt, TSRX_SOURCE_FILE as h, encodedSymbolSource as ht, isMarklessNavigationPack as i, MARKLESS_INTERACTION_CLOSURES as it, isSymbolOnlySourceRequest as j, compilePrerenderInlineResumerSources as jt, isRouteNavigationSourceRequest as k, sharedInlineSourcesModuleSource as kt, startupPackOfLazy as l, STORAGE_FREE_RESUME_ENTRY_SPECIFIER as lt, MARKLESS_ROUTE_SOURCE_QUERY_RE as m, emitSourceModule as mt, MARKLESS_NAVIGATION_PACK_PREFIX as n, MARKLESS_EXECUTION_DEMAND as nt, lazyStartupPackName as o, outputDefaults as ot, plannedLandingFiles as p, emitSettleModule as pt, emitPrerenderBoundaryRendererModule as q, isMarklessDeferredPack as r, MARKLESS_EXECUTION_SIZES as rt, marklessDeferredChunkFileNames as s, MARKLESS_VIRTUAL_PREFIX as st, MARKLESS_DEFERRED_PACK as t, MARKLESS_BYTE_ATTRIBUTION as tt, warmEvaluatedImports as u, demandsOverlay as ut, devBrowserSourceModuleUrl as v, prerenderWakeVirtualModuleSourceFile as vt, isMarklessRuntimeModule as w, symbolVirtualModuleId as wt, executionLogRuntimeModuleId as x, scopedSymbolExportName as xt, devBrowserVirtualModuleUrl as y, resumeVirtualModuleId as yt, sharedReachedRenderDataRequest as z, executionLogVirtualModuleSource as zt };
+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 };