@markless/bundler 0.8.0 → 0.10.0

package/dist/vite.js

@@ -1,19 +1,25 @@
+import { i as persistentCompileCacheAvailable, n as compilerFingerprint, r as createPersistentCompileCache } from "./compile-store-DxF9Vj4_.js";
 import { a as MARKLESS_DEV_RELOADS_ATTRIBUTE, d as renderMarklessDevErrorDocument, i as MARKLESS_DEV_PAGE_EDIT_EVENT, n as MARKLESS_DEV_ERROR_CLIENT_ID, o as MARKLESS_DEV_RELOADS_EVENT, r as MARKLESS_DEV_ERROR_EVENT, t as MARKLESS_DEV_ERROR_CLEAR_EVENT, u as normalizeMarklessDevError } from "./dev-error-BEduK_R3.js";
-import { N as pathname, R as sharedReachedRenderDataRequest, at as outputDefaults, ct as STORAGE_FREE_RESUME_ENTRY_SPECIFIER, kt as executionLogActivationInjection, st as RESUME_ENTRY_SPECIFIER, t as MARKLESS_DEFERRED_PACK } from "./route-pack-groups-BLS6xeVV.js";
-import { n as includeOptimizedDeps, t as excludeSourceShippedDeps } from "./optimized-deps-BfzxSm6C.js";
-import { A as INLINE_DEFER_LOADER_SOURCE, D as prefetchChunkParses, M as inlineDeferSource, N as moduleIdFor, O as preflightTsrxModuleDiagnostics, _ as createPreloadGraphAdder, a as collapseInitFacadeImports, d as nativePackingEnabled, f as nativePackingPlugins, h as withUndemandedReExportDoors, j as createInlineDeferTriggerSource, l as marklessRuntimeSpecifierId, m as undemandedRuntimeModules, o as unwrapAsyncImportWrappers, p as isReExportDoor, t as createMarklessRolldownPlugin, u as DEPRECATED_NATIVE_PACKING_WARNING, v as entryReachableModuleIds, y as runtimeModuleIdFromOrigin } from "./rolldown-BMQrr9-Y.js";
+import { A as sharedReachedRenderDataRequest, T as pathname, W as usePersistentStrippedCode, i as STRING_EXPORT_QUERY, it as includeOptimizedDeps, m as isCompilerStatefulModuleId, ot as runtimeFunctionSpecifiers, rt as excludeSourceShippedDeps, tt as outputDefaults, z as preflightTsrxModuleDiagnostics } from "./planned-landing-BHy22Yf5.js";
+import { C as MARKLESS_VIRTUAL_PREFIX, Q as PROTOCOL_BLOCK_START_COMMENT, T as STORAGE_FREE_RESUME_ENTRY_SPECIFIER, X as createInlineDeferTriggerSource, Y as INLINE_DEFER_LOADER_SOURCE, Z as inlineDeferSource, f as PACK_COST_MODEL, h as moduleIdFor, rt as executionLogActivationInjection, t as MARKLESS_DEFERRED_PACK, w as RESUME_ENTRY_SPECIFIER } from "./route-pack-groups-ByQmKKom.js";
+import { o as clearChunkFactCaches } from "./chunk-ast-pN_P5wIo.js";
+import { a as collapseInitFacadeImports, b as runtimeModuleIdFromOrigin, c as marklessRuntimeSpecifierId, d as nativePackingPlugins, f as isReExportDoor, g as isPlannedCoLocation, h as dynamicImportersOf, l as DEPRECATED_NATIVE_PACKING_WARNING, m as withUndemandedReExportDoors, p as undemandedRuntimeModules, t as createMarklessRolldownPlugin, u as nativePackingEnabled, v as createPreloadGraphAdder, y as entryReachableModuleIds } from "./rolldown-DS8OY1i9.js";
+import { a as createCompileWorkerPool, i as buildWorkerCount, n as prefetchChunkDynamicImports, u as unwrapAsyncImportWrappers } from "./lazy-module-facades-qZajWDD8.js";
 import { n as marklessRosterPositions, r as marklessRosterRenderContext, t as marklessRosterPositionSeeds } from "./shared-seed-slot-ihIVCD2S.js";
