@markless/bundler 0.1.1 → 0.2.0

package/dist/{rolldown-Czh1duwk.js → rolldown-CpG_S-ZJ.js}

@@ -1,8 +1,11 @@
-import { S as planModulePreloads, _ as requalifyExecutionLogModuleHook, a as resumeVirtualModuleId, b as outputDefaults, c as symbolVirtualModuleId, d as MARKLESS_EXECUTION_SIZES, f as createExecutionSizesAsset, g as normalizeExecutionLogMode, h as injectExecutionLogModuleHook, i as payloadModule, l as symbolVirtualModuleSourceFile, m as executionLogVirtualModuleSource, n as emitResumeModule, o as rewriteSymbolModuleExport, p as executionLogActivationInjection, r as emitSourceModule, s as scopedSymbolExportName, t as MARKLESS_VIRTUAL_PREFIX, u as MARKLESS_EXECUTION_LOG_MODULE_ID, v as MARKLESS_BUILD_PREFIX, y as MARKLESS_BUNDLE_GRAPH } from "./source-module-CSRzW4Ny.js";
+import { MarklessCompileError, createCompileErrorPayload } from "./dev-error.js";
+import { C as planModulePreloads, _ as normalizeExecutionLogMode, a as payloadModule, b as MARKLESS_BUNDLE_GRAPH, c as scopedSymbolExportName, d as MARKLESS_EXECUTION_LOG_MODULE_ID, f as MARKLESS_EXECUTION_SIZES, g as injectExecutionLogModuleHook, h as executionLogVirtualModuleSource, i as encodedSymbolSource, l as symbolVirtualModuleId, m as executionLogActivationInjection, n as emitResumeModule, o as resumeVirtualModuleId, p as createExecutionSizesAsset, r as emitSourceModule, s as rewriteSymbolModuleExport, t as MARKLESS_VIRTUAL_PREFIX, u as symbolVirtualModuleSourceFile, v as requalifyExecutionLogModuleHook, x as outputDefaults, y as MARKLESS_BUILD_PREFIX } from "./source-module-C8W2THUI.js";
 import { joinURL, parsePath, withLeadingSlash, withQuery, withoutLeadingSlash } from "ufo";
 import { dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
 import { defDGraph } from "@thi.ng/dgraph";
-import { compileTsrxModule, emitSymbolResolverModule, parseJavaScriptModule } from "@markless/compiler";
+import { collectTsrxModuleDiagnostics, compileTsrxModule, emitSymbolResolverModule, parseJavaScriptModule } from "@markless/compiler";
+import { createStorageSeedMetadataFromGraphNodeId } from "@markless/serializer";
+import { createInlineResumerDebugRegistrationSource, createInlineResumerSource } from "@markless/web/inline/resumer";
 //#region src/build/bundle-graph.ts
 const SLOW_BUNDLE_TOTAL = 300 * 1024 / 8 * .5;
 const SMALL_BUNDLE_TOTAL = 1e3;
@@ -887,7 +890,7 @@ function rewriteDynamicImportSpecifiers(chunk, rewrites) {
 	return {
 		code: chunk.code.replace(LOCAL_DYNAMIC_IMPORT_HELPER_RE, (match, quote, specifier, parameter, helperName, exportQuote, exportName) => {
 			if (!isLocalSpecifier(specifier)) return match;
-			const importedFileName = resolveChunkSpecifier(chunk.fileName, specifier);
+			const importedFileName = resolveChunkSpecifier$1(chunk.fileName, specifier);
 			const rewrite = rewrites.get(importedFileName);
 			if (!rewrite) return match;
 			if (!rewrite.target.exports.includes(exportName)) return match;
@@ -896,7 +899,7 @@ function rewriteDynamicImportSpecifiers(chunk, rewrites) {
 			return `import(${quote}${nextSpecifier}${quote}).then(${parameter}=>${helperName}(${parameter},${exportQuote}${exportName}${exportQuote}))`;
 		}).replace(LOCAL_DYNAMIC_IMPORT_RE, (match, quote, specifier, parameter, exportName) => {
 			if (!isLocalSpecifier(specifier)) return match;
-			const importedFileName = resolveChunkSpecifier(chunk.fileName, specifier);
+			const importedFileName = resolveChunkSpecifier$1(chunk.fileName, specifier);
 			const rewrite = rewrites.get(importedFileName);
 			if (!rewrite) return match;
 			if (rewrite.initExports.length > 0 && (!parameter || !exportName)) return match;
@@ -1058,7 +1061,7 @@ function findBlockEnd(code, open) {
 	}
 	return -1;
 }
-function resolveChunkSpecifier(importerFileName, specifier) {
+function resolveChunkSpecifier$1(importerFileName, specifier) {
 	return normalize(join(dirname(importerFileName), specifier));
 }
 function relativeChunkSpecifier$1(importerFileName, targetFileName) {
@@ -1169,6 +1172,299 @@ function normalizeVirtualId$2(id) {
 	return id.startsWith("\0") ? id.slice(1) : id;
 }
 //#endregion
+//#region ../web/src/debug-channel.ts
+function installDebugChannelLayer(root, initialPhase, initiallyActive = true) {
+	const global = globalThis;
+	const previous = global.__MARKLESS_DEBUG__?.version === 1 ? global.__MARKLESS_DEBUG__ : void 0;
+	let priorRoot;
+	try {
+		priorRoot = previous?.explainInteraction(root, "__markless_debug_root__");
+	} catch {}
+	const priorContainer = priorRoot && "containerId" in priorRoot ? previous?.containers.find((entry) => entry.id === priorRoot.containerId) : void 0;
+	const seed = `${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+	const id = priorContainer?.id ?? `container:${seed}`;
+	const rootKey = priorContainer?.root.key ?? `root:${seed}`;
+	const rootRef = new WeakRef(root);
+	const events = /* @__PURE__ */ new WeakMap();
+	const keys = /* @__PURE__ */ new WeakMap();
+	const invalidated = /* @__PURE__ */ new WeakSet();
+	const routerSources = global[Symbol.for("markless.debug.channel.v1.router-sources")] ??= /* @__PURE__ */ new Set();
+	const ownViolations = [];
+	let phase = initialPhase;
+	let lifecycle = initiallyActive ? "active" : "registered";
+	let boundarySnapshots = Object.freeze([]);
+	let nextElement = 1;
+	let nextSequence = (previous?.violations.at(-1)?.sequence ?? 0) + 1;
+	let dropped = 0;
+	let pruned = false;
+	const freeze = (value) => Object.freeze(value);
+	const contains = (element) => {
+		const currentRoot = rootRef.deref();
+		return !!currentRoot && (currentRoot === element || currentRoot.contains?.(element) === true);
+	};
+	const keyFor = (element) => {
+		let key = keys.get(element);
+		if (!key) {
+			key = `${rootKey}:element:${nextElement++}`;
+			keys.set(element, key);
+		}
+		return key;
+	};
+	const eligibleAnchor = (element) => {
+		const anchor = element.closest?.("a[href]");
+		if (!anchor?.hasAttribute("data-markless-router-link") || anchor.hasAttribute("download")) return false;
+		const target = anchor.getAttribute("target");
+		if (target && target !== "_self" || anchor.relList?.contains("external")) return false;
+		try {
+			const base = global.location?.href ?? "http://localhost/";
+			return new URL(anchor.href ?? "", base).origin === new URL(base).origin;
+		} catch {
+			return false;
+		}
+	};
+	const none = (element, eventName, reason) => freeze({
+		kind: "none",
+		eventName,
+		reason,
+		containerId: id,
+		elementKey: keyFor(element)
+	});
+	const explain = (element, eventName) => {
+		if (lifecycle === "disposed" && (contains(element) || keys.has(element))) return none(element, eventName, "container-disposed");
+		if (!contains(element)) try {
+			return previous?.explainInteraction(element, eventName) ?? freeze({
+				kind: "none",
+				eventName,
+				reason: "outside-known-container"
+			});
+		} catch {
+			return freeze({
+				kind: "none",
+				eventName,
+				reason: "outside-known-container"
+			});
+		}
+		if (element.isConnected === false) return none(element, eventName, "element-disconnected");
+		if (eligibleAnchor(element)) {
+			const source = eventName === "navigate" && routerSources.has("navigation-event") ? "navigation-event" : eventName === "click" && routerSources.has("spa-click-listener") ? "spa-click-listener" : eventName === "click" && routerSources.has("ssr-link-bridge") ? "ssr-link-bridge" : void 0;
+			if (source) return freeze({
+				kind: "router-delegation",
+				source,
+				containerId: id,
+				elementKey: keyFor(element),
+				eventName
+			});
+		}
+		const interaction = events.get(element)?.get(eventName);
+		if (interaction) return freeze({ ...interaction });
+		if (invalidated.has(element)) return none(element, eventName, "not-registered");
+		try {
+			const prior = previous?.explainInteraction(element, eventName);
+			if (prior && prior.kind !== "none") return prior;
+		} catch {}
+		return none(element, eventName, "not-registered");
+	};
+	const cloneJson = (value, seen = /* @__PURE__ */ new Set()) => {
+		if (value === null) return null;
+		if (typeof value === "boolean" || typeof value === "string") return value;
+		if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+		if (!value || typeof value !== "object" || seen.has(value)) return void 0;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			const copy = value.map((entry) => cloneJson(entry, seen));
+			return copy.some((entry) => entry === void 0) ? void 0 : freeze(copy);
+		}
+		if (Object.getPrototypeOf(value) !== Object.prototype) return void 0;
+		const copy = {};
+		for (const [name, entry] of Object.entries(value)) {
+			const cloned = cloneJson(entry, seen);
+			if (cloned === void 0) return void 0;
+			copy[name] = cloned;
+		}
+		return freeze(copy);
+	};
+	const pushViolation = (input) => {
+		const cloned = input.details === void 0 ? void 0 : cloneJson(input.details);
+		const details = cloned && !Array.isArray(cloned) && typeof cloned === "object" ? cloned : void 0;
+		const { details: _details, ...metadata } = input;
+		ownViolations.push(freeze({
+			...metadata,
+			...details ? { details } : {},
+			sequence: nextSequence++,
+			timestamp: Date.now()
+		}));
+		if (input.details !== void 0 && !details) ownViolations.push(freeze({
+			code: "MARKLESS_DEBUG_DETAILS_DROPPED",
+			message: "Debug violation details were not JSON-safe and were dropped.",
+			sequence: nextSequence++,
+			timestamp: Date.now()
+		}));
+		while (ownViolations.length > 100) {
+			ownViolations.shift();
+			dropped++;
+		}
+	};
+	const channel = freeze({
+		version: 1,
+		get containers() {
+			const inherited = previous?.containers.filter((entry) => entry.id !== id) ?? [];
+			if (pruned || lifecycle === "disposed") return freeze([...inherited]);
+			const currentRoot = rootRef.deref();
+			const connected = !!currentRoot && currentRoot.isConnected !== false;
+			const snapshot = freeze({
+				id,
+				phase,
+				lifecycle: connected ? lifecycle : "disposed",
+				root: freeze({
+					key: rootKey,
+					connected
+				}),
+				boundaries: freeze([...boundarySnapshots])
+			});
+			if (!connected) pruned = true;
+			return freeze([...inherited, snapshot]);
+		},
+		get violations() {
+			return freeze([...previous?.violations ?? [], ...ownViolations].slice(-100));
+		},
+		violationCapacity: 100,
+		get droppedViolationCount() {
+			return (previous?.droppedViolationCount ?? 0) + dropped;
+		},
+		explainInteraction: explain
+	});
+	Object.defineProperty(global, "__MARKLESS_DEBUG__", {
+		configurable: true,
+		enumerable: false,
+		value: channel,
+		writable: false
+	});
+	return {
+		start(nextPhase, active = true) {
+			phase = nextPhase === "ssr-resume" && phase === "csr" ? "csr" : nextPhase;
+			if (active) lifecycle = "active";
+			return id;
+		},
+		activate: () => void (lifecycle === "disposed" || (lifecycle = "active")),
+		dispose() {
+			lifecycle = "disposed";
+			boundarySnapshots = freeze([]);
+		},
+		invalidate(element) {
+			events.delete(element);
+			invalidated.add(element);
+		},
+		record(element, eventName, input) {
+			if (lifecycle === "disposed") return;
+			let byName = events.get(element);
+			if (!byName) events.set(element, byName = /* @__PURE__ */ new Map());
+			const symbolIds = "symbolIds" in input ? freeze([...input.symbolIds]) : void 0;
+			byName.set(eventName, freeze({
+				...input,
+				...symbolIds ? { symbolIds } : {},
+				containerId: id,
+				elementKey: keyFor(element),
+				eventName
+			}));
+		},
+		violation: pushViolation,
+		router: (source) => void routerSources.add(source),
+		boundaries(value) {
+			boundarySnapshots = freeze(value.map((entry) => freeze({ ...entry })));
+		},
+		disposed: () => lifecycle === "disposed"
+	};
+}
+function __marklessDebugBootstrapSource() {
+	return `((root,phase,active)=>{const controls=(${installDebugChannelLayer.toString()})(root,phase,active);return Object.freeze({record:(element,eventName,input)=>controls.record(element,eventName,input),router:(source)=>controls.router(source),activate:()=>controls.activate()})})`;
+}
+//#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);
+	if (!compiled) {
+		compiled = compileInlineResumerSourceVariants(options);
+		compiledSources.set(cacheKey, compiled);
+	}
+	return compiled;
+}
+async function compileInlineResumerSourceVariants(options) {
+	const shared = {
+		debug: options.debug,
+		executionLog: options.executionLog
+	};
+	const [event, syncPolicy, graphSyncPolicyOwner, graphSyncPolicyConsumer] = await Promise.all([
+		compileInlineResumerSource({
+			...shared,
+			graphSyncPolicy: false,
+			sharedGraphPolicy: false,
+			syncPolicy: false
+		}),
+		compileInlineResumerSource({
+			...shared,
+			graphSyncPolicy: false,
+			sharedGraphPolicy: false,
+			syncPolicy: true
+		}),
+		compileInlineResumerSource({
+			...shared,
+			graphSyncPolicy: true,
+			sharedGraphPolicy: true,
+			syncPolicy: true
+		}),
+		compileInlineResumerSource({
+			...shared,
+			graphSyncPolicy: true,
+			sharedGraphPolicy: false,
+			syncPolicy: true
+		})
+	]);
+	return {
+		...shared,
+		event,
+		syncPolicy,
+		graphSyncPolicyOwner,
+		graphSyncPolicyConsumer
+	};
+}
+async function compileInlineResumerSource(options) {
+	const source = createInlineResumerSource({
+		...options,
+		...options.debug ? {
+			debugBootstrapSource: __marklessDebugBootstrapSource(),
+			debugRegistrationSource: createInlineResumerDebugRegistrationSource()
+		} : {}
+	});
+	const { minifySync, transformSync } = await loadOxcTools();
+	const transformed = transformSync("markless-inline-resumer.js", source, {
+		lang: "js",
+		sourceType: "script",
+		target: "es2020"
+	});
+	assertOxcResult("transform", transformed.errors);
+	const minified = minifySync("markless-inline-resumer.js", transformed.code, {
+		compress: true,
+		mangle: { toplevel: true },
+		module: false
+	});
+	assertOxcResult("minify", minified.errors);
+	return minified.code.trim();
+}
+function assertOxcResult(phase, errors) {
+	if (errors.length === 0) return;
+	throw new Error(`MARKLESS_INLINE_RESUMER_${phase.toUpperCase()}_FAILED:\n${errors.map((error) => error.message).join("\n")}`);
+}
+//#endregion
 //#region src/transform.ts
 let oxcTransformSyncPromise;
 function loadOxcTransformSync() {
@@ -1191,29 +1487,32 @@ async function transformTsrxModule(input) {
 	const payloadId = `${MARKLESS_VIRTUAL_PREFIX}payload:${encodedFilename}`;
 	const resolverId = `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodedFilename}`;
 	const resumeId = resumeVirtualModuleId(input.filename);
-	const compiled = await compileTsrxModule({
-		filename: input.filename,
-		source: input.source,
-		buildId: input.buildId,
-		resolverId,
-		symbols: []
-	});
+	const { compiled, blockingDiagnostics } = await compileWithBlockingDiagnostics(input, resolverId);
+	throwIfBlocked(input, blockingDiagnostics);
 	const symbolRows = compiled.symbolModules.modules.map((module) => ({
 		id: module.symbolId,
 		chunk: symbolVirtualModuleId(input.filename, module.symbolId),
 		exportName: scopedSymbolExportName(input.filename, module.exportName)
 	}));
-	const resolverSource = emitSymbolResolverModule({
+	const importedBoundRows = compiled.boundSymbolResolver.rows.map((row) => row.loaderSymbolId ? {
+		...row,
+		baseSymbolId: row.loaderSymbolId
+	} : row);
+	const resolverSource = adaptImportedCaptureResolver(emitSymbolResolverModule({
 		buildId: input.buildId,
-		symbols: symbolRows
-	});
+		symbols: uniqueSymbolsById([...input.symbols ?? [], ...symbolRows]),
+		boundSymbols: importedBoundRows
+	}), importedBoundRows.some((row) => row.loaderSymbolId !== void 0));
 	const symbolRoutes = compiled.semanticGraph.componentEdges.flatMap((edge, index) => edge.importSource ? [{
 		prefix: `c${index}:`,
-		importSource: edge.importSource
+		importSource: edge.importSource,
+		componentEdgeId: edge.id
 	}] : []);
 	const executionLogModuleHookMode = input.executionLogModuleHooks === false ? "never" : input.executionLog;
 	const manifest = {
 		source: input.filename,
+		captureMetadata: compiled.captureAnalysis,
+		symbolRoutes,
 		payload: { virtualModuleId: payloadId },
 		resolver: { virtualModuleId: resolverId },
 		symbols: compiled.symbolModules.modules.map((module, index) => ({
@@ -1255,7 +1554,8 @@ async function transformTsrxModule(input) {
 				payloadView: containerScopedResumeView(compiled.payloadScripts.view),
 				runtimeDemandMap: compiled.runtimeDemandMap,
 				executionLog: input.executionLog,
-				needsFullResume: needsFullResume(compiled.protocolView, compiled.runtimeDemandMap),
+				needsFullResume: needsFullResume(compiled.protocolState, compiled.protocolView, compiled.runtimeDemandMap),
+				hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
 				symbols: symbolRows,
 				symbolRoutes
 			})
@@ -1268,17 +1568,37 @@ async function transformTsrxModule(input) {
 			source: injectExecutionLogModuleHook(await stripEmittedTypes(rewriteSymbolModuleExport(module.source, module.exportName, symbolRows[index].exportName)), `symbol:${module.symbolId}`, executionLogModuleHookMode)
 		})))
 	];
+	const styleImport = styleId ? `import ${JSON.stringify(styleId)};\n` : "";
+	const inlineResumerSources = (input.environment ?? "lib") === "client" ? void 0 : await compileInlineResumerSources({
+		debug: input.inlineResumerDebug === true,
+		executionLog: input.executionLog ?? "never"
+	});
+	const headInjections = [...input.headInjections ?? [], ...styleId && input.styleModuleUrl ? [{
+		tag: "link",
+		location: "head",
+		attributes: {
+			rel: "stylesheet",
+			href: input.styleModuleUrl(styleId)
+		}
+	}] : []];
+	const storageSeeds = compiled.payloadArena.state.storage.map((storage) => {
+		const binding = compiled.semanticGraph.graphBindings.find((candidate) => candidate.id === storage.graphNodeId);
+		if (typeof binding?.initialValue !== "string") throw new Error(`MARKLESS_STORAGE_SEED_FALLBACK_MISSING: ${storage.graphNodeId} has no static string fallback.`);
+		return createStorageSeedMetadataFromGraphNodeId(storage.graphNodeId, storage.key, binding.initialValue);
+	});
 	return {
-		code: (styleId ? `import ${JSON.stringify(styleId)};\n` : "") + await stripEmittedTypes(emitSourceModule({
+		code: styleImport + await stripEmittedTypes(emitSourceModule({
 			filename: input.filename,
 			payloadId,
 			resolverId,
 			environment: input.environment ?? "lib",
 			clientOutput: input.clientOutput ?? "full",
 			executionLog: input.executionLog,
-			headInjections: input.headInjections,
+			headInjections: headInjections.length > 0 ? headInjections : void 0,
+			storageSeeds: storageSeeds.length > 0 ? storageSeeds : void 0,
+			inlineResumerSources,
 			devResumeReexport: input.devResumeReexport === true,
-			needsFullResume: needsFullResume(compiled.protocolView, compiled.runtimeDemandMap),
+			needsFullResume: needsFullResume(compiled.protocolState, compiled.protocolView, compiled.runtimeDemandMap),
 			resumeModuleUrl: input.resumeModuleUrl,
 			publicRenderModuleSource: compiled.publicRenderModule.moduleSource,
 			publicRenderRootExportName: compiled.publicRenderModule.rootExportName,
@@ -1286,6 +1606,7 @@ async function transformTsrxModule(input) {
 			publicRenderCsrExportName: compiled.publicRenderModule.csrExportName,
 			publicSsrModuleSource: compiled.publicRenderModule.ssrModuleSource,
 			publicRenderSsrExportName: compiled.publicRenderModule.ssrExportName,
+			hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
 			symbols: symbolRows,
 			symbolRoutes
 		})),
@@ -1294,6 +1615,89 @@ async function transformTsrxModule(input) {
 		manifest
 	};
 }
+async function preflightTsrxModuleDiagnostics(input) {
+	const { blockingDiagnostics } = await compileWithBlockingDiagnostics(input, `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodeURIComponent(input.filename)}`);
+	throwIfBlocked(input, blockingDiagnostics);
+}
+async function compileWithBlockingDiagnostics(input, resolverId) {
+	const compiled = await compileTsrxModule({
+		filename: input.filename,
+		source: input.source,
+		buildId: input.buildId,
+		resolverId,
+		symbols: input.symbols ?? []
+	});
+	return {
+		compiled,
+		blockingDiagnostics: collectTsrxModuleDiagnostics(compiled).filter((diagnostic) => diagnostic.severity === "error")
+	};
+}
+function throwIfBlocked(input, blockingDiagnostics) {
+	if (blockingDiagnostics.length === 0) return;
+	const details = formatBlockedCompileError(input, blockingDiagnostics);
+	throw new MarklessCompileError(createCompileErrorPayload({
+		filename: input.filename,
+		source: input.source,
+		diagnostics: blockingDiagnostics,
+		details
+	}));
+}
+function formatBlockedCompileError(input, diagnostics) {
+	return [`MARKLESS_COMPILE_BLOCKED: ${input.filename} has ${diagnostics.length} compiler error(s).`, ...diagnostics.map((diagnostic) => {
+		const position = diagnostic.primarySpan ? formatSourcePosition(input.source, diagnostic.primarySpan.start) : void 0;
+		const location = position ? ` (${diagnostic.primarySpan.filename}:${position.line}:${position.column})` : "";
+		return [
+			`${diagnostic.code}: ${diagnostic.message}${location}`,
+			diagnostic.why,
+			diagnostic.suggestions[0]?.message,
+			diagnostic.docsUrl
+		].filter((line) => Boolean(line)).join("\n");
+	})].join("\n\n");
+}
+function formatSourcePosition(source, start) {
+	const sourceBeforeSpan = source.slice(0, start);
+	const lastLineBreak = sourceBeforeSpan.lastIndexOf("\n");
+	return {
+		line: sourceBeforeSpan.split("\n").length,
+		column: sourceBeforeSpan.length - lastLineBreak
+	};
+}
+function uniqueSymbolsById(symbols) {
+	return [...new Map(symbols.map((symbol) => [symbol.id, symbol])).values()];
+}
+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]] : []));",
+		"	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 = context.invokeSymbol(slot.route.callbackSymbolId, { ...context, event: context.event, args });",
+		"				pendingCallbacks.push(Promise.resolve(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) {`);
+}
 function containerScopedResumeView(view) {
 	return {
 		...view,
@@ -1303,7 +1707,8 @@ function containerScopedResumeView(view) {
 		}))
 	};
 }
-function needsFullResume(view, runtimeDemandMap) {
+function needsFullResume(state, view, runtimeDemandMap) {
+	if ((state.storage?.length ?? 0) > 0) return true;
 	if ((view.branches?.length ?? 0) > 0) return true;
 	if ((view.elementHandles?.length ?? 0) > 0) return true;
 	if ((view.asyncBoundaries?.length ?? 0) > 0) return true;
@@ -1316,10 +1721,13 @@ function recordKindReplaced(runtimeDemandMap, kind) {
 //#endregion
 //#region src/build/symbol-table.ts
 const SYMBOL_VIRTUAL_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}symbol:`;
+const PACKED_SYMBOL_VIRTUAL_LIST_RE = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1\.split\(\s*(["'`]),\3\s*\)/g;
 const SYMBOL_VIRTUAL_STRING_RE$1 = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1/g;
-const SYMBOL_MANIFEST_TUPLE_RE = /(\[1,(?:null|["'`][^"'`]*["'`]),(?:null|["'`][^"'`]*["'`]),)(\[[^\]]*\]),(\[[^\]]*\]),(\{[^}]*\})(\])/g;
+const STRING_LIST_SOURCE = String.raw`(?:\[[^\]]*\]|["'\x60][^"'\x60]*["'\x60]\.split\(\s*["'\x60][^"'\x60]*["'\x60]\s*\))`;
+const SYMBOL_MANIFEST_TUPLE_RE = new RegExp(String.raw`(\[1,(?:null|["'\x60][^"'\x60]*["'\x60]),(?:null|["'\x60][^"'\x60]*["'\x60]),)(${STRING_LIST_SOURCE}),(${STRING_LIST_SOURCE}),(\{[^}]*\})(\])`, "g");
 const STRING_LITERAL_RE = /(["'`])([^"'`]*)\1/g;
 const SYMBOL_ROW_RE = /((?:["'`][^"'`]*["'`])\s*:\s*\[)(\d+)(,\s*\d+\])/g;
+const SYMBOL_ROW_CAPTURE_RE = /(["'`])([^"'`]*)\1\s*:\s*\[(\d+),\s*(\d+)\]/g;
 function rewriteGeneratedSymbolTableUrls(bundle) {
 	const chunks = collectChunks(bundle);
 	const symbolFiles = collectGeneratedSymbolFiles(chunks);
@@ -1337,6 +1745,56 @@ function rewriteGeneratedSymbolTableUrls(bundle) {
 		unresolved: [...unresolved].sort()
 	};
 }
+/**
+* Checks emitted resolver routes against compiler manifests and Rolldown's
+* chunk ownership/export metadata. Table source is read only to recover each
+* claimed file; termination evidence stays structural.
+*/
+function verifyGeneratedSymbolTableRoutes(bundle, manifests) {
+	const chunks = collectChunks(bundle);
+	const errors = [];
+	let verified = 0;
+	for (const manifest of manifests) {
+		if (manifest.symbols.length === 0) continue;
+		const resolverChunk = findResolverRouteChunk(chunks, manifest.resolver.virtualModuleId, manifest.symbols);
+		const routeChunk = resolverChunk ?? findChunkForVirtualId(chunks, manifest.source);
+		if (!routeChunk) {
+			for (const symbol of manifest.symbols) errors.push({
+				symbolId: symbol.symbolId,
+				claimedChunk: "<missing route chunk>",
+				reason: `neither compiler resolver ${manifest.resolver.virtualModuleId} nor source ${manifest.source} was emitted`
+			});
+			continue;
+		}
+		const table = resolverChunk ? findSymbolTable(routeChunk.code, manifest.symbols) : void 0;
+		for (const symbol of manifest.symbols) {
+			if (!table) {
+				const directRoute = verifyDirectRoute(chunks, routeChunk, symbol);
+				if (directRoute.reason) errors.push({
+					symbolId: symbol.symbolId,
+					claimedChunk: directRoute.claimedChunk,
+					reason: directRoute.reason
+				});
+				else verified++;
+				continue;
+			}
+			const specifier = tableRouteSpecifier(table, symbol, routeChunk.fileName, errors);
+			if (!specifier) continue;
+			const claimedChunk = resolveChunkSpecifier(routeChunk.fileName, specifier);
+			const reason = routeTerminationError(chunks, claimedChunk, symbol);
+			if (reason) errors.push({
+				symbolId: symbol.symbolId,
+				claimedChunk,
+				reason
+			});
+			else verified++;
+		}
+	}
+	return {
+		verified,
+		errors
+	};
+}
 function collectChunks(bundle) {
 	const chunks = /* @__PURE__ */ new Map();
 	for (const output of Object.values(bundle)) if (isGeneratedChunk(output)) chunks.set(output.fileName, output);
@@ -1344,9 +1802,135 @@ function collectChunks(bundle) {
 }
 function collectGeneratedSymbolFiles(chunks) {
 	const symbolFiles = /* @__PURE__ */ new Map();
-	for (const chunk of chunks.values()) for (const id of virtualIds(chunk)) if (id.startsWith(SYMBOL_VIRTUAL_PREFIX)) symbolFiles.set(id, chunk.fileName);
+	for (const chunk of chunks.values()) {
+		const facadeId = chunk.facadeModuleId ? normalizeVirtualId$1(chunk.facadeModuleId) : void 0;
+		if (facadeId?.startsWith(SYMBOL_VIRTUAL_PREFIX)) symbolFiles.set(facadeId, chunk.fileName);
+	}
+	for (const chunk of chunks.values()) for (const id of chunk.moduleIds.map(normalizeVirtualId$1)) if (id.startsWith(SYMBOL_VIRTUAL_PREFIX) && !symbolFiles.has(id)) symbolFiles.set(id, chunk.fileName);
 	return symbolFiles;
 }
+function findSymbolTable(code, symbols) {
+	let bestMatch;
+	let bestScore = -1;
+	for (const match of code.matchAll(SYMBOL_MANIFEST_TUPLE_RE)) {
+		const moduleUrls = parseStringList(match[2]);
+		const exportNames = parseStringList(match[3]);
+		if (!moduleUrls || !exportNames) continue;
+		const rows = /* @__PURE__ */ new Map();
+		for (const row of match[4].matchAll(SYMBOL_ROW_CAPTURE_RE)) rows.set(row[2], [Number(row[3]), Number(row[4])]);
+		if (rows.size === 0) continue;
+		const score = symbols.filter((symbol) => exportNames.includes(symbol.exportName)).length;
+		if (score > bestScore) {
+			bestMatch = {
+				moduleUrls,
+				exportNames,
+				rows
+			};
+			bestScore = score;
+		}
+	}
+	return bestMatch;
+}
+function tableRouteSpecifier(table, symbol, resolverFileName, errors) {
+	const row = table.rows.get(symbol.symbolId);
+	if (!row) {
+		errors.push({
+			symbolId: symbol.symbolId,
+			claimedChunk: resolverFileName,
+			reason: "emitted symbol table has no row for this compiler symbol"
+		});
+		return;
+	}
+	const specifier = table.moduleUrls[row[0]];
+	if (!specifier) {
+		errors.push({
+			symbolId: symbol.symbolId,
+			claimedChunk: resolverFileName,
+			reason: `emitted symbol table references missing module URL index ${row[0]}`
+		});
+		return;
+	}
+	const exportName = table.exportNames[row[1]];
+	if (exportName !== symbol.exportName) {
+		errors.push({
+			symbolId: symbol.symbolId,
+			claimedChunk: resolveChunkSpecifier(resolverFileName, specifier),
+			reason: `emitted symbol table claims export ${exportName ?? `<missing index ${row[1]}>`} instead of ${symbol.exportName}`
+		});
+		return;
+	}
+	return specifier;
+}
+function verifyDirectRoute(chunks, routeChunk, symbol) {
+	const target = findChunkForVirtualId(chunks, symbol.virtualModuleId);
+	if (!target) return {
+		claimedChunk: "<missing symbol chunk>",
+		reason: `generated symbol module ${symbol.virtualModuleId} was not emitted`
+	};
+	if (!(target.exports ?? []).includes(symbol.exportName)) return {
+		claimedChunk: target.fileName,
+		reason: `claimed chunk does not export ${symbol.exportName}`
+	};
+	if (!dynamicRouteReachesChunk(chunks, routeChunk, target.fileName) && !rewrittenSpecifierRoutesTo(routeChunk, target.fileName)) return {
+		claimedChunk: target.fileName,
+		reason: `source chunk ${routeChunk.fileName} has no emitted dynamic route to the claimed chunk`
+	};
+	return { claimedChunk: target.fileName };
+}
+function rewrittenSpecifierRoutesTo(routeChunk, targetFileName) {
+	const specifier = relativeChunkSpecifier(routeChunk.fileName, targetFileName);
+	return routeChunk.code.includes(JSON.stringify(specifier)) || routeChunk.code.includes(`'${specifier}'`) || routeChunk.code.includes(`\`${specifier}\``);
+}
+function dynamicRouteReachesChunk(chunks, start, targetFileName) {
+	const pending = [start];
+	const visited = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const chunk = pending.shift();
+		if (chunk.fileName === targetFileName) return true;
+		if (visited.has(chunk.fileName)) continue;
+		visited.add(chunk.fileName);
+		for (const importedFileName of chunk.dynamicImports ?? []) {
+			const imported = chunks.get(importedFileName);
+			if (imported) pending.push(imported);
+		}
+	}
+	return false;
+}
+function routeTerminationError(chunks, claimedChunk, symbol) {
+	const target = chunks.get(claimedChunk);
+	if (!target) return "claimed chunk was not emitted. markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package";
+	if (!chunkOrReexportChainContainsSymbol(chunks, target, normalizeVirtualId$1(symbol.virtualModuleId), symbol.exportName)) return `claimed chunk does not contain its generated symbol module ${symbol.virtualModuleId} or a live re-export chain to it. markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package`;
+	if (!(target.exports ?? []).includes(symbol.exportName)) return `claimed chunk does not export ${symbol.exportName}. markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package`;
+}
+function chunkOrReexportChainContainsSymbol(chunks, start, virtualId, exportName) {
+	const pending = [start];
+	const visited = /* @__PURE__ */ new Set();
+	while (pending.length > 0) {
+		const chunk = pending.shift();
+		if (visited.has(chunk.fileName)) continue;
+		visited.add(chunk.fileName);
+		if (virtualIds(chunk).includes(virtualId) && (chunk.exports ?? []).includes(exportName)) return true;
+		if (!(chunk.exports ?? []).includes(exportName)) continue;
+		for (const importedFileName of chunk.imports ?? []) {
+			const imported = chunks.get(importedFileName);
+			if (imported && (imported.exports ?? []).includes(exportName)) pending.push(imported);
+		}
+	}
+	return false;
+}
+function findChunkForVirtualId(chunks, virtualId) {
+	const normalized = normalizeVirtualId$1(virtualId);
+	return [...chunks.values()].find((chunk) => !!chunk.facadeModuleId && normalizeVirtualId$1(chunk.facadeModuleId) === normalized) ?? [...chunks.values()].find((chunk) => chunk.moduleIds.map(normalizeVirtualId$1).includes(normalized));
+}
+function findResolverRouteChunk(chunks, virtualId, symbols) {
+	const normalized = normalizeVirtualId$1(virtualId);
+	const candidates = [...chunks.values()].filter((chunk) => virtualIds(chunk).includes(normalized));
+	return candidates.find((chunk) => !!findSymbolTable(chunk.code, symbols)) ?? candidates.find((chunk) => chunk.moduleIds.map(normalizeVirtualId$1).includes(normalized)) ?? candidates[0];
+}
+function resolveChunkSpecifier(importerFileName, specifier) {
+	if (!specifier.startsWith(".")) return normalize(specifier);
+	return normalize(join(dirname(importerFileName), specifier));
+}
 function virtualIds(chunk) {
 	return [chunk.facadeModuleId ?? void 0, ...chunk.moduleIds].filter((id) => !!id).map(normalizeVirtualId$1);
 }
@@ -1354,7 +1938,16 @@ function rewriteSymbolVirtualStrings(chunk, symbolFiles) {
 	let rewritten = 0;
 	const unresolved = /* @__PURE__ */ new Set();
 	return {
-		code: compactSymbolManifestTables(chunk.code.replace(SYMBOL_VIRTUAL_STRING_RE$1, (match, _quote, virtualId) => {
+		code: compactSymbolManifestTables(chunk.code.replace(PACKED_SYMBOL_VIRTUAL_LIST_RE, (match, _quote, packedVirtualIds) => {
+			const virtualIds = packedVirtualIds.split(",");
+			if (virtualIds.length < 2 || virtualIds.some((id) => !id.startsWith(SYMBOL_VIRTUAL_PREFIX))) return match;
+			return JSON.stringify(virtualIds.map((virtualId) => {
+				const fileName = symbolFiles.get(virtualId);
+				if (!fileName) return virtualId;
+				rewritten++;
+				return relativeChunkSpecifier(chunk.fileName, fileName);
+			}));
+		}).replace(SYMBOL_VIRTUAL_STRING_RE$1, (match, _quote, virtualId) => {
 			const fileName = symbolFiles.get(virtualId);
 			if (!fileName) {
 				unresolved.add(virtualId);
@@ -1403,6 +1996,11 @@ function parseStringArray(source) {
 	if (source.slice(end).trim() !== "]") return void 0;
 	return values;
 }
+function parseStringList(source) {
+	if (source.startsWith("[")) return parseStringArray(source);
+	const packed = source.match(/^(["'`])([^"'`]*)\1\.split\(\s*(["'`])([^"'`]*)\3\s*\)$/);
+	return packed ? packed[2].split(packed[4]) : void 0;
+}
 function relativeChunkSpecifier(importerFileName, targetFileName) {
 	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
 	return value.startsWith(".") ? value : `./${value}`;
@@ -1496,6 +2094,9 @@ function createMarklessRolldownPlugin(input) {
 	const internalOptions = input.options ?? {};
 	const virtualModules = /* @__PURE__ */ new Map();
 	const transformManifests = /* @__PURE__ */ new Map();
+	const importedChildren = /* @__PURE__ */ new Map();
+	const importedChildSources = /* @__PURE__ */ new Set();
+	const emittedClientResolverSources = /* @__PURE__ */ new Set();
 	const sourceVirtualModules = /* @__PURE__ */ new Map();
 	const clientSymbolEntrySources = /* @__PURE__ */ new Set();
 	const executionLogEstimatedSizes = /* @__PURE__ */ new Map();
@@ -1512,8 +2113,16 @@ function createMarklessRolldownPlugin(input) {
 	return {
 		api: { invalidateGeneratedModules(parent, currentEnvironment) {
 			const ids = dev.clear(parent, currentEnvironment);
-			for (const id of ids) virtualModules.delete(id);
-			return ids.map(resolveVirtualId);
+			const resolvedIds = /* @__PURE__ */ new Set();
+			for (const id of ids) {
+				const type = virtualModules.get(id)?.type;
+				virtualModules.delete(id);
+				const resolvedId = resolveVirtualId(id);
+				resolvedIds.add(resolvedId);
+				if (type === "style") resolvedIds.add(`${resolvedId}?direct`);
+			}
+			if ((currentEnvironment === "client" || currentEnvironment === void 0 && environment === "client") && internalOptions.dev === true && normalizeExecutionLogMode(internalOptions.executionLog) !== "never") resolvedIds.add(resolveVirtualId(MARKLESS_EXECUTION_LOG_MODULE_ID));
+			return [...resolvedIds];
 		} },
 		name,
 		options(input) {
@@ -1528,6 +2137,9 @@ function createMarklessRolldownPlugin(input) {
 			clientSymbolEntrySources.clear();
 			virtualModules.clear();
 			transformManifests.clear();
+			importedChildren.clear();
+			importedChildSources.clear();
+			emittedClientResolverSources.clear();
 			sourceVirtualModules.clear();
 			executionLogEstimatedSizes.clear();
 			dev.reset();
@@ -1554,10 +2166,14 @@ function createMarklessRolldownPlugin(input) {
 				id: resolveVirtualId(MARKLESS_EXECUTION_LOG_MODULE_ID),
 				moduleSideEffects: true
 			};
-			if (virtualModules.has(normalized)) return {
-				id: resolveVirtualId(normalized),
-				moduleSideEffects: true
-			};
+			const virtualModule = virtualModules.get(normalized);
+			if (virtualModule) {
+				const directQuery = virtualModule.type === "style" && /(?:[?&])direct(?:[=&]|$)/.test(source) ? "?direct" : "";
+				return {
+					id: `${resolveVirtualId(normalized)}${directQuery}`,
+					moduleSideEffects: true
+				};
+			}
 			const symbolSource = sourceForSymbolVirtualImporter(importer);
 			if (symbolSource && isRelativeImport(source)) return await this.resolve(source, symbolSource, { skipSelf: true });
 			const resumeSource = sourceForResumeVirtualImporter(importer);
@@ -1565,10 +2181,14 @@ function createMarklessRolldownPlugin(input) {
 			return null;
 		},
 		load(id) {
-			if (normalizeVirtualId(id) === "virtual:markless:dev-log") return executionLogVirtualModuleSource({
-				moduleSizes: internalOptions.dev === true && getEnvironment(this) === "client" ? executionLogEstimatedSizes : void 0,
-				sizesUrl: internalOptions.dev === true ? void 0 : internalOptions.publicPath?.(MARKLESS_EXECUTION_SIZES) ?? `/${MARKLESS_EXECUTION_SIZES}`
-			});
+			if (normalizeVirtualId(id) === "virtual:markless:dev-log") {
+				const embedsDevSizes = internalOptions.dev === true && getEnvironment(this) === "client";
+				return executionLogVirtualModuleSource({
+					moduleSizes: embedsDevSizes ? executionLogEstimatedSizes : void 0,
+					attribution: embedsDevSizes ? executionAttributionTables(transformManifests, getRoot(), importedChildren.values()) : void 0,
+					sizesUrl: internalOptions.dev === true ? void 0 : internalOptions.publicPath?.(MARKLESS_EXECUTION_SIZES) ?? `/${MARKLESS_EXECUTION_SIZES}`
+				});
+			}
 			const module = virtualModules.get(normalizeVirtualId(id));
 			if (module) return virtualModuleSourceForLoad(module, {
 				dev: internalOptions.dev === true && getEnvironment(this) === "client",
@@ -1592,15 +2212,54 @@ function createMarklessRolldownPlugin(input) {
 			if (virtualId.startsWith("virtual:markless:")) return null;
 			const source = pathname(id);
 			clearSourceVirtualModules(source, virtualModules, sourceVirtualModules);
-			const transformed = await transformTsrxModule({
+			let transformed = await transformTsrxModule({
+				filename: source,
+				source: code,
+				buildId: internalOptions.buildId,
+				executionLog: normalizeExecutionLogMode(internalOptions.executionLog),
+				executionLogModuleHooks: internalOptions.dev === true && currentEnvironment === "client",
+				inlineResumerDebug: internalOptions.inlineResumerDebug === true,
+				environment: currentEnvironment,
+				clientOutput: currentEnvironment === "client" && (clientSymbolEntrySources.has(source) || isSymbolOnlySourceRequest(id)) ? "symbols-only" : void 0,
+				resumeModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? devBrowserSourceModuleUrl(source, getRoot(), internalOptions.publicPath) : void 0,
+				styleModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? (virtualId) => withQuery(devBrowserVirtualModuleUrl(virtualId, internalOptions.publicPath), { direct: null }) : void 0,
+				headInjections: internalOptions.dev === true && currentEnvironment === "server" ? internalOptions.devInjections : void 0,
+				devResumeReexport: internalOptions.dev === true && currentEnvironment === "client"
+			});
+			registerTransformArtifacts({
+				source,
+				result: transformed,
+				virtualModules,
+				transformManifests,
+				sourceVirtualModules,
+				executionLogEstimatedSizes,
+				dev,
+				environment: currentEnvironment
+			});
+			const resolvedChildren = await resolveImportedChildren.call(this, source, transformed.manifest);
+			for (const child of resolvedChildren) {
+				importedChildren.set(importedChildKey(child), child);
+				importedChildSources.add(child.source);
+			}
+			for (const child of resolvedChildren) {
+				if (!transformManifests.has(child.source)) {
+					if (internalOptions.dev === true) await internalOptions.devServer?.transformRequest(child.source, currentEnvironment);
+					else if (typeof this.load === "function") await this.load({ id: child.source });
+				}
+				if (internalOptions.dev === true) validateImportedChild(child, transformManifests);
+			}
+			if (resolvedChildren.length > 0) transformed = await transformTsrxModule({
 				filename: source,
 				source: code,
 				buildId: internalOptions.buildId,
+				symbols: importedSymbolInputs(resolvedChildren, transformManifests),
 				executionLog: normalizeExecutionLogMode(internalOptions.executionLog),
 				executionLogModuleHooks: internalOptions.dev === true && currentEnvironment === "client",
+				inlineResumerDebug: internalOptions.inlineResumerDebug === true,
 				environment: currentEnvironment,
 				clientOutput: currentEnvironment === "client" && (clientSymbolEntrySources.has(source) || isSymbolOnlySourceRequest(id)) ? "symbols-only" : void 0,
 				resumeModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? devBrowserSourceModuleUrl(source, getRoot(), internalOptions.publicPath) : void 0,
+				styleModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? (virtualId) => withQuery(devBrowserVirtualModuleUrl(virtualId, internalOptions.publicPath), { direct: null }) : void 0,
 				headInjections: internalOptions.dev === true && currentEnvironment === "server" ? internalOptions.devInjections : void 0,
 				devResumeReexport: internalOptions.dev === true && currentEnvironment === "client"
 			});
@@ -1614,6 +2273,7 @@ function createMarklessRolldownPlugin(input) {
 				dev,
 				environment: currentEnvironment
 			});
+			for (const child of resolvedChildren) dev.record(child.source, [transformed.manifest.resolver.virtualModuleId], currentEnvironment);
 			if (currentEnvironment === "client" && isResumeSourceRequest(id)) {
 				const resumeModule = transformed.virtualModules.find((module) => module.type === "resume");
 				if (resumeModule) return {
@@ -1621,16 +2281,24 @@ function createMarklessRolldownPlugin(input) {
 					map: null
 				};
 			}
-			if (currentEnvironment === "client" && !internalOptions.dev) for (const module of transformed.virtualModules.filter((item) => item.type === "symbol" || item.type === "resume" && internalOptions.emitResumeModules === true && clientSymbolEntrySources.has(source))) this.emitFile({
-				type: "chunk",
-				id: module.id,
-				preserveSignature: "strict"
-			});
+			if (currentEnvironment === "client" && !internalOptions.dev) for (const module of transformed.virtualModules.filter((item) => {
+				if (item.type === "symbol") return true;
+				if (item.type === "resolver") return (importedChildSources.has(source) || (transformed.manifest.captureMetadata?.boundResolverRows?.length ?? 0) > 0) && !emittedClientResolverSources.has(source);
+				return item.type === "resume" && internalOptions.emitResumeModules === true && clientSymbolEntrySources.has(source);
+			})) {
+				this.emitFile({
+					type: "chunk",
+					id: module.id,
+					preserveSignature: "strict"
+				});
+				if (module.type === "resolver") emittedClientResolverSources.add(source);
+			}
 			return transformed;
 		},
 		generateBundle: {
 			order: "post",
 			async handler(_, bundle) {
+				for (const child of importedChildren.values()) validateImportedChild(child, transformManifests);
 				if (getEnvironment(this) !== "client") return;
 				stripEmptyPreloadWrappersFromChunks(bundle);
 				const removedSymbolFacades = rewriteGeneratedSymbolFacadeImports(bundle);
@@ -1638,7 +2306,9 @@ function createMarklessRolldownPlugin(input) {
 				compactGeneratedDirectSymbolLoaders(bundle);
 				const manifestBundle = bundleWithoutRemovedChunks(bundle, removedSymbolFacades);
 				const tableRewrite = rewriteGeneratedSymbolTableUrls(manifestBundle);
-				if (tableRewrite.unresolved.length > 0) this.error(`Markless symbol resolver table contains unresolved generated symbol chunks: ${tableRewrite.unresolved.join(", ")}`);
+				if (tableRewrite.unresolved.length > 0) this.error(`Markless symbol resolver table contains unresolved generated symbol chunks: ${tableRewrite.unresolved.join(", ")}. markless debugging playbook: run pnpm doctor, or read agent/markless.md in the installed @markless/core package`);
+				const tableIntegrity = verifyGeneratedSymbolTableRoutes(manifestBundle, transformManifests.values());
+				if (tableIntegrity.errors.length > 0) this.error(`Markless symbol resolver table integrity check failed:\n${tableIntegrity.errors.map((error) => `- ${error.symbolId} -> ${error.claimedChunk}: ${error.reason}`).join("\n")}`);
 				const clientManifest = createBuildMetadata(manifestBundle, transformManifests.values(), getRoot(), {
 					bundleGraphAsset: MARKLESS_BUNDLE_GRAPH,
 					bundleGraphAdders: internalOptions.bundleGraphAdders,
@@ -1657,7 +2327,7 @@ function createMarklessRolldownPlugin(input) {
 					fileName: MARKLESS_BUNDLE_GRAPH,
 					source: JSON.stringify(clientManifest.bundleGraph)
 				});
-				this.emitFile(await createExecutionSizesAsset(manifestBundle, clientManifest, stripBuildPrefix));
+				this.emitFile(await createExecutionSizesAsset(manifestBundle, clientManifest, stripBuildPrefix, executionLogInjection ? executionAttributionTables(transformManifests, getRoot(), importedChildren.values()) : void 0));
 				this.emitFile({
 					type: "asset",
 					fileName: `${MARKLESS_BUILD_PREFIX}execution-demand.json`,
@@ -1667,6 +2337,88 @@ function createMarklessRolldownPlugin(input) {
 		}
 	};
 }
+async function resolveImportedChildren(parent, manifest) {
+	return await Promise.all((manifest.symbolRoutes ?? []).map(async (route) => {
+		const resolvedImport = await this.resolve(route.importSource, parent, { skipSelf: true });
+		const resolvedId = typeof resolvedImport === "string" ? resolvedImport : resolvedImport && typeof resolvedImport === "object" && "id" in resolvedImport ? String(resolvedImport.id) : fallbackImportedSource(parent, route.importSource);
+		return {
+			parent,
+			specifier: route.importSource,
+			source: pathname(resolvedId),
+			componentEdgeId: route.componentEdgeId
+		};
+	}));
+}
+function importedSymbolInputs(children, manifests) {
+	return children.flatMap((child) => {
+		const manifest = manifests.get(child.source);
+		if (!manifest?.captureMetadata || !child.componentEdgeId) return [];
+		return manifest.symbols.flatMap((symbol) => {
+			const captureSymbol = manifest.captureMetadata?.extractedSymbols.find((candidate) => candidate.symbolId === symbol.symbolId);
+			return captureSymbol?.captureSlots.some((slot) => slot.propName !== void 0) ? [{
+				id: `imported:${encodeURIComponent(child.source)}:${symbol.symbolId}`,
+				chunk: symbol.virtualModuleId,
+				exportName: symbol.exportName,
+				componentEdgeId: child.componentEdgeId,
+				captureSymbol
+			}] : [];
+		});
+	});
+}
+function fallbackImportedSource(parent, specifier) {
+	const source = specifier.split("?")[0];
+	return isRelativeImport(source) ? resolve(dirname(parent), source) : source;
+}
+function importedChildKey(child) {
+	return `${child.parent}\0${child.specifier}\0${child.source}`;
+}
+function validateImportedChild(child, manifests) {
+	const parentMetadata = manifests.get(child.parent)?.captureMetadata;
+	const childMetadata = manifests.get(child.source)?.captureMetadata;
+	if (!childMetadata && isPlainTypeScriptSource(child.source)) return;
+	if (parentMetadata && childMetadata?.passId === parentMetadata.passId && Array.isArray(childMetadata.extractedSymbols) && Array.isArray(childMetadata.diagnostics)) return;
+	throw new Error(`MARKLESS_CAPTURE_METADATA_MISSING: Parent module ${JSON.stringify(child.parent)} composes imported child ${JSON.stringify(child.specifier)}, but its compiled artifact has no current capture metadata. Rebuild the child with the current Markless compiler and clear any stale build cache.`);
+}
+function isPlainTypeScriptSource(source) {
+	return /\.[cm]?tsx?$/.test(source);
+}
+function executionAttributionRoots(manifests, childrenByRoute) {
+	const children = /* @__PURE__ */ new Set();
+	for (const manifest of manifests.values()) for (const route of manifest.symbolRoutes ?? []) {
+		const child = resolvedRouteSource(manifest.source, route.importSource, childrenByRoute);
+		if (manifests.has(child)) children.add(child);
+	}
+	return [...manifests.keys()].filter((source) => !children.has(source));
+}
+function executionAttributionTables(manifests, root, children) {
+	const childrenByRoute = new Map([...children].map((child) => [routeKey(child.parent, child.specifier), child.source]));
+	return Object.fromEntries(executionAttributionRoots(manifests, childrenByRoute).sort().map((source) => [executionAttributionRouteKey(source, root), flattenExecutionAttributionScopes(source, manifests, childrenByRoute)]));
+}
+function executionAttributionRouteKey(source, root) {
+	const prefix = root ? `${root.replace(/[/\\]+$/, "")}/` : "";
+	return (prefix && source.startsWith(prefix) ? source.slice(prefix.length) : source).replace(/^[/\\]+/, "");
+}
+function flattenExecutionAttributionScopes(root, manifests, childrenByRoute) {
+	const scopes = {};
+	const visit = (source, scope, seen) => {
+		if (seen.has(source)) return;
+		scopes[scope] = encodedSymbolSource(source);
+		const manifest = manifests.get(source);
+		for (const route of manifest?.symbolRoutes ?? []) {
+			const child = resolvedRouteSource(source, route.importSource, childrenByRoute);
+			if (!manifests.has(child)) continue;
+			visit(child, scope + route.prefix, new Set([...seen, source]));
+		}
+	};
+	visit(root, "", /* @__PURE__ */ new Set());
+	return scopes;
+}
+function resolvedRouteSource(parent, specifier, childrenByRoute) {
+	return childrenByRoute.get(routeKey(parent, specifier)) ?? fallbackImportedSource(parent, specifier);
+}
+function routeKey(parent, specifier) {
+	return `${parent}\0${specifier}`;
+}
 function bundleWithoutRemovedChunks(bundle, removedFileNames) {
 	if (removedFileNames.size === 0) return bundle;
 	const next = {};
@@ -1799,4 +2551,4 @@ function pathname(id) {
 	return parsePath(id).pathname;
 }
 //#endregion
-export { transformTsrxModule as a, convertManifestToBundleGraph as c, marklessServer as i, createPreloadGraphAdder as l, marklessClient as n, createBuildMetadata as o, marklessLib as r, collectHeadLinkInjections as s, createMarklessRolldownPlugin as t };
+export { preflightTsrxModuleDiagnostics as a, collectHeadLinkInjections as c, marklessServer as i, convertManifestToBundleGraph as l, marklessClient as n, transformTsrxModule as o, marklessLib as r, createBuildMetadata as s, createMarklessRolldownPlugin as t, createPreloadGraphAdder as u };