+import { DEBUGGING_PLAYBOOK_HINT, evaluateModuleConstants, parseJavaScriptModule, useCompileRunner, usePersistentCompileStore } from "@markless/compiler";
+import { readFileSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { builtinModules } from "node:module";
+import { isAbsolute, join, relative, resolve } from "pathe";
 import { joinURL, parsePath, withQuery } from "ufo";
 import { ASYNC_PROTOCOL_VERSION, PROTOCOL_CONTAINER_HOST_NODE_ID, STORAGE_SLOT_SYMBOL_KEY, escapeScriptJson, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName, storageCookieName, storageSlotEntryKeyFromGraphNodeId } from "@markless/serializer";
-import { isAbsolute, join, resolve } from "pathe";
-import { DEBUGGING_PLAYBOOK_HINT } from "@markless/compiler";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { isAbsolute as isAbsolute$1 } from "node:path";
 import { pathToFileURL } from "node:url";
-import { createServerModuleRunner, isRunnableDevEnvironment } from "vite";
 import { tmpdir } from "node:os";
+import { isAbsolute as isAbsolute$1 } from "node:path";
+import { createServerModuleRunner, isCSSRequest, isRunnableDevEnvironment } from "vite";
 import { PROTOCOL_CONTAINER_END_COMMENT, PROTOCOL_CONTAINER_START_COMMENT, PROTOCOL_EVENT_ACTION_KIND as PROTOCOL_EVENT_ACTION_KIND$1, PROTOCOL_EVENT_HOST_ATTRIBUTE, PROTOCOL_EVENT_HOST_DELEGATED_REF, PROTOCOL_IDLE_EVENT_NAME as PROTOCOL_IDLE_EVENT_NAME$1, PROTOCOL_LOCATOR_PATHS_ATTRIBUTE, PROTOCOL_SYNC_POLICY_TABLE_TYPE, PROTOCOL_VISIBLE_EVENT_NAME, constantSyncPolicyCode, formatEventHostEntries, protocolEventDispatchesMarkless, syncPolicyNeverActs } from "@markless/serializer/protocol";
 import "@markless/serializer/resume-record-delta";
+import { analyze } from "yuku/analyzer";
 //#region ../web/src/inline/served-census.ts
 /**
 * Pins the container's elements in DOM order as its census and returns them,
@@ -39,7 +45,24 @@ function marklessServedCensus(root, attribute) {
 	return value && (parseInt(value) !== live.length || order && order !== (signature >>> 0).toString(36)) ? (root.__marklessShifted = 1, []) : live;
 }
 //#endregion
+//#region ../serializer/src/protocol-record-keys.ts
+/** The field names each templated record list may spell, in the order its templates index them. */
+const PROTOCOL_RECORD_KEYS = {
+	"markless/state": {
+		computed: "graphNodeId name async deriveSymbolId value version root $type $ref source flags records id type fields items entries values bytes arrayType buffer byteOffset length byteLength directValue dependencies path snapshot status key error hostScope",
+		sharedSeeds: "graphNodeId deriveSymbolId dependencies path reads",
+		sharedDefinitions: "id name exportedName scope version graphNodeIds projectionIds dependencies definitionId definitionName returnProperties kind graphNodeId path"
+	},
+	"markless/view": {
+		domUpdates: "hostNodeId source graphNodeId path target kind prefix suffix trueValue falseValue textNode name constantClass leadingClass symbolId",
+		behaviors: "hostNodeId source functionSource inputSources inputValues inputGraphReads inputIndex graphNodeId path symbolId usesGraph",
+		elementHandles: "hostNodeId handleId name plural"
+	}
+};
+//#endregion
 //#region ../web/src/inline/resumer.ts
+const listKeys = (type, list) => PROTOCOL_RECORD_KEYS[type][list] ?? "";
+listKeys("markless/state", "cells"), listKeys("markless/state", "sharedRecords"), listKeys("markless/view", "events");
 const withPageMarkers = (source) => source.replaceAll("__MARKLESS_PAGE_START__", JSON.stringify(PROTOCOL_CONTAINER_START_COMMENT)).replaceAll("__MARKLESS_PAGE_END__", JSON.stringify(PROTOCOL_CONTAINER_END_COMMENT));
 const servedCensusSource = () => withPageMarkers(marklessServedCensus.toString());
 PROTOCOL_EVENT_ACTION_KIND$1.event, PROTOCOL_EVENT_ACTION_KIND$1.externalDelegate;
@@ -163,11 +186,13 @@ function runPrerenderInlineResumer(eventNames, fallbackResumeModuleUrl, loadModu
 	const root = currentScript?.closest("[data-async-container]");
 	const resumeModuleUrl = currentScript?.getAttribute?.("data-markless-resume-module") ?? fallbackResumeModuleUrl;
 	if (!root || !resumeModuleUrl) return;
+	const life = root.__mL ||= {};
 	let loaded;
 	const dispatch = (event) => {
+		if (root.__mL !== life) return root.removeEventListener(event.type, dispatch, true);
 		root.__marklessDelegatedDispatch = true;
 		if (!root.__marklessCensus) census(root, pathsAttribute);
-		return (loaded ||= loadModule(resumeModuleUrl)).then((module) => module.resumeContainerEvent({
+		return (loaded ||= loadModule(resumeModuleUrl)).then((module) => root.__mL === life && module.resumeContainerEvent({
 			root,
 			event,
 			element: event.target,
@@ -181,10 +206,12 @@ function runInlineResumerSelfWake(fallbackResumeModuleUrl, loadModule, defer) {
 	const root = currentScript?.closest("[data-async-container]");
 	const resumeModuleUrl = currentScript?.getAttribute?.("data-markless-resume-module") ?? fallbackResumeModuleUrl;
 	if (!root || !resumeModuleUrl) return;
+	const life = root.__mL ||= {};
 	defer.idle(root, async () => {
-		if (root.__asyncResumeRuntimeStarted) return;
+		if (root.__asyncResumeRuntimeStarted || root.__mL !== life) return;
 		root.__marklessDelegatedDispatch = true;
-		await (await (root.__mResume ||= loadModule(resumeModuleUrl))).resumeContainerEvent({
+		const module = await (root.__mResume ||= loadModule(resumeModuleUrl));
+		if (root.__mL === life) await module.resumeContainerEvent({
 			root,
 			event: 0
 		});
@@ -195,8 +222,9 @@ function runInlineResumerOverlayPrimer(fallbackResumeModuleUrl, loadModule) {
 	const root = currentScript?.closest("[data-async-container]");
 	const resumeModuleUrl = currentScript?.getAttribute?.("data-markless-resume-module") ?? fallbackResumeModuleUrl;
 	if (!root || !resumeModuleUrl) return;
+	const life = root.__mL ||= {};
 	const prime = (event) => {
-		if (root.__marklessOverlayInstalled) {
+		if (root.__marklessOverlayInstalled || root.__mL !== life) {
 			removeEventListener("keydown", prime, true);
 			removeEventListener("pointerdown", prime, true);
 			return;
@@ -213,9 +241,9 @@ function runInlineResumerOverlayPrimer(fallbackResumeModuleUrl, loadModule) {
 			root.__marklessCensus = census;
 		}
 		setTimeout(() => {
-			if (root.__marklessDelegatedDispatch === true) return;
+			if (root.__marklessDelegatedDispatch === true || root.__mL !== life) return;
 			root.__marklessDelegatedDispatch = true;
-			loadModule(resumeModuleUrl).then((module) => module.resumeContainerEvent({
+			loadModule(resumeModuleUrl).then((module) => root.__mL === life && module.resumeContainerEvent({
 				root,
 				event: 0
 			}));
@@ -370,11 +398,24 @@ function servedElementTree(html) {
 	const elements = [{
 		tag: "",
 		parent: -1,
-		child: 0
+		child: 0,
+		node: 0
 	}];
 	const childCounts = [0];
+	const nodeCounts = [0];
+	const inText = [false];
+	const current = () => stack.length ? stack[stack.length - 1].index : 0;
+	const node = (parent, text) => {
+		if (templateDepth > 0 || text && inText[parent]) return;
+		nodeCounts[parent]++;
+		inText[parent] = text;
+	};
 	const commentElementIndexes = [];
 	const nameEnds = [0];
+	const addressSteps = [[]];
+	const blockSteps = /* @__PURE__ */ new Map();
+	const openBlocks = [[]];
+	const stepsOf = (parent) => openBlocks[parent].at(-1)?.steps ?? addressSteps[parent];
 	const stack = [];
 	let templateDepth = 0;
 	let foreignDepth = 0;
@@ -383,11 +424,28 @@ function servedElementTree(html) {
 	while (at < html.length) {
 		const open = html.indexOf("<", at);
 		if (open < 0) break;
+		if (open > at) node(current(), true);
 		if (html.startsWith("<!--", open)) {
+			node(current(), false);
 			const end = html.indexOf("-->", open + 4);
 			at = end < 0 ? html.length : end + 3;
 			const data = html.slice(open + 4, end < 0 ? html.length : end);
-			if (templateDepth === 0 && !isArmBranchAnchorComment({
+			if (templateDepth > 0) continue;
+			const parent = current();
+			if (openBlocks[parent].at(-1)?.end === data) openBlocks[parent].pop();
+			else if (PROTOCOL_BLOCK_START_COMMENT.test(data)) {
+				const steps = [];
+				stepsOf(parent).push(-1);
+				openBlocks[parent].push({
+					end: `/${data}`,
+					steps
+				});
+				if (!isArmBranchAnchorComment({
+					nodeType: 8,
+					data
+				})) blockSteps.set(commentElementIndexes.length, steps);
+			}
+			if (!isArmBranchAnchorComment({
 				nodeType: 8,
 				data
 			})) commentElementIndexes.push(elements.length);
@@ -395,6 +453,7 @@ function servedElementTree(html) {
 		}
 		const next = html[open + 1] ?? "";
 		if (next === "!" || next === "?") {
+			node(current(), false);
 			const end = html.indexOf(">", open);
 			at = end < 0 ? html.length : end + 1;
 			continue;
@@ -403,6 +462,7 @@ function servedElementTree(html) {
 		const nameStart = closing ? open + 2 : open + 1;
 		const nameMatch = /^[a-zA-Z][^\s/>]*/.exec(html.slice(nameStart, nameStart + 64));
 		if (!nameMatch) {
+			node(current(), true);
 			at = open + 1;
 			continue;
 		}
@@ -428,10 +488,17 @@ function servedElementTree(html) {
 			index = elements.push({
 				tag,
 				parent,
-				child: childCounts[parent]++
+				child: childCounts[parent]++,
+				node: nodeCounts[parent]
 			}) - 1;
+			node(parent, false);
+			stepsOf(parent).push(index);
 			childCounts.push(0);
+			nodeCounts.push(0);
+			inText.push(false);
 			nameEnds.push(nameStart + name.length);
+			addressSteps.push([]);
+			openBlocks.push([]);
 		}
 		if (VOID_TAGS.has(lower) || selfClosing) continue;
 		if (PROTOCOL_RAW_TEXT_TAGS.has(lower)) {
@@ -450,7 +517,9 @@ function servedElementTree(html) {
 		elements,
 		childCounts,
 		commentElementIndexes,
-		nameEnds
+		nameEnds,
+		addressSteps,
+		blockSteps
 	};
 }
 /** Writes `attribute="value"` on each element the map names by its index in servedElementTree(html). */
@@ -553,7 +622,7 @@ async function assemblePrerenderPageParts(component, output, options) {
 }
 async function renderSsrOutput(component, props, renderContext) {
 	assertPageRenderable(component);
-	globalThis.__marklessRosterResume ??= () => import("./roster-resume-CpphsFl_.js");
+	globalThis.__marklessRosterResume ??= () => import("./roster-resume-DXptD6DG.js");
 	const context = marklessSsrRosterPositionContext(renderContext);
 	if (typeof component === "function") return marklessSsrRosterCounted(context, await marklessSsrDeferredCounted(context, await component(props, context)));
 	if (component && typeof component.renderSsr === "function") return marklessSsrRosterCounted(context, await marklessSsrDeferredCounted(context, await component.renderSsr(props, context)));
@@ -718,8 +787,64 @@ function addEventHostEntry(marks, index, entry) {
 	const entries = marks.get(index);
 	if (!entries) return void marks.set(index, [entry]);
 	const same = entries.findIndex((candidate) => candidate.name === entry.name);
-	if (same < 0) entries.push(entry);
-	else if (entries[same].ref === void 0 && entry.ref !== void 0) entries[same] = entry;
+	if (same < 0) return void entries.push(entry);
+	const held = entries[same];
+	entries[same] = {
+		...held,
+		...held.ref === void 0 && entry.ref !== void 0 ? { ref: entry.ref } : {},
+		...held.policy === void 0 && entry.policy !== void 0 ? { policy: entry.policy } : {}
+	};
+}
+const childLists = /* @__PURE__ */ new WeakMap();
+function addRowPolicyMarks(marks, tree, parent, repeat, policyTable) {
+	if (repeat.rowEndOffset === void 0) return;
+	const events = repeat.rowEvents.flatMap((event) => {
+		const policy = policyTable.entry(event.syncPolicy);
+		return policy === void 0 ? [] : [{
+			...event,
+			policy
+		}];
+	});
+	if (!events.length) return;
+	const rows = servedChildren(tree, parent);
+	for (const row of rows.slice(repeat.rowStartOffset ?? 0, rows.length - repeat.rowEndOffset)) for (const event of events) {
+		const host = event.hostPath.length ? servedElementAt(tree, tree.addressSteps[row], event.hostPath) : row;
+		if (host !== void 0) addEventHostEntry(marks, host, {
+			name: event.eventName,
+			policy: event.policy
+		});
+	}
+}
+function servedChildren(tree, of) {
+	let lists = childLists.get(tree);
+	if (!lists) {
+		lists = tree.elements.map(() => []);
+		tree.elements.forEach((element, index) => index && lists.at(element.parent).push(index));
+		childLists.set(tree, lists);
+	}
+	return lists[of];
+}
+function servedElementAt(tree, steps, address) {
+	let host;
+	for (const step of address) {
+		host = steps?.at(step);
+		steps = host === void 0 || host < 0 ? void 0 : tree.addressSteps[host];
+	}
+	return host === void 0 || host < 0 ? void 0 : host;
+}
+function addPaintedArmPolicyMarks(marks, tree, branch, policyTable) {
+	const taken = branch.takenArm;
+	const set = taken === void 0 ? void 0 : branch.armRecords?.[taken];
+	const steps = tree.blockSteps.get(branch.startAnchor.index);
+	if (!set || !steps) return;
+	for (const event of set.events) {
+		const policy = policyTable.entry(event.syncPolicy);
+		const host = servedElementAt(tree, steps, event.hostPath);
+		if (policy !== void 0 && host !== void 0) addEventHostEntry(marks, host, {
+			name: event.eventName,
+			policy
+		});
+	}
 }
 function writeEventHostMarks(html, nameEnds, marks) {
 	return marks.size ? withElementAttributes(html, nameEnds, PROTOCOL_EVENT_HOST_ATTRIBUTE, new Map([...marks].map(([index, entries]) => [index, formatEventHostEntries(entries)]))) : html;
@@ -750,6 +875,7 @@ function withEventHostMarks(view, html, policyTable) {
 		const index = shell.get(repeat.parentHostNodeId);
 		if (index === void 0) continue;
 		for (const event of repeat.rowEvents) addEventHostEntry(marks, index, { name: event.eventName });
+		addRowPolicyMarks(marks, tree, index, repeat, policyTable);
 	}
 	for (const [anchor, records] of [...view.asyncBoundaries.map((boundary) => [boundary.startAnchor, boundary.armRecords]), ...(view.branches ?? []).map((branch) => [branch.startAnchor, branch.servedArmRecords])]) {
 		if (!records || Array.isArray(records)) continue;
@@ -766,7 +892,12 @@ function withEventHostMarks(view, html, policyTable) {
 				policy
 			});
 		}
+		for (const repeat of set.keyedRepeats ?? []) {
+			const index = arm.get(repeat.parentHostNodeId);
+			if (index !== void 0) addRowPolicyMarks(marks, tree, offset + index, repeat, policyTable);
+		}
 	}
+	for (const branch of view.branches ?? []) if (!branch.servedArmRecords) addPaintedArmPolicyMarks(marks, tree, branch, policyTable);
 	return writeEventHostMarks(html, tree.nameEnds, marks);
 }
 function renderSyncPolicyTableScript(policies) {
@@ -1378,6 +1509,7 @@ function deferredRuntimePacks(input) {
 }
 function deferredRuntimePlugin(demandMaps) {
 	let packs = /* @__PURE__ */ new Map();
+	let dynamicImporters = /* @__PURE__ */ new Map();
 	return {
 		name: "markless:deferred-runtime",
 		options(input) {
@@ -1388,6 +1520,7 @@ function deferredRuntimePlugin(demandMaps) {
 		},
 		buildEnd(error) {
 			packs = /* @__PURE__ */ new Map();
+			dynamicImporters = /* @__PURE__ */ new Map();
 			if (error) return;
 			const modules = /* @__PURE__ */ new Map();
 			for (const id of entryReachableModuleIds(this)) {
@@ -1406,6 +1539,10 @@ function deferredRuntimePlugin(demandMaps) {
 					moduleIds: modules.keys()
 				})
 			});
+			dynamicImporters = dynamicImportersOf(modules);
+		},
+		onLog(_level, log) {
+			if (isPlannedCoLocation(log, (id) => packs.get(id), dynamicImporters)) return false;
 		},
 		outputOptions(output) {
 			if (typeof output.codeSplitting !== "object") return null;
@@ -1414,6 +1551,7 @@ function deferredRuntimePlugin(demandMaps) {
 				codeSplitting: {
 					...output.codeSplitting,
 					groups: [{
+						debugName: "markless-deferred-runtime",
 						name: (id) => packs.get(id) ?? null,
 						priority: 1e3,
 						includeDependenciesRecursively: false
@@ -2167,6 +2305,590 @@ function installDevRuntimeImportResolution(server, clientEnvironment) {
 	}
 }
 //#endregion
+//#region src/vite/browser-node-guard.ts
+const NODE_IN_BROWSER_ERROR = "MARKLESS_NODE_IN_BROWSER";
+const VITE_BROWSER_EXTERNAL = "__vite-browser-external";
+const OPTIMIZER_BROWSER_EXTERNAL = "browser-external:";
+const builtinNames = builtinModules.filter((name) => !name.includes(":"));
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Specifiers that name a Node built-in: `node:*`, `bun:*`, or a bare built-in and its subpaths. */
+const NODE_BUILTIN_SPECIFIER = new RegExp(`^(?:node:|bun:|(?:${builtinNames.map(escape).join("|")})(?:/|$))`);
+function isNodeBuiltinSpecifier(specifier) {
+	return NODE_BUILTIN_SPECIFIER.test(specifier);
+}
+/** Free names that only exist in Node; a browser throws a ReferenceError on any of them. */
+const NODE_ONLY_GLOBALS = [
+	"process",
+	"Buffer",
+	"global",
+	"__dirname",
+	"__filename",
+	"require"
+];
+const NODE_GLOBAL_WORD = new RegExp(`\\b(?:${NODE_ONLY_GLOBALS.join("|")})\\b`);
+function parsed(code) {
+	for (const options of [
+		{
+			lang: "js",
+			sourceType: "module"
+		},
+		{
+			lang: "js",
+			sourceType: "commonjs"
+		},
+		{
+			lang: "ts",
+			sourceType: "module"
+		}
+	]) {
+		const module = analyze(code, options);
+		if (!module.diagnostics.some((diagnostic) => diagnostic.severity === "error")) return module;
+	}
+}
+function contains(outer, inner) {
+	return !!outer && outer.start <= inner.start && inner.end <= outer.end;
+}
+function testsTypeof(module, test, name) {
+	if (!test) return false;
+	return module.unresolvedReferences.some((reference) => {
+		const node = reference.node;
+		if (reference.name !== name || !contains(test, node)) return false;
+		const parent = module.parentOf(reference.node);
+		return parent?.type === "UnaryExpression" && parent.operator === "typeof";
+	});
+}
+function allowedUse(module, reference) {
+	const node = reference.node;
+	const parent = module.parentOf(reference.node);
+	if (parent?.type === "UnaryExpression" && parent.operator === "typeof") return true;
+	const name = reference.name;
+	if (name === "process" && parent?.type === "MemberExpression" && parent.object === reference.node && !parent.computed && parent.property.name === "env") return true;
+	if (name === "require" && parent?.type === "CallExpression" && parent.callee === reference.node && parent.arguments.length === 1 && parent.arguments[0].type === "Literal" && typeof parent.arguments[0].value === "string") return true;
+	for (const ancestor of module.ancestors(reference.node)) {
+		if (ancestor === node) continue;
+		if ((ancestor.type === "ConditionalExpression" || ancestor.type === "IfStatement") && !contains(ancestor.test, node) && testsTypeof(module, ancestor.test, name)) return true;
+		if (ancestor.type === "LogicalExpression" && contains(ancestor.right, node) && testsTypeof(module, ancestor.left, name)) return true;
+	}
+	return false;
+}
+function lineAndColumn(code, offset) {
+	let line = 1;
+	let lineStart = 0;
+	for (let index = code.indexOf("\n"); index !== -1 && index < offset; index = code.indexOf("\n", index + 1)) {
+		line++;
+		lineStart = index + 1;
+	}
+	const lineEnd = code.indexOf("\n", offset);
+	return {
+		line,
+		column: offset - lineStart + 1,
+		code: code.slice(lineStart, lineEnd === -1 ? void 0 : lineEnd).trim().slice(0, 120)
+	};
+}
+/**
+* The places `code` uses a Node-only global a browser does not have. `typeof X`, a branch that runs
+* only after testing `typeof X`, `process.env` (Vite replaces it, Vitest's browser runner provides
+* it) and a literal `require("x")` (the bundler resolves it) are allowed.
+*/
+function nodeGlobalUses(code) {
+	if (!NODE_GLOBAL_WORD.test(code)) return [];
+	const module = parsed(code);
+	if (!module) return [];
+	const uses = [];
+	for (const reference of module.unresolvedReferences) {
+		if (!NODE_ONLY_GLOBALS.includes(reference.name)) continue;
+		if (reference.inTypePosition) continue;
+		if (allowedUse(module, reference)) continue;
+		const node = reference.node;
+		uses.push({
+			name: reference.name,
+			...lineAndColumn(code, node.start)
+		});
+	}
+	return uses;
+}
+/** The shortest import chain from an entry to `id`, entry first; a link is `dynamic` when reached by `import()`. */
+function importChain(graph, id) {
+	const reachedFrom = /* @__PURE__ */ new Map([[id, null]]);
+	const queue = [id];
+	let root = id;
+	for (let index = 0; index < queue.length; index++) {
+		const current = queue[index];
+		const { static: staticImporters, dynamic } = graph.importers(current);
+		if (graph.isEntry(current) || staticImporters.length === 0 && dynamic.length === 0) {
+			root = current;
+			break;
+		}
+		for (const [importers, isDynamic] of [[staticImporters, false], [dynamic, true]]) for (const importer of importers) {
+			if (reachedFrom.has(importer)) continue;
+			reachedFrom.set(importer, {
+				toward: current,
+				dynamic: isDynamic
+			});
+			queue.push(importer);
+		}
+	}
+	const chain = [{
+		id: root,
+		dynamic: false
+	}];
+	for (let step = reachedFrom.get(root); step; step = reachedFrom.get(step.toward)) chain.push({
+		id: step.toward,
+		dynamic: step.dynamic
+	});
+	return chain;
+}
+function displayId(id, root) {
+	const clean = id.replace(/^\0/, "").replace(/\?.*$/, "");
+	const relativeToRoot = (path) => path.startsWith("/") && root ? relative(root, path) : path;
+	if (clean.startsWith("virtual:markless:")) {
+		const [kind = "", ...source] = clean.slice(MARKLESS_VIRTUAL_PREFIX.length).split(":");
+		return `${relativeToRoot(decodeURIComponent(source.join(":")))} (Markless ${kind.replaceAll("-", " ")} module)`;
+	}
+	return relativeToRoot(clean);
+}
+const FINDING_ORDER = {
+	builtin: 0,
+	"browser-field": 1,
+	global: 2
+};
+function compareFindings(a, b) {
+	if (a.kind !== b.kind) return FINDING_ORDER[a.kind] - FINDING_ORDER[b.kind];
+	if (a.kind === "global" && b.kind === "global") return a.use.line - b.use.line || a.use.column - b.use.column;
+	if (a.kind === "builtin" && b.kind === "builtin") return a.specifier < b.specifier ? -1 : a.specifier > b.specifier ? 1 : 0;
+	return 0;
+}
+function describeFinding(violation) {
+	switch (violation.kind) {
+		case "builtin": return `imports "${violation.specifier}", a Node built-in module`;
+		case "browser-field": return "imports a module its package removes from browser builds (its package.json \"browser\" field maps it to false)";
+		case "global": return `uses \`${violation.use.name}\` at ${violation.use.line}:${violation.use.column}, a global only Node has: ${violation.use.code}`;
+	}
+}
+/** The error a browser build fails with: each import chain once, what its last module does, then how to fix it. */
+function nodeInBrowserMessage(environment, violations, chainOf, root) {
+	const byImporter = /* @__PURE__ */ new Map();
+	for (const violation of violations) {
+		const list = byImporter.get(violation.importer) ?? [];
+		list.push(violation);
+		byImporter.set(violation.importer, list);
+	}
+	const sections = [...byImporter].map(([importer, findings]) => {
+		const lines = chainOf(importer).map((link, index) => {
+			return `${index === 0 ? "  " : link.dynamic ? "  → import() " : "  → "}${displayId(link.id, root)}`;
+		});
+		const described = [...new Set(findings.toSorted(compareFindings).map(describeFinding))];
+		return [...lines, ...described.map((finding) => `      ${finding}`)].join("\n");
+	});
+	return [
+		`${NODE_IN_BROWSER_ERROR}: Node-only code is reachable from the browser build ("${environment}").`,
+		"",
+		sections.join("\n\n"),
+		"",
+		"A browser cannot run Node code: Vite would ship an empty stand-in that breaks when it is used.",
+		"Fix: move what the browser side needs (a constant, a type, a pure function) into a module that imports nothing from Node, and import that module instead. Keep Node work in server-only files."
+	].join("\n");
+}
+function isBrowserExternal(id) {
+	return id === VITE_BROWSER_EXTERNAL || id.startsWith(`${VITE_BROWSER_EXTERNAL}:`);
+}
+function guardsEnvironment(environment) {
+	return environment.config.consumer === "client";
+}
+function devChain(environment, id) {
+	const graph = environment.moduleGraph;
+	return importChain({
+		importers: (current) => ({
+			static: [...graph?.getModuleById(current)?.importers ?? []].map((node) => node.id).filter((importer) => !!importer),
+			dynamic: []
+		}),
+		isEntry: () => false
+	}, id);
+}
+const ROLLDOWN_RUNTIME = "\0rolldown/runtime.js";
+/**
+* Fails every browser build, worker bundle and dev request that reaches a Node built-in, a module
+* Vite would replace with an empty browser stand-in, or a global only Node has.
+*/
+function browserNodeGuard() {
+	const violationsByEnvironment = /* @__PURE__ */ new Map();
+	const record = (environment, violation) => {
+		const list = violationsByEnvironment.get(environment) ?? [];
+		list.push(violation);
+		violationsByEnvironment.set(environment, list);
+	};
+	let root = "";
+	return {
+		name: "markless:browser-node-guard",
+		enforce: "pre",
+		applyToEnvironment(environment) {
+			return guardsEnvironment(environment);
+		},
+		configEnvironment(name, config) {
+			if ((config.consumer ?? (name === "client" ? "client" : "server")) !== "client") return void 0;
+			return { optimizeDeps: { rolldownOptions: { plugins: [optimizedDepsGuard(name, () => root)] } } };
+		},
+		configResolved(config) {
+			root = config.root;
+		},
+		config() {
+			return { worker: { plugins: () => [browserNodeGuard()] } };
+		},
+		buildStart() {
+			violationsByEnvironment.delete(this.environment.name);
+		},
+		resolveId: {
+			order: "pre",
+			filter: { id: NODE_BUILTIN_SPECIFIER },
+			async handler(source, importer, options) {
+				if (!importer) return null;
+				const resolved = await this.resolve(source, importer, {
+					...options,
+					skipSelf: true
+				});
+				if (!resolved) return null;
+				if (!(isBrowserExternal(resolved.id) || resolved.external !== false && resolved.external !== void 0 && isNodeBuiltinSpecifier(resolved.id))) return resolved;
+				const environment = this.environment;
+				const violation = {
+					kind: "builtin",
+					importer,
+					specifier: source
+				};
+				if (environment.mode === "dev") throw new Error(nodeInBrowserMessage(environment.name, [violation], (id) => devChain(environment, id), environment.config.root));
+				record(environment.name, violation);
+				return resolved;
+			}
+		},
+		transform: {
+			order: "post",
+			filter: { code: NODE_GLOBAL_WORD },
+			handler(code, id) {
+				if (id === ROLLDOWN_RUNTIME || isCSSRequest(id) || STRING_EXPORT_QUERY.test(id)) return null;
+				const environment = this.environment;
+				if (environment.depsOptimizer?.isOptimizedDepFile(id)) return null;
+				const uses = nodeGlobalUses(code);
+				if (uses.length === 0) return null;
+				const violations = uses.map((use) => ({
+					kind: "global",
+					importer: id,
+					use
+				}));
+				if (environment.mode === "dev") throw new Error(nodeInBrowserMessage(environment.name, violations, (target) => devChain(environment, target), environment.config.root));
+				for (const violation of violations) record(environment.name, violation);
+				return null;
+			}
+		},
+		buildEnd(error) {
+			if (error) return;
+			const environment = this.environment;
+			const violations = [...violationsByEnvironment.get(environment.name) ?? []];
+			violationsByEnvironment.delete(environment.name);
+			const recorded = new Set(violations.map((violation) => violation.kind === "builtin" ? `${violation.importer}\0${violation.specifier}` : ""));
+			const explained = new Set(violations.filter((violation) => violation.kind === "builtin").map((violation) => violation.importer));
+			for (const importer of this.getModuleIds()) {
+				const info = this.getModuleInfo(importer);
+				for (const id of [...info?.importedIds ?? [], ...info?.dynamicallyImportedIds ?? []]) if (isNodeBuiltinSpecifier(id)) {
+					if (!recorded.has(`${importer}\0${id}`)) violations.push({
+						kind: "builtin",
+						importer,
+						specifier: id
+					});
+				} else if (isBrowserExternal(id) && !explained.has(importer)) violations.push({
+					kind: "browser-field",
+					importer
+				});
+			}
+			if (violations.length === 0) return;
+			const graph = {
+				importers: (id) => {
+					const info = this.getModuleInfo(id);
+					return {
+						static: info?.importers ?? [],
+						dynamic: info?.dynamicImporters ?? []
+					};
+				},
+				isEntry: (id) => this.getModuleInfo(id)?.isEntry === true
+			};
+			this.error(nodeInBrowserMessage(environment.name, violations, (id) => importChain(graph, id), environment.config.root));
+		}
+	};
+}
+/** The dev dependency optimizer's half: a pre-bundled package that reaches a Node built-in fails too. */
+function optimizedDepsGuard(environment, root) {
+	return {
+		name: "markless:browser-node-guard-deps",
+		buildEnd(error) {
+			if (error) return;
+			const violations = [];
+			for (const id of this.getModuleIds()) {
+				const specifier = id.startsWith(OPTIMIZER_BROWSER_EXTERNAL) ? id.slice(17) : void 0;
+				if (specifier === void 0 && id !== VITE_BROWSER_EXTERNAL) continue;
+				for (const importer of this.getModuleInfo(id)?.importers ?? []) violations.push(specifier === void 0 ? {
+					kind: "browser-field",
+					importer
+				} : {
+					kind: "builtin",
+					importer,
+					specifier
+				});
+			}
+			if (violations.length === 0) return;
+			const graph = {
+				importers: (id) => {
+					const info = this.getModuleInfo(id);
+					return {
+						static: info?.importers ?? [],
+						dynamic: info?.dynamicImporters ?? []
+					};
+				},
+				isEntry: (id) => this.getModuleInfo(id)?.isEntry === true
+			};
+			this.error(nodeInBrowserMessage(environment, violations, (id) => importChain(graph, id), root()));
+		}
+	};
+}
+//#endregion
+//#region src/constant-slices.ts
+const SLICE_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}constant-slice:`;
+const SLICED_MODULE = /^\0virtual:markless:(?:symbol|symbol-bundle|render-data|render-data-served):|[?&]markless-render-data(?:[&#]|$)/;
+const AUTHORED_IMPORT = /\bimport\s*\{[^}]*\}\s*from\s*["'](?!@markless\/|virtual:)/;
+const PLAIN_SCRIPT_FILE = /\.[cm]?[jt]sx?$/;
+const MUTATING_METHODS = /* @__PURE__ */ new Set([
+	"push",
+	"pop",
+	"shift",
+	"unshift",
+	"splice",
+	"sort",
+	"reverse",
+	"fill",
+	"copyWithin",
+	"set",
+	"add",
+	"delete",
+	"clear"
+]);
+const evaluated = /* @__PURE__ */ new Map();
+function moduleConstants(file) {
+	const source = readFileSync(file, "utf8");
+	const cached = evaluated.get(file);
+	if (cached?.source === source) return cached.constants;
+	const constants = evaluateModuleConstants({
+		filename: file,
+		source
+	});
+	evaluated.set(file, {
+		source,
+		constants
+	});
+	return constants;
+}
+function constantSliceId(file, exportName, path) {
+	return `${SLICE_PREFIX}${encodeURIComponent(file)}:${encodeURIComponent(exportName)}:${encodeURIComponent(JSON.stringify(path))}`;
+}
+function sliceAt(value, path) {
+	let current = value;
+	for (const segment of path) current = current[segment];
+	return current;
+}
+function plainJson(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value) && !Object.is(value, -0);
+	if (Array.isArray(value)) return value.every(plainJson);
+	if (typeof value === "object") return Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every(plainJson);
+	return false;
+}
+function children(node) {
+	const out = [];
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "start" || key === "end" || key === "type") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (item && typeof item === "object" && "type" in item) out.push(item);
+		} else if (value && typeof value === "object" && "type" in value) out.push(value);
+	}
+	return out;
+}
+function declaredNames(node, into) {
+	if (!node) return;
+	if (node.type === "Identifier") into.add(node.name);
+	else if (node.type === "ObjectPattern") for (const property of node.properties) declaredNames(property.type === "RestElement" ? property.argument : property.value, into);
+	else if (node.type === "ArrayPattern") for (const element of node.elements ?? []) declaredNames(element, into);
+	else if (node.type === "AssignmentPattern") declaredNames(node.left, into);
+	else if (node.type === "RestElement") declaredNames(node.argument, into);
+}
+/** Every use of `local` as the root of a member chain, with the chain cut where the value stops having that own property. */
+function references(program, local, value) {
+	const found = [];
+	const shadowed = /* @__PURE__ */ new Set();
+	let bare = false;
+	const visit = (node, parents) => {
+		if (node.type === "VariableDeclarator") declaredNames(node.id, shadowed);
+		if (/Function/.test(node.type)) {
+			for (const param of node.params ?? []) declaredNames(param, shadowed);
+			if (node.id) declaredNames(node.id, shadowed);
+		}
+		if (node.type === "CatchClause") declaredNames(node.param, shadowed);
+		if (node.type === "Identifier" && node.name === local) {
+			const parent = parents.at(-1);
+			if (!(parent?.type === "MemberExpression" && parent.property === node && !parent.computed || parent?.type === "Property" && parent.key === node && !parent.computed && !parent.shorthand || parent?.type === "ImportSpecifier")) {
+				const chain = [node];
+				const path = [];
+				let current = value;
+				for (let depth = parents.length - 1; depth >= 0; depth--) {
+					const member = parents[depth];
+					if (member.type !== "MemberExpression" || member.object !== chain.at(-1)) break;
+					const property = member.property;
+					const key = member.computed ? property.type === "Literal" && (typeof property.value === "string" || typeof property.value === "number") ? property.value : void 0 : property.name;
+					if (key === void 0 || !current || typeof current !== "object" || !Object.hasOwn(current, key)) break;
+					current = current[key];
+					path.push(key);
+					chain.push(member);
+				}
+				if (path.length === 0) bare = true;
+				const top = chain.at(-1);
+				const above = parents[parents.length - chain.length];
+				const mutates = above?.type === "AssignmentExpression" && above.left === top || above?.type === "UpdateExpression" || above?.type === "UnaryExpression" && above.operator === "delete" || above?.type === "MemberExpression" && above.object === top && !above.computed && MUTATING_METHODS.has(above.property.name);
+				found.push({
+					chain,
+					path,
+					mutates
+				});
+			}
+		}
+		for (const child of children(node)) visit(child, [...parents, node]);
+	};
+	visit(program, []);
+	if (bare || shadowed.has(local) || found.some((reference) => reference.mutates)) return null;
+	return found;
+}
+function slicingPays(value, roots, droppedPathBytes, maxModuleBytes) {
+	const sliced = roots.reduce((sum, path) => sum + JSON.stringify(sliceAt(value, path)).length + PACK_COST_MODEL.packedModuleWrapperBytes, 0);
+	const whole = JSON.stringify(value).length * 1.015 + PACK_COST_MODEL.packedModuleWrapperBytes;
+	return sliced - droppedPathBytes < whole || whole > maxModuleBytes;
+}
+/** The module with each imported constant it reads only in slices narrowed to those slices, or null when nothing narrows. */
+async function narrowConstantImports(code, resolve, maxModuleBytes = Infinity) {
+	if (!AUTHORED_IMPORT.test(code)) return null;
+	let program;
+	try {
+		program = parseJavaScriptModule(code);
+	} catch {
+		return null;
+	}
+	const edits = [];
+	const sliceImports = [];
+	const files = [];
+	const sliceLocals = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		if (statement.type !== "ImportDeclaration" || statement.importKind === "type") continue;
+		const specifier = statement.source.value;
+		if (specifier.startsWith("@markless/") || specifier.startsWith("virtual:")) continue;
+		const named = statement.specifiers.filter((entry) => entry.type === "ImportSpecifier");
+		if (named.length === 0) continue;
+		const file = await resolve(specifier);
+		if (!file || !PLAIN_SCRIPT_FILE.test(file)) continue;
+		const constants = moduleConstants(file);
+		const kept = [];
+		for (const entry of statement.specifiers) {
+			const imported = entry.type === "ImportSpecifier" ? entry.imported : void 0;
+			const exportName = imported ? imported.name ?? imported.value : void 0;
+			const local = entry.local.name;
+			const value = exportName !== void 0 ? constants[exportName] : void 0;
+			const uses = exportName !== void 0 && Object.hasOwn(constants, exportName) && value && typeof value === "object" ? references(program, local, value) : null;
+			const paths = uses ? [...new Map(uses.map((use) => [JSON.stringify(use.path), use.path])).values()].sort((left, right) => left.length - right.length) : [];
+			const roots = paths.filter((path, index) => !paths.slice(0, index).some((shorter) => shorter.every((segment, at) => path[at] === segment)));
+			if (!uses || roots.some((path) => !plainJson(sliceAt(value, path))) || !slicingPays(value, roots, uses.reduce((sum, use) => {
+				const root = roots.find((path) => path.every((segment, at) => use.path[at] === segment));
+				return sum + use.chain[root.length].end - use.chain[0].start - local.length;
+			}, 0), maxModuleBytes)) {
+				kept.push(entry);
+				continue;
+			}
+			for (const use of uses) {
+				const root = roots.find((path) => path.every((segment, at) => use.path[at] === segment));
+				const id = constantSliceId(file, exportName, root);
+				let name = sliceLocals.get(id);
+				if (!name) {
+					name = `marklessConstantSlice${sliceLocals.size}`;
+					sliceLocals.set(id, name);
+					sliceImports.push(`import ${name} from ${JSON.stringify(id)};`);
+				}
+				const node = use.chain[root.length];
+				edits.push({
+					start: use.chain[0].start,
+					end: node.end,
+					text: name
+				});
+			}
+			if (!files.includes(file)) files.push(file);
+		}
+		if (kept.length === named.length && kept.length === statement.specifiers.length) continue;
+		const remaining = kept.map((entry) => code.slice(entry.start, entry.end));
+		edits.push({
+			start: statement.start,
+			end: statement.end,
+			text: remaining.length ? `import ${kept.some((entry) => entry.type === "ImportSpecifier") ? `{ ${remaining.join(", ")} }` : remaining.join(", ")} from ${JSON.stringify(specifier)};` : ""
+		});
+	}
+	if (sliceImports.length === 0) return null;
+	let out = code;
+	for (const edit of edits.sort((left, right) => right.start - left.start)) out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+	return {
+		code: `${sliceImports.join("\n")}\n${out}`,
+		files
+	};
+}
+function constantSlicesPlugin() {
+	return {
+		name: "markless:constant-slices",
+		enforce: "post",
+		applyToEnvironment(environment) {
+			return environment.config.consumer === "client";
+		},
+		buildEnd() {
+			if (this.environment?.mode !== "dev") evaluated.clear();
+		},
+		resolveId: {
+			filter: { id: /^virtual:markless:constant-slice:/ },
+			handler(source) {
+				return `\0${source}`;
+			}
+		},
+		load: {
+			filter: { id: /^\0virtual:markless:constant-slice:/ },
+			handler(id) {
+				const [file, exportName, path] = id.slice(1 + SLICE_PREFIX.length).split(":").map(decodeURIComponent);
+				this.addWatchFile(file);
+				const at = JSON.parse(path);
+				const value = sliceAt(moduleConstants(file)[exportName], at);
+				const json = JSON.stringify(value);
+				const limitKb = this.environment?.config.build.chunkSizeWarningLimit;
+				if (limitKb === void 0 || json.length <= limitKb * 1e3 || !value || typeof value !== "object") return `export default ${json};`;
+				const keys = Array.isArray(value) ? value.map((_, index) => index) : Object.keys(value);
+				const parts = keys.map((key, index) => `import marklessSlicePart${index} from ${JSON.stringify(constantSliceId(file, exportName, [...at, key]))};`);
+				const body = Array.isArray(value) ? `[${keys.map((_, index) => `marklessSlicePart${index}`).join(",")}]` : `{${keys.map((key, index) => `${JSON.stringify(key)}:marklessSlicePart${index}`).join(",")}}`;
+				return `${parts.join("\n")}\nexport default ${body};`;
+			}
+		},
+		transform: {
+			filter: { id: SLICED_MODULE },
+			async handler(code, id) {
+				const limitKb = this.environment?.config.build.chunkSizeWarningLimit;
+				const narrowed = await narrowConstantImports(code, async (specifier) => {
+					const resolved = await this.resolve(specifier, id, { skipSelf: true });
+					return resolved && !resolved.external ? resolved.id.split("?")[0] : null;
+				}, limitKb === void 0 ? Infinity : limitKb * 1e3);
+				if (!narrowed) return null;
+				for (const file of narrowed.files) this.addWatchFile(file);
+				return {
+					code: narrowed.code,
+					map: null
+				};
+			}
+		}
+	};
+}
+//#endregion
 //#region src/vite/index.ts
 const MARKLESS_SKIP_DUPLICATE_BUILDS = Symbol("markless-skip-duplicate-builds");
 const TSRX_INPUT_FILE = /\.tsrx(?:[?#].*)?$/;
@@ -2190,6 +2912,7 @@ function markless(options = {}) {
 	rolldownOptions.productionPrerenderWakeModuleUrls = /* @__PURE__ */ new Map();
 	let prerenderEntry = null;
 	let resolvedRoot = "";
+	let chunkSizeWarningBytes;
 	let clientOutDir = "dist";
 	rolldownOptions.bundleGraphAdders = bundleGraphAdders;
 	const hmrOptions = {
@@ -2202,6 +2925,20 @@ function markless(options = {}) {
 		pageForUrl: void 0
 	};
 	let devPrerender;
+	let compileCache;
+	let compileWorkers;
+	const flushCompileCache = async () => {
+		const workers = compileWorkers;
+		compileWorkers = void 0;
+		useCompileRunner(void 0);
+		await workers?.close();
+		const cache = compileCache;
+		if (!cache) return;
+		compileCache = void 0;
+		usePersistentCompileStore(void 0);
+		usePersistentStrippedCode(void 0);
+		await cache.flush();
+	};
 	const devTags = createDevTags();
 	rolldownOptions.devInjections = devTags.tags;
 	const basePlugin = createMarklessRolldownPlugin({
@@ -2209,6 +2946,9 @@ function markless(options = {}) {
 		options: rolldownOptions,
 		prerenderRecordsBySource
 	});
+	const packingPlugins = nativePackingEnabled(options) ? nativePackingPlugins(() => resolvedRoot, () => basePlugin.api.runtimeDemandMaps(), () => basePlugin.api.runtimeDemandSources(), () => basePlugin.api.directCsrOnly(), () => chunkSizeWarningBytes) : void 0;
+	const packOwnership = packingPlugins?.[0]?.api;
+	if (packOwnership) basePlugin.api.declarePackOwnership(packOwnership);
 	const hmr = createViteHmr(hmrOptions);
 	const marklessPlugin = {
 		...basePlugin,
@@ -2247,7 +2987,11 @@ function markless(options = {}) {
 			};
 			configDefaults(config, options, rolldownOptions);
 			if (devEnabled) {
-				includeOptimizedDeps(config, [RESUME_ENTRY_SPECIFIER, STORAGE_FREE_RESUME_ENTRY_SPECIFIER]);
+				includeOptimizedDeps(config, [
+					RESUME_ENTRY_SPECIFIER,
+					STORAGE_FREE_RESUME_ENTRY_SPECIFIER,
+					...runtimeFunctionSpecifiers()
+				]);
 				excludeSourceShippedDeps(config);
 			}
 			if (prerender || stagePrerenderWake) {
@@ -2258,6 +3002,8 @@ function markless(options = {}) {
 		configResolved(resolvedConfig) {
 			if (options.experimentalNativePacking !== void 0) resolvedConfig.logger.warn(DEPRECATED_NATIVE_PACKING_WARNING);
 			resolvedRoot = resolvedConfig.root;
+			const warningKb = (resolvedConfig.environments?.client ?? resolvedConfig).build?.chunkSizeWarningLimit;
+			chunkSizeWarningBytes = warningKb === void 0 ? void 0 : warningKb * 1e3;
 			clientOutDir = resolvedConfig.build?.outDir ?? "dist";
 			const serve = resolvedConfig.command === "serve";
 			hmrOptions.base = resolvedConfig.base;
@@ -2265,6 +3011,25 @@ function markless(options = {}) {
 			rolldownOptions.dev = serve;
 			rolldownOptions.rootDir = resolvedConfig.root;
 			rolldownOptions.publicPath = (fileName) => joinURL(resolvedConfig.base, fileName);
+			if (!serve && resolvedConfig.cacheDir && options.compileCache !== false && persistentCompileCacheAvailable()) {
+				const directory = resolve(resolvedConfig.cacheDir, "markless-compile");
+				const fingerprint = compilerFingerprint();
+				compileCache = createPersistentCompileCache({
+					directory,
+					fingerprint
+				});
+				usePersistentCompileStore(compileCache);
+				usePersistentStrippedCode(compileCache.strippedCode);
+				compileWorkers = createCompileWorkerPool({
+					size: buildWorkerCount(),
+					store: {
+						cache: compileCache,
+						directory,
+						fingerprint
+					}
+				});
+			} else if (!serve) compileWorkers = createCompileWorkerPool({ size: buildWorkerCount() });
+			if (compileWorkers) useCompileRunner(compileWorkers.run);
 			if (serve) {
 				devTags.registerViteTags(resolvedConfig.base);
 				if (prerender && prerenderEntry) {
@@ -2314,6 +3079,7 @@ function markless(options = {}) {
 					}));
 				}
 				await buildMarklessEnvironments(builder, options);
+				await flushCompileCache();
 				if (prerender && prerenderEntry) {
 					const source = resolve(resolvedRoot, prerenderEntry);
 					const clientEnvironment = builder.environments[viteEnvironmentName("client", options)];
@@ -2335,6 +3101,9 @@ function markless(options = {}) {
 				}
 			}
 		},
+		configureVitest({ defineCacheKeyGenerator }) {
+			defineCacheKeyGenerator(({ id }) => isCompilerStatefulModuleId(id) ? false : void 0);
+		},
 		configureServer(server) {
 			server.config.logger?.info(`markless diagnostics available - window.__MARKLESS_DEBUG__ records containers, lifecycles, and event routing; ${DEBUGGING_PLAYBOOK_HINT}.`);
 			rolldownOptions.devServer = {
@@ -2379,7 +3148,7 @@ function markless(options = {}) {
 			return hmr.load(id) ?? runHook(basePlugin.load, this, id, loadOptions);
 		},
 		transform: { async handler(code, id, transformOptions) {
-			if (rolldownOptions.dev === true && TSRX_INPUT_FILE.test(id)) transformedTsrxSources.set(parsePath(id).pathname, code);
+			if (rolldownOptions.dev === true && TSRX_INPUT_FILE.test(id) && !STRING_EXPORT_QUERY.test(id)) transformedTsrxSources.set(parsePath(id).pathname, code);
 			try {
 				const context = rolldownOptions.dev === true ? withDevServerExternals(this) : this;
 				return await runHook(basePlugin.transform, context, code, id, transformOptions);
@@ -2398,6 +3167,8 @@ function markless(options = {}) {
 	};
 	return [
 		marklessPlugin,
+		browserNodeGuard(),
+		constantSlicesPlugin(),
 		{
 			name: "markless:shared-render-data-reach",
 			enforce: "pre",
@@ -2419,13 +3190,14 @@ function markless(options = {}) {
 			generateBundle: {
 				order: "post",
 				async handler(_options, bundle) {
-					await prefetchChunkParses(Object.values(bundle).filter((output) => output.type === "chunk" && output.code.includes("import(")));
+					await prefetchChunkDynamicImports(Object.values(bundle).filter((output) => output.type === "chunk" && output.code.includes("import(")));
 					collapseInitFacadeImports(bundle);
-					unwrapAsyncImportWrappers(bundle);
+					await unwrapAsyncImportWrappers(bundle);
+					clearChunkFactCaches();
 				}
 			}
 		},
-		...nativePackingEnabled(options) ? nativePackingPlugins(() => resolvedRoot, () => basePlugin.api.runtimeDemandMaps(), () => basePlugin.api.runtimeDemandSources()).map((plugin) => ({
+		...packingPlugins ? packingPlugins.map((plugin) => ({
 			...plugin,
 			apply: "build",
 			enforce: "post",