@markless/bundler 0.4.0 → 0.6.0

package/dist/rolldown-CB2Xpf-E.js

@@ -1,4828 +0,0 @@
-import { MarklessCompileError, createCompileErrorPayload } from "./dev-error.js";
-import { S as requalifyExecutionLogModuleHook, _ as executionLogActivationInjection, a as encodedSymbolSource, b as injectExecutionLogModuleHook, d as scopedSymbolExportName, f as settleVirtualModuleId, g as MARKLESS_EXECUTION_LOG_MODULE_ID, h as EXECUTION_LOG_DISPATCH_MODULE_IDS, i as emitSourceModule, l as resumeVirtualModuleId, m as symbolVirtualModuleSourceFile, n as emitResumeModule, o as payloadModule, p as symbolVirtualModuleId, r as emitSettleModule, s as prerenderWakeVirtualModuleId, t as MARKLESS_VIRTUAL_PREFIX, u as rewriteSymbolModuleExport, v as executionLogVirtualModuleSource, w as planModulePreloads, x as normalizeExecutionLogMode, y as hasExecutionLogModuleHook } from "./source-module-DI20i0ZG.js";
-import { joinURL, parsePath, withLeadingSlash, withQuery, withoutLeadingSlash } from "ufo";
-import { PROTOCOL_EVENT_ACTION_KIND, createStorageSeedMetadataFromGraphNodeId, protocolEventActionKind } from "@markless/serializer";
-import { artifactChildCandidates, collectTsrxModuleDiagnostics, compileTsrxModule, compileTsrxModuleLinkArtifact, componentEdgeSymbolRoutes, computeExecutionAttribution, computeLinkedInterfaces, delegateChildRenderPlan, delegateChildRendering, delegateChildResolutionRequests, delegateMaterializationScope, emitSymbolResolverModule, importedSymbolRoutes, linkBarrelComponents, linkClaimManifests, linkDelegateChildren, linkImportedModules, linkedChildrenHaveBrowserTriggers, linkedImportedClaimsMissing, linkedImportedSymbolInputs, linkedManifestHasBrowserTriggers, linkedModuleChildDiagnostics, linkedModuleChildKey, linkedModuleClaimPlan, linkedModuleImportRequests, linkedModuleLoadSource, linkedRenderDataBoundarySymbols, linkedRenderDataOnlyChange, linkedRenderDataReachRoot, linkedResolverClaimVerdict, linkedRouteArtifactRegistration, linkedSymbolRouteRequests, moduleInterfaceHash, moduleLinkResolutionKey, parseJavaScriptModule, planDelegateChildren, planEmittedClaimOwnership, planLinkedModuleChildren, planRenderDataModule, planTransformRequest, prerenderInterfacesComplete, renderDataClaimManifest, renderDataReachImportSources, uniqueLinkedModuleChildren } from "@markless/compiler";
-import { dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
-import { PRERENDER_INLINE_EVENT_NAMES_TOKEN, createInlineResumerDebugRegistrationSource, createInlineResumerSelfWakeSource, createInlineResumerSource, createPrerenderInlineResumerSource, createPrerenderSettleInlineResumerSource } from "@markless/web/inline/resumer";
-import { defDGraph } from "@thi.ng/dgraph";
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { isAbsolute as isAbsolute$1 } from "node:path";
-import { pathToFileURL } from "node:url";
-const MARKLESS_BUILD_PREFIX = `build/`;
-const MARKLESS_BUNDLE_GRAPH = `${MARKLESS_BUILD_PREFIX}bundle-graph.json`;
-const WEB_RUNTIME_CAPABILITY_GROUPS = [
-	{
-		name: "markless-direct-renderer",
-		test: fileBasenamePattern("direct")
-	},
-	{
-		name: "markless-resume-branches",
-		test: fileBasenamePattern("resume-branches")
-	},
-	{
-		name: "markless-resume-behaviors",
-		test: fileBasenamePattern("resume-behaviors")
-	},
-	{
-		name: "markless-resume-repeats",
-		test: fileBasenamePattern("resume-keyed-repeats", "repeat-runtime")
-	},
-	{
-		name: "markless-resume-async",
-		test: fileBasenamePattern("resume-async-boundaries", "resume-async-wiring")
-	},
-	{
-		name: "markless-resume-shared-patch",
-		test: fileBasenamePattern("resume-shared-patch")
-	},
-	{
-		name: "markless-resume-runtime",
-		test: fileBasenamePattern("resume-runtime")
-	},
-	{
-		name: "markless-resume-runtime-start",
-		test: fileBasenamePattern("resume-runtime-start")
-	},
-	{
-		name: "markless-resume-runtime-shared",
-		test: fileBasenamePattern("resume-runtime-shared")
-	},
-	{
-		name: "markless-resume-events",
-		test: fileBasenamePattern("resume-events")
-	},
-	{
-		name: "markless-resume-handoff",
-		test: fileBasenamePattern("resume-handoff")
-	},
-	{
-		name: "markless-resume-locators",
-		test: fileBasenamePattern("resume-locators")
-	},
-	{
-		name: "markless-resume-errors",
-		test: fileBasenamePattern("resume-errors")
-	},
-	{
-		name: "markless-resume-sync-computed",
-		test: fileBasenamePattern("resume-sync-computed")
-	},
-	{
-		name: "markless-resume-sync-demand",
-		test: fileBasenamePattern("resume-sync-demand")
-	},
-	{
-		name: "markless-payload-full",
-		test: fileBasenamePattern("payload-full", "payload-full-storage-free")
-	},
-	{
-		name: "markless-payload-resume",
-		test: fileBasenamePattern("payload-resume")
-	},
-	{
-		name: "markless-inline-payload-document",
-		test: /[/\\]web[/\\]src[/\\]inline[/\\]payload-document\.ts(?:[?#].*)?$/
-	},
-	{
-		name: "markless-payload-document",
-		test: fileBasenamePattern("payload-document", "payload-document-common", "payload-resume-registry")
-	},
-	{
-		name: "markless-payload-graph-construct",
-		test: fileBasenamePattern("payload-graph-construct")
-	},
-	{
-		name: "markless-dom-journal",
-		test: fileBasenamePattern("dom-journal")
-	},
-	{
-		name: "markless-protocol-decode",
-		test: fileBasenamePattern("protocol-client", "protocol-client-storage", "protocol-state", "storage-record-client")
-	},
-	{
-		name: "markless-value-decode",
-		test: fileBasenamePattern("value-decode-client", "value-decode-extensions")
-	},
-	{
-		name: "markless-payload-leaves",
-		test: fileBasenamePattern("payload", "payload-document")
-	},
-	{
-		name: "markless-dev-log",
-		test: /virtual:markless:dev-log|[/\\]web[/\\]src[/\\]dev-log\.ts(?:[?#].*)?$/
-	},
-	{
-		name: "markless-resume-core",
-		test: fileBasenamePattern("resume")
-	},
-	{
-		name: "markless-runtime-graph-core",
-		test: fileBasenamePattern("graph-core")
-	},
-	{
-		name: "markless-runtime-graph-collections",
-		test: fileBasenamePattern("graph-collections")
-	},
-	{
-		name: "markless-runtime-graph-computed",
-		test: fileBasenamePattern("graph-computed")
-	},
-	{
-		name: "markless-runtime-graph-async",
-		test: fileBasenamePattern("graph-async")
-	},
-	{
-		name: "markless-runtime-graph-scheduler",
-		test: fileBasenamePattern("graph-scheduler")
-	},
-	{
-		name: "markless-runtime-graph-shared",
-		test: fileBasenamePattern("graph-shared")
-	},
-	{
-		name: "markless-graph",
-		test: /[/\\](?:runtime[/\\]src[/\\](?!graph-(?:core|collections|computed|async|scheduler|shared)\.ts)|core[/\\]src[/\\]runtime)[/\\]?/
-	},
-	{
-		name: "markless-serializer",
-		test: /[/\\]serializer[/\\]src[/\\](?!protocol-validation)/
-	}
-];
-function fileBasenamePattern(...names) {
-	return new RegExp(`[/\\\\](?:${names.join("|")})\\.ts(?:[?#].*)?$`);
-}
-const MARKLESS_RUNTIME_GROUPS = [...WEB_RUNTIME_CAPABILITY_GROUPS, {
-	name: "markless-runtime",
-	test: /[/\\]@markless[/\\]runtime[/\\]/
-}];
-function outputDefaults(output, environment) {
-	if (environment === "lib") return output;
-	const next = {
-		...output,
-		hoistTransitiveImports: false
-	};
-	if (environment === "server") {
-		next.entryFileNames ??= "[name].js";
-		next.chunkFileNames ??= "chunk-[hash].js";
-		next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
-		return next;
-	}
-	next.entryFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
-	next.chunkFileNames ??= `${MARKLESS_BUILD_PREFIX}chunk-[hash].js`;
-	next.minifyInternalExports = true;
-	next.strictExecutionOrder = true;
-	next.codeSplitting = marklessCodeSplitting(next.codeSplitting);
-	return next;
-}
-function marklessCodeSplitting(codeSplitting) {
-	if (typeof codeSplitting === "boolean") throw new Error("@markless/bundler requires output.codeSplitting to be an object so runtime chunks can be grouped.");
-	return {
-		...codeSplitting,
-		groups: [...MARKLESS_RUNTIME_GROUPS, ...codeSplitting?.groups ?? []]
-	};
-}
-//#endregion
-//#region src/dev.ts
-function createMarklessDevGraph() {
-	const parentModules = /* @__PURE__ */ new Map();
-	return {
-		record(parent, ids, environment) {
-			const entries = [...ids];
-			for (const path of parentKeys(parent)) {
-				const key = parentKey(environment, path);
-				const existing = parentModules.get(key) ?? /* @__PURE__ */ new Set();
-				for (const id of entries) existing.add(id);
-				parentModules.set(key, existing);
-			}
-		},
-		clear(parent, environment) {
-			const deleted = [];
-			for (const currentEnvironment of targetEnvironments(environment)) for (const path of parentKeys(parent)) {
-				const key = parentKey(currentEnvironment, path);
-				const ids = parentModules.get(key);
-				if (!ids) continue;
-				deleted.push(...ids);
-				parentModules.delete(key);
-			}
-			return [...new Set(deleted)];
-		},
-		reset() {
-			parentModules.clear();
-		}
-	};
-}
-function targetEnvironments(environment) {
-	if (environment) return [environment];
-	return allEnvironments;
-}
-const allEnvironments = [
-	"client",
-	"server",
-	"lib"
-];
-function parentKeys(parent) {
-	const path = pathname$1(parent);
-	const normalized = normalize(path);
-	const leadingPath = withLeadingSlash(normalized);
-	const barePath = leadingPath.slice(1);
-	return new Set([
-		path,
-		normalized,
-		leadingPath,
-		barePath
-	]);
-}
-function parentKey(environment, parent) {
-	return `${environment}:${parent}`;
-}
-function pathname$1(id) {
-	return parsePath(id).pathname;
-}
-//#endregion
-//#region src/module-metadata-registry.ts
-/**
-* Capture data follows authored source identity. Symbol claims follow the exact
-* emitted module identity that owns the corresponding loadSymbol route.
-*/
-var ModuleMetadataRegistry = class ModuleMetadataRegistry {
-	#captureManifestsBySource = /* @__PURE__ */ new Map();
-	#symbolClaimsByEmittedModule = /* @__PURE__ */ new Map();
-	#sourceClaimPublications = /* @__PURE__ */ new Map();
-	#publication(source) {
-		const existing = this.#sourceClaimPublications.get(source);
-		if (existing) return existing;
-		const created = {
-			active: 0,
-			activeModules: /* @__PURE__ */ new Set(),
-			begun: /* @__PURE__ */ new Set(),
-			expected: /* @__PURE__ */ new Set(),
-			finalized: /* @__PURE__ */ new Set(),
-			pending: /* @__PURE__ */ new Set(),
-			published: /* @__PURE__ */ new Set(),
-			revision: 0,
-			sealed: false,
-			waiters: []
-		};
-		this.#sourceClaimPublications.set(source, created);
-		return created;
-	}
-	static #changed(publication) {
-		publication.revision += 1;
-		for (const resolve of publication.waiters.splice(0)) resolve();
-	}
-	static #complete(publication) {
-		for (const emittedModule of publication.begun) if (!publication.published.has(emittedModule)) return false;
-		return true;
-	}
-	static #awaited(publication) {
-		for (const emittedModule of publication.activeModules) if (!publication.published.has(emittedModule)) return true;
-		return false;
-	}
-	clear() {
-		this.#captureManifestsBySource.clear();
-		this.#symbolClaimsByEmittedModule.clear();
-		this.#sourceClaimPublications.clear();
-	}
-	recordCaptureMetadata(source, manifest) {
-		if (manifest.captureMetadata) this.#captureManifestsBySource.set(source, manifest);
-		else this.#captureManifestsBySource.delete(source);
-	}
-	captureMetadataForSource(source) {
-		return this.#captureManifestsBySource.get(source)?.captureMetadata;
-	}
-	deleteCaptureMetadata(source) {
-		this.#captureManifestsBySource.delete(source);
-	}
-	recordSymbolClaims(emittedModule, manifest) {
-		this.#symbolClaimsByEmittedModule.set(emittedModule, manifest);
-	}
-	deleteSymbolClaims(emittedModule) {
-		this.#symbolClaimsByEmittedModule.delete(emittedModule);
-	}
-	hasSymbolClaims(emittedModule) {
-		return this.#symbolClaimsByEmittedModule.has(emittedModule);
-	}
-	beginSourceSymbolClaims(source, emittedModule) {
-		const publication = this.#publication(source);
-		publication.sealed = false;
-		publication.finalized.delete(emittedModule);
-		if (publication.expected.has(emittedModule)) publication.pending.add(emittedModule);
-		publication.begun.add(emittedModule);
-		publication.activeModules.add(emittedModule);
-		publication.active += 1;
-		ModuleMetadataRegistry.#changed(publication);
-	}
-	expectSourceSymbolClaims(source, emittedModules) {
-		const publication = this.#publication(source);
-		for (const emittedModule of emittedModules) {
-			publication.expected.add(emittedModule);
-			if (!publication.finalized.has(emittedModule)) publication.pending.add(emittedModule);
-		}
-		publication.sealed = false;
-		ModuleMetadataRegistry.#changed(publication);
-	}
-	finishSourceSymbolClaims(source, emittedModule) {
-		const publication = this.#sourceClaimPublications.get(source);
-		if (!publication || publication.active === 0) throw new Error(`MARKLESS_SOURCE_SYMBOL_CLAIMS_FINAL_WITHOUT_START: Source ${JSON.stringify(source)} published final claims without an active emitted variant.`);
-		publication.active -= 1;
-		publication.activeModules.delete(emittedModule);
-		publication.finalized.add(emittedModule);
-		publication.published.add(emittedModule);
-		publication.pending.delete(emittedModule);
-		ModuleMetadataRegistry.#changed(publication);
-	}
-	/**
-	* Drops an edited module's claims and the ledger entry that remembers it ever
-	* published them, so the transform that recompiles it counts as a first
-	* publication the barrier waits on rather than a republication it waves past.
-	* Displacement between emitted siblings is not this: those owners ceded their
-	* routes on purpose and stay published.
-	*/
-	invalidateSourceSymbolClaims(source, emittedModule) {
-		this.deleteSymbolClaims(emittedModule);
-		const publication = this.#sourceClaimPublications.get(source);
-		if (!publication) return;
-		publication.begun.delete(emittedModule);
-		publication.published.delete(emittedModule);
-		publication.finalized.delete(emittedModule);
-		ModuleMetadataRegistry.#changed(publication);
-	}
-	releaseSourceSymbolClaims(source, emittedModule) {
-		const publication = this.#sourceClaimPublications.get(source);
-		if (!publication || !publication.activeModules.has(emittedModule)) return;
-		publication.active -= 1;
-		publication.activeModules.delete(emittedModule);
-		ModuleMetadataRegistry.#changed(publication);
-	}
-	async sealSourceSymbolClaims(source) {
-		const publication = this.#sourceClaimPublications.get(source);
-		if (!publication || publication.sealed) return;
-		for (;;) {
-			while (publication.active > 0 || publication.pending.size > 0) await new Promise((resolve) => publication.waiters.push(resolve));
-			const revision = publication.revision;
-			await new Promise((resolve) => setTimeout(resolve, 0));
-			if (publication.revision === revision && publication.active === 0 && publication.pending.size === 0) break;
-		}
-		publication.sealed = true;
-	}
-	/**
-	* The barrier, waited on instead of asserted. A reader in an environment that
-	* does not drive this source's publication - an SSR transform reading a child's
-	* client claims - has no seal of its own, so it blocks here until every emitted
-	* variant in flight has published. Returns as soon as nothing is left to wait
-	* for, whether or not the result satisfies the barrier: deciding that is
-	* `assertSourceClaimsSealed`'s, and it stays fail-closed.
-	*/
-	async awaitSourceClaimsPublished(source) {
-		const publication = this.#sourceClaimPublications.get(source);
-		if (!publication) return;
-		while (ModuleMetadataRegistry.#awaited(publication)) await new Promise((resolve) => publication.waiters.push(resolve));
-	}
-	symbolClaimManifests() {
-		return this.#symbolClaimsByEmittedModule.values();
-	}
-	symbolClaimMap() {
-		return this.#symbolClaimsByEmittedModule;
-	}
-	/**
-	* The publication barrier every reader shares: an emitted sibling that has
-	* begun publishing must have finished a publication before its source's claims
-	* may be read, so the merged manifest is a complete set rather than half of
-	* one. A sibling compiling again has already published once, so a second
-	* importer forcing it - ordinary in a dev server serving several importers at
-	* once - is not a barrier failure. One importer's expectation list is not part
-	* of this: that is its own `sealSourceSymbolClaims` wait, not a fact about the
-	* source, and enforcing it here made the read order-dependent. Merging the
-	* claims is the `claim-manifest` compiler pass, not this registry.
-	*/
-	assertSourceClaimsSealed(source) {
-		const publication = this.#sourceClaimPublications.get(source);
-		if (!publication || ModuleMetadataRegistry.#complete(publication)) return;
-		const unpublished = [...publication.begun].filter((emittedModule) => !publication.published.has(emittedModule));
-		throw new Error(`MARKLESS_SOURCE_SYMBOL_CLAIMS_UNSEALED: Source ${JSON.stringify(source)} claims were consumed before final publication completed. Emitted variants that have not published: ${unpublished.map((emittedModule) => JSON.stringify(emittedModule)).join(", ")}.`);
-	}
-	emittedSymbolClaimMap(emittedModules) {
-		const emitted = new Set(emittedModules);
-		return new Map([...this.#symbolClaimsByEmittedModule].filter(([owner]) => emitted.has(owner)));
-	}
-};
-//#endregion
-//#region ../web/src/debug-channel.ts
-function installDebugChannelLayer(root, initialPhase, initiallyActive = true) {
-	const global = globalThis;
-	const previous = global.__MARKLESS_DEBUG__?.version === 1 ? global.__MARKLESS_DEBUG__ : void 0;
-	let priorRoot;
-	try {
-		priorRoot = previous?.explainInteraction(root, "__markless_debug_root__");
-	} catch {}
-	const priorContainer = priorRoot && "containerId" in priorRoot ? previous?.containers.find((entry) => entry.id === priorRoot.containerId) : void 0;
-	const seed = `${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
-	const id = priorContainer?.id ?? `container:${seed}`;
-	const rootKey = priorContainer?.root.key ?? `root:${seed}`;
-	const rootRef = new WeakRef(root);
-	const events = /* @__PURE__ */ new WeakMap();
-	const delegatedEvents = /* @__PURE__ */ new Set();
-	const keys = /* @__PURE__ */ new WeakMap();
-	const invalidated = /* @__PURE__ */ new WeakSet();
-	const routerSources = global[Symbol.for("markless.debug.channel.v1.router-sources")] ??= /* @__PURE__ */ new Set();
-	const ownViolations = [];
-	let phase = initialPhase;
-	let lifecycle = initiallyActive ? "active" : "registered";
-	let boundarySnapshots = Object.freeze([]);
-	let nextElement = 1;
-	let nextSequence = (previous?.violations.at(-1)?.sequence ?? 0) + 1;
-	let dropped = 0;
-	let pruned = false;
-	const freeze = (value) => Object.freeze(value);
-	const contains = (element) => {
-		const currentRoot = rootRef.deref();
-		return !!currentRoot && (currentRoot === element || currentRoot.contains?.(element) === true);
-	};
-	const keyFor = (element) => {
-		let key = keys.get(element);
-		if (!key) {
-			key = `${rootKey}:element:${nextElement++}`;
-			keys.set(element, key);
-		}
-		return key;
-	};
-	const eligibleAnchor = (element) => {
-		const anchor = element.closest?.("a[href]");
-		if (!anchor?.hasAttribute("data-markless-router-link") || anchor.hasAttribute("download")) return false;
-		const target = anchor.getAttribute("target");
-		if (target && target !== "_self" || anchor.relList?.contains("external")) return false;
-		try {
-			const base = global.location?.href ?? "http://localhost/";
-			return new URL(anchor.href ?? "", base).origin === new URL(base).origin;
-		} catch {
-			return false;
-		}
-	};
-	const none = (element, eventName, reason) => freeze({
-		kind: "none",
-		eventName,
-		reason,
-		containerId: id,
-		elementKey: keyFor(element)
-	});
-	const explain = (element, eventName) => {
-		if (lifecycle === "disposed" && (contains(element) || keys.has(element))) return none(element, eventName, "container-disposed");
-		if (!contains(element)) try {
-			return previous?.explainInteraction(element, eventName) ?? freeze({
-				kind: "none",
-				eventName,
-				reason: "outside-known-container"
-			});
-		} catch {
-			return freeze({
-				kind: "none",
-				eventName,
-				reason: "outside-known-container"
-			});
-		}
-		if (element.isConnected === false) return none(element, eventName, "element-disconnected");
-		if (eligibleAnchor(element)) {
-			const source = eventName === "navigate" && routerSources.has("navigation-event") ? "navigation-event" : eventName === "click" && routerSources.has("spa-click-listener") ? "spa-click-listener" : eventName === "click" && routerSources.has("ssr-link-bridge") ? "ssr-link-bridge" : void 0;
-			if (source) return freeze({
-				kind: "router-delegation",
-				source,
-				containerId: id,
-				elementKey: keyFor(element),
-				eventName
-			});
-		}
-		const interaction = events.get(element)?.get(eventName);
-		if (interaction) return freeze({ ...interaction });
-		if (delegatedEvents.has(eventName)) return freeze({
-			kind: "inline-resumer",
-			source: "ssr-inline",
-			containerId: id,
-			elementKey: keyFor(element),
-			eventName
-		});
-		if (invalidated.has(element)) return none(element, eventName, "not-registered");
-		try {
-			const prior = previous?.explainInteraction(element, eventName);
-			if (prior && prior.kind !== "none") return prior;
-		} catch {}
-		return none(element, eventName, "not-registered");
-	};
-	const cloneJson = (value, seen = /* @__PURE__ */ new Set()) => {
-		if (value === null) return null;
-		if (typeof value === "boolean" || typeof value === "string") return value;
-		if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
-		if (!value || typeof value !== "object" || seen.has(value)) return void 0;
-		seen.add(value);
-		if (Array.isArray(value)) {
-			const copy = value.map((entry) => cloneJson(entry, seen));
-			return copy.some((entry) => entry === void 0) ? void 0 : freeze(copy);
-		}
-		if (Object.getPrototypeOf(value) !== Object.prototype) return void 0;
-		const copy = {};
-		for (const [name, entry] of Object.entries(value)) {
-			const cloned = cloneJson(entry, seen);
-			if (cloned === void 0) return void 0;
-			copy[name] = cloned;
-		}
-		return freeze(copy);
-	};
-	const pushViolation = (input) => {
-		const cloned = input.details === void 0 ? void 0 : cloneJson(input.details);
-		const details = cloned && !Array.isArray(cloned) && typeof cloned === "object" ? cloned : void 0;
-		const { details: _details, ...metadata } = input;
-		ownViolations.push(freeze({
-			...metadata,
-			...details ? { details } : {},
-			sequence: nextSequence++,
-			timestamp: Date.now()
-		}));
-		if (input.details !== void 0 && !details) ownViolations.push(freeze({
-			code: "MARKLESS_DEBUG_DETAILS_DROPPED",
-			message: "Debug violation details were not JSON-safe and were dropped.",
-			sequence: nextSequence++,
-			timestamp: Date.now()
-		}));
-		while (ownViolations.length > 100) {
-			ownViolations.shift();
-			dropped++;
-		}
-	};
-	const channel = freeze({
-		version: 1,
-		get containers() {
-			const inherited = previous?.containers.filter((entry) => entry.id !== id) ?? [];
-			if (pruned || lifecycle === "disposed") return freeze([...inherited]);
-			const currentRoot = rootRef.deref();
-			const connected = !!currentRoot && currentRoot.isConnected !== false;
-			const snapshot = freeze({
-				id,
-				phase,
-				lifecycle: connected ? lifecycle : "disposed",
-				root: freeze({
-					key: rootKey,
-					connected
-				}),
-				boundaries: freeze([...boundarySnapshots])
-			});
-			if (!connected) pruned = true;
-			return freeze([...inherited, snapshot]);
-		},
-		get violations() {
-			return freeze([...previous?.violations ?? [], ...ownViolations].slice(-100));
-		},
-		violationCapacity: 100,
-		get droppedViolationCount() {
-			return (previous?.droppedViolationCount ?? 0) + dropped;
-		},
-		explainInteraction: explain
-	});
-	Object.defineProperty(global, "__MARKLESS_DEBUG__", {
-		configurable: true,
-		enumerable: false,
-		value: channel,
-		writable: false
-	});
-	return {
-		start(nextPhase, active = true) {
-			phase = nextPhase === "ssr-resume" && phase === "csr" ? "csr" : nextPhase;
-			if (active) lifecycle = "active";
-			return id;
-		},
-		activate: () => void (lifecycle === "disposed" || (lifecycle = "active")),
-		dispose() {
-			lifecycle = "disposed";
-			boundarySnapshots = freeze([]);
-		},
-		invalidate(element) {
-			events.delete(element);
-			invalidated.add(element);
-		},
-		record(element, eventName, input) {
-			if (lifecycle === "disposed") return;
-			let byName = events.get(element);
-			if (!byName) events.set(element, byName = /* @__PURE__ */ new Map());
-			const symbolIds = "symbolIds" in input ? freeze([...input.symbolIds]) : void 0;
-			byName.set(eventName, freeze({
-				...input,
-				...symbolIds ? { symbolIds } : {},
-				containerId: id,
-				elementKey: keyFor(element),
-				eventName
-			}));
-		},
-		delegated(eventNames) {
-			if (lifecycle === "disposed") return;
-			for (const eventName of eventNames) delegatedEvents.add(eventName);
-		},
-		violation: pushViolation,
-		router: (source) => void routerSources.add(source),
-		boundaries(value) {
-			boundarySnapshots = freeze(value.map((entry) => freeze({ ...entry })));
-		},
-		disposed: () => lifecycle === "disposed"
-	};
-}
-function __marklessDebugBootstrapSource() {
-	return `((root,phase,active)=>{const controls=(${installDebugChannelLayer.toString()})(root,phase,active);return Object.freeze({record:(element,eventName,input)=>controls.record(element,eventName,input),delegated:(eventNames)=>controls.delegated(eventNames),router:(source)=>controls.router(source),activate:()=>controls.activate()})})`;
-}
-//#endregion
-//#region 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")}`);
-}
-const compiledPrerenderSources = /* @__PURE__ */ new Map();
-function compilePrerenderInlineResumerSources() {
-	let compiled = compiledPrerenderSources.get("production");
-	if (!compiled) {
-		compiled = compilePrerenderVariants();
-		compiledPrerenderSources.set("production", compiled);
-	}
-	return compiled;
-}
-async function compilePrerenderVariants() {
-	const [prerender, prerenderSelfWake, prerenderSettle] = await Promise.all([
-		compilePrerenderInlineResumerSource(false),
-		compilePrerenderInlineResumerSource(true),
-		compilePrerenderInlineResumerSource("settle")
-	]);
-	return {
-		prerender,
-		prerenderSelfWake,
-		prerenderSettle
-	};
-}
-async function compilePrerenderInlineResumerSource(selfWake) {
-	const source = parameterizedPrerenderInlineResumerSource(selfWake);
-	const { minifySync, transformSync } = await loadOxcTools();
-	const transformed = transformSync("markless-prerender-inline-resumer.js", source, {
-		lang: "js",
-		sourceType: "script",
-		target: "es2020"
-	});
-	assertOxcResult("transform", transformed.errors);
-	const minified = minifySync("markless-prerender-inline-resumer.js", transformed.code, {
-		compress: true,
-		mangle: { toplevel: true },
-		module: false
-	});
-	assertOxcResult("minify", minified.errors);
-	const code = minified.code.trim();
-	if (code.split(PRERENDER_INLINE_EVENT_NAMES_TOKEN).length !== 2) throw new Error("MARKLESS_PRERENDER_INLINE_RESUMER_EVENT_NAMES_TOKEN_LOST");
-	return code;
-}
-function parameterizedPrerenderInlineResumerSource(selfWake) {
-	const placeholder = [PRERENDER_INLINE_EVENT_NAMES_TOKEN];
-	const literal = JSON.stringify(placeholder);
-	const plain = selfWake === "settle" ? createPrerenderSettleInlineResumerSource(placeholder, void 0) : createPrerenderInlineResumerSource(placeholder, void 0);
-	if (plain.split(literal).length !== 2) throw new Error("MARKLESS_PRERENDER_INLINE_RESUMER_EVENT_NAMES_UNPLACEABLE");
-	return `${plain.replace(literal, PRERENDER_INLINE_EVENT_NAMES_TOKEN)}${selfWake === true ? createInlineResumerSelfWakeSource(void 0) : ""}`;
-}
-//#endregion
-//#region src/bound-resolver.ts
-function adaptImportedCaptureResolver(source, hasImportedRows) {
-	if (!hasImportedRows) return source;
-	const original = "	return (context) => base({ ...context, capture: createCaptureContext(context, bound) });";
-	const replacement = [
-		"	return async (context) => {",
-		"		const pendingCallbacks = [];",
-		"		const capture = createCaptureContext(context, bound);",
-		"		const result = await base({ ...context, graph: createBoundGraph(context, bound, capture, pendingCallbacks), capture });",
-		"		await Promise.all(pendingCallbacks);",
-		"		return result;",
-		"	};"
-	].join("\n");
-	const helper = [
-		"function createBoundGraph(context, bound, capture, pendingCallbacks) {",
-		"	const legacySlots = new Map(bound.captureSlots.flatMap((slot) => slot.legacyGraphRead ? [[JSON.stringify([slot.legacyGraphRead.graphNodeId, slot.legacyGraphRead.path ?? []]), slot]] : []));",
-		"	let lastCallback = Promise.resolve();",
-		"	return {",
-		"		...context.graph,",
-		"		read(graphNodeId, path = []) {",
-		"			const slot = legacySlots.get(JSON.stringify([graphNodeId, path]));",
-		"			if (!slot) return context.graph.read(graphNodeId, path);",
-		"			if (slot.route.kind === callbackRoute) return (...args) => {",
-		"				const pending = lastCallback.then(() => context.invokeSymbol(slot.route.callbackSymbolId, { ...context, event: context.event, args }));",
-		"				lastCallback = pending.catch(() => {});",
-		"				pendingCallbacks.push(pending);",
-		"				return pending;",
-		"			};",
-		"			return capture.read(slot.slotId);",
-		"		},",
-		"	};",
-		"}",
-		""
-	].join("\n");
-	return source.replace(original, replacement).replace("function createCaptureContext(context, bound) {", `${helper}function createCaptureContext(context, bound) {`);
-}
-//#endregion
-//#region src/trigger-groups.ts
-const EVENT_STAGES_BROWSER_TRIGGER = {
-	[PROTOCOL_EVENT_ACTION_KIND.event]: true,
-	[PROTOCOL_EVENT_ACTION_KIND.externalDelegate]: false
-};
-function triggerGroupVirtualModuleId(filename, index) {
-	return `virtual:markless:trigger-group:${encodeURIComponent(filename)}:${index}`;
-}
-function triggerGroupVirtualModuleSourceFile(moduleId) {
-	const bare = moduleId.startsWith("\0") ? moduleId.slice(1) : moduleId;
-	const match = /^virtual:markless:trigger-group:([^:]+):\d+$/.exec(bare);
-	if (!match?.[1]) return null;
-	try {
-		return decodeURIComponent(match[1]);
-	} catch {
-		return null;
-	}
-}
-function emitPrerenderTriggerGroupModule(input) {
-	const armRendererModuleId = input.armRendererModuleId ?? input.group.armRendererModuleId;
-	const ids = new Set(input.group.symbolIds);
-	const boundRows = input.boundRows.filter((row) => ids.has(row.id));
-	let source = emitSymbolResolverModule({
-		symbols: input.symbols.filter((symbol) => ids.has(symbol.id)),
-		boundSymbols: boundRows
-	});
-	const routes = input.symbolRoutes ?? [];
-	if (routes.length > 0) {
-		source = source.replaceAll("loadSymbol(", "marklessLoadLocalSymbol(");
-		source += [
-			"export function loadSymbol(symbolId) {",
-			...routes.flatMap((route) => [
-				`\tif (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
-				"importSource" in route ? `\t\treturn import(${JSON.stringify(symbolRouteImportSource(route.importSource))}).then((mod) => mod.loadSymbol ? mod.loadSymbol(symbolId.slice(${route.prefix.length})) : Promise.reject(new Error(\`Unknown child async symbol \${symbolId}\`)));` : `\t\treturn ${route.prefix.length > 0 ? "loadSymbol" : "marklessLoadLocalSymbol"}(symbolId.slice(${route.prefix.length}));`,
-				"	}"
-			]),
-			"	return marklessLoadLocalSymbol(symbolId);",
-			"}"
-		].join("\n");
-	}
-	return [
-		armRendererModuleId ? [
-			`import { prepareBoundaryArm as marklessPrepareBoundaryArm, renderBoundaryArm as marklessRenderBoundaryArm } from ${JSON.stringify(armRendererModuleId)};`,
-			"export function prepareBoundaryArm(boundaryId, status, graph) {",
-			"	return marklessPrepareBoundaryArm(boundaryId, status, graph, loadSymbol);",
-			"}",
-			"export function renderBoundaryArm(boundaryId, status, graph) {",
-			"	return marklessRenderBoundaryArm(boundaryId, status, graph, loadSymbol);",
-			"}"
-		].join("\n") : "",
-		adaptImportedCaptureResolver(source, boundRows.some((row) => row.loaderSymbolId !== void 0)),
-		`export const groupId=${JSON.stringify(input.group.id)};`,
-		`export const state=${JSON.stringify(input.group.state)};`,
-		`export const view=${JSON.stringify(input.group.view)};`,
-		`export const graphNodeIds=${JSON.stringify(input.group.graphNodeIds)};`
-	].join("\n");
-}
-function emitPrerenderBoundaryRendererModule(renderDataId) {
-	return [
-		`import { marklessPrerenderData } from ${JSON.stringify(renderDataId)};`,
-		"import { renderPrerenderBoundary } from '@markless/web/fns/prerender-resume';",
-		"const marklessPreparedBoundaryArms = new Map();",
-		"export async function prepareBoundaryArm(boundaryId, status, graph, loadSymbol) {",
-		"	const rendered = await renderPrerenderBoundary(marklessPrerenderData, boundaryId, status, graph, loadSymbol);",
-		"	marklessPreparedBoundaryArms.set(`${boundaryId}:${status}`, rendered);",
-		"}",
-		"export function renderBoundaryArm(boundaryId, status) {",
-		"	const key = `${boundaryId}:${status}`;",
-		"	const rendered = marklessPreparedBoundaryArms.get(key);",
-		"	if (!rendered) throw new Error(`Markless prerender arm ${key} was not prepared.`);",
-		"	marklessPreparedBoundaryArms.delete(key);",
-		"	return rendered;",
-		"}"
-	].join("\n");
-}
-function symbolRouteImportSource(importSource) {
-	return importSource.includes("?") ? `${importSource}&markless-symbols` : `${importSource}?markless-symbols`;
-}
-function planPrerenderTriggerGroups(input) {
-	const symbols = new Map(input.symbolResolver.symbols.map((symbol) => [symbol.id, symbol]));
-	const bounds = new Map(input.boundRows.map((row) => [row.id, row]));
-	const completeView = input.completeView ?? input.view;
-	const completeBoundaries = new Map(completeView.asyncBoundaries.map((boundary) => [boundary.id, boundary]));
-	const selfWakeBoundaries = unsettledAsyncBoundaryIndexes(input.state, input.view);
-	const groups = [
-		...selfWakeBoundaries.length > 0 ? [{
-			event: {
-				hostNodeId: "self-wake",
-				eventName: "self-wake",
-				symbolIds: []
-			},
-			selfWakeBoundaries
-		}] : [],
-		...input.view.events.filter((event) => EVENT_STAGES_BROWSER_TRIGGER[protocolEventActionKind(event)]).map((event) => ({ event })),
-		...(input.view.branches ?? []).flatMap((branch, branchIndex) => {
-			const events = /* @__PURE__ */ new Map();
-			for (const arm of branch.armRecords ?? []) for (const event of arm.events) {
-				const key = `${event.eventName}:${event.hostPath.join(".")}`;
-				const route = events.get(key) ?? {
-					eventName: event.eventName,
-					hostPath: event.hostPath,
-					symbolIds: /* @__PURE__ */ new Set()
-				};
-				for (const symbolId of event.symbolIds ?? []) route.symbolIds.add(symbolId);
-				events.set(key, route);
-			}
-			return [...events.values()].map((route) => ({
-				event: {
-					hostNodeId: `branch:${branch.id}:${route.hostPath.join(".")}`,
-					eventName: route.eventName,
-					symbolIds: [...route.symbolIds]
-				},
-				branch,
-				branchIndex,
-				hostPath: route.hostPath
-			}));
-		})
-	].flatMap(({ event, branch, branchIndex, hostPath, selfWakeBoundaries }) => {
-		const closureView = selfWakeBoundaries ? completeView : input.view;
-		if (event.eventName === "visible") return [];
-		const host = branch ? void 0 : input.view.locators.find((locator) => locator.hostNodeId === event.hostNodeId);
-		if (!host && !branch && !selfWakeBoundaries) return [];
-		const compilerGroup = input.triggerGroups.groups.find((group) => group.hostNodeId === event.hostNodeId && group.eventName === event.eventName);
-		const graphNodeIds = /* @__PURE__ */ new Set();
-		const symbolIds = new Set(event.symbolIds ?? []);
-		const selected = {
-			domUpdates: /* @__PURE__ */ new Set(),
-			behaviors: /* @__PURE__ */ new Set(),
-			branches: /* @__PURE__ */ new Set(),
-			boundaries: /* @__PURE__ */ new Set(),
-			repeats: /* @__PURE__ */ new Set(),
-			elementHandles: /* @__PURE__ */ new Set()
-		};
-		if (branch && branchIndex !== void 0) {
-			selected.branches.add(branchIndex);
-			if (branch.symbolId) symbolIds.add(branch.symbolId);
-			for (const read of branch.testReads ?? []) graphNodeIds.add(read.graphNodeId);
-			for (const arm of branch.armRecords ?? []) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
-		}
-		const adoptedBoundaryIds = /* @__PURE__ */ new Set();
-		for (const boundaryIndex of selfWakeBoundaries ?? []) {
-			const servedBoundary = input.view.asyncBoundaries[boundaryIndex];
-			selected.boundaries.add(boundaryIndex);
-			collectSettledBoundaryClosure(input, completeBoundaries.get(servedBoundary.id) ?? servedBoundary, graphNodeIds, symbolIds);
-		}
-		closureView.behaviors.forEach((behavior, index) => {
-			if (selfWakeBoundaries) return;
-			const recordId = `behavior:${behavior.hostNodeId}:${behavior.symbolId ?? ""}`;
-			if ((behavior.inputGraphReads?.length ?? 0) > 0 && !compilerGroup?.payloadRecordIds.includes(recordId)) return;
-			selected.behaviors.add(index);
-			if (behavior.symbolId) symbolIds.add(behavior.symbolId);
-		});
-		let changed = true;
-		while (changed) {
-			const before = closureSize(graphNodeIds, symbolIds, selected);
-			const currentSymbolIds = Array.from(symbolIds);
-			for (const symbolId of currentSymbolIds) {
-				const bound = bounds.get(symbolId);
-				if (bound) {
-					symbolIds.add(bound.loaderSymbolId ?? bound.baseSymbolId);
-					for (const slot of bound.captureSlots) {
-						if (slot.route.kind === "graph-reference") graphNodeIds.add(slot.route.graphNodeId);
-						if (slot.route.kind === "callback-route") symbolIds.add(slot.route.callbackSymbolId);
-					}
-				}
-				const symbol = symbols.get(symbolId);
-				if (!symbol) continue;
-				if ("reads" in symbol) for (const read of symbol.reads ?? []) graphNodeIds.add(read.graphNodeId);
-				if ("writes" in symbol) for (const write of symbol.writes ?? []) graphNodeIds.add(write.graphNodeId);
-				if (symbol.kind === "async-computed-runner" || symbol.kind === "sync-computed-derive") {
-					graphNodeIds.add(symbol.graphNodeId);
-					for (const dependency of symbol.dependencies ?? []) graphNodeIds.add(dependency.graphNodeId);
-				}
-				if ("elementHandleCalls" in symbol) for (const call of symbol.elementHandleCalls ?? []) closureView.elementHandles.forEach((handle, index) => {
-					if (handle.name === call.handleName) selected.elementHandles.add(index);
-				});
-				if ("elementHandleReads" in symbol) for (const read of symbol.elementHandleReads ?? []) closureView.elementHandles.forEach((handle, index) => {
-					if (handle.handleId === read.handleId || handle.name === read.handleName) selected.elementHandles.add(index);
-				});
-			}
-			closeComputedGraph(graphNodeIds, input.state);
-			for (const graphNodeId of graphNodeIds) {
-				const runnerSymbolId = closureView.asyncRunners?.[graphNodeId];
-				if (runnerSymbolId) symbolIds.add(runnerSymbolId);
-			}
-			selectViewSubscribers(closureView, graphNodeIds, symbolIds, selected);
-			if (!selfWakeBoundaries) input.view.asyncBoundaries.forEach((servedBoundary, index) => {
-				if (adoptedBoundaryIds.has(servedBoundary.id)) return;
-				const boundary = completeBoundaries.get(servedBoundary.id) ?? servedBoundary;
-				if (!settledArmReadGraphNodeIds(input, boundary).some((graphNodeId) => graphNodeIds.has(graphNodeId))) return;
-				adoptedBoundaryIds.add(servedBoundary.id);
-				selected.boundaries.add(index);
-				collectSettledBoundaryClosure(input, boundary, graphNodeIds, symbolIds);
-				collectSettledArmHostRecordClosure(completeView, boundary, graphNodeIds, symbolIds);
-			});
-			if (selfWakeBoundaries || adoptedBoundaryIds.size > 0) {
-				for (const symbol of symbols.values()) if (symbol.kind === "state-initializer" && graphNodeIds.has(symbol.graphNodeId)) symbolIds.add(symbol.id);
-			}
-			changed = closureSize(graphNodeIds, symbolIds, selected) !== before;
-		}
-		const neededHosts = new Set(branch ? [] : [event.hostNodeId]);
-		for (const index of selected.domUpdates) neededHosts.add(closureView.domUpdates[index].hostNodeId);
-		for (const index of selected.behaviors) neededHosts.add(closureView.behaviors[index].hostNodeId);
-		for (const index of selected.repeats) neededHosts.add(closureView.keyedRepeats[index].parentHostNodeId);
-		for (const index of selected.elementHandles) neededHosts.add(closureView.elementHandles[index].hostNodeId);
-		const selectedBoundaryIds = new Set([...selected.boundaries].map((index) => closureView.asyncBoundaries[index].id));
-		const view = {
-			...input.view,
-			locators: closureView.locators.filter((locator) => neededHosts.has(locator.hostNodeId)),
-			events: branch || selfWakeBoundaries ? [] : [event],
-			domUpdates: closureView.domUpdates.filter((_, index) => selected.domUpdates.has(index)),
-			behaviors: closureView.behaviors.filter((_, index) => selected.behaviors.has(index)),
-			elementHandles: closureView.elementHandles.filter((_, index) => selected.elementHandles.has(index)),
-			keyedRepeats: closureView.keyedRepeats?.filter((_, index) => selected.repeats.has(index)),
-			branches: closureView.branches?.filter((_, index) => selected.branches.has(index)),
-			asyncBoundaries: closureView.asyncBoundaries.filter((boundary) => selectedBoundaryIds.has(boundary.id)).map((boundary) => adoptedBoundaryIds.has(boundary.id) ? completeBoundaries.get(boundary.id) ?? boundary : boundary),
-			...closureView.asyncRunners ? { asyncRunners: Object.fromEntries(Object.entries(closureView.asyncRunners).filter(([graphNodeId]) => graphNodeIds.has(graphNodeId))) } : {}
-		};
-		const graphIds = [...graphNodeIds].sort();
-		return [{
-			id: selfWakeBoundaries ? "self-wake" : branch ? `branch:${branch.id}:${event.eventName}:${hostPath.join(".")}` : `${event.hostNodeId}:${event.eventName}`,
-			hostNodeId: event.hostNodeId,
-			eventName: event.eventName,
-			hostIndex: host?.index ?? -1,
-			hostTagName: host?.tagName ?? "*",
-			...branch ? {
-				branchStartIndex: branch.startAnchor.index,
-				branchEndIndex: branch.endAnchor.index,
-				hostPath
-			} : {},
-			graphNodeIds: graphIds,
-			symbolIds: [...symbolIds].sort(),
-			state: filterState(input.state, new Set(graphIds)),
-			view,
-			...adoptedBoundaryIds.size > 0 ? { adoptsSettledArm: true } : {}
-		}];
-	});
-	const armRendererModuleId = groups.some((group) => group.id === "self-wake") ? triggerGroupVirtualModuleId(input.filename, groups.length) : void 0;
-	return groups.map(({ adoptsSettledArm, ...group }) => adoptsSettledArm && armRendererModuleId ? {
-		...group,
-		armRendererModuleId
-	} : group);
-}
-function settledArmReadGraphNodeIds(input, boundary) {
-	const graphNodeIds = /* @__PURE__ */ new Set();
-	for (const arm of boundaryArmRecordSets(boundary)) collectCompleteArmRecordClosure(arm, graphNodeIds, /* @__PURE__ */ new Set());
-	for (const edge of input.componentEdges ?? []) if (edge.asyncBoundaryId === boundary.id) {
-		for (const prop of edge.props) if (prop.kind === "graph-reference") graphNodeIds.add(prop.graphNodeId);
-	}
-	return [...graphNodeIds];
-}
-function collectSettledBoundaryClosure(input, boundary, graphNodeIds, symbolIds) {
-	if (boundary.updateSymbolId) symbolIds.add(boundary.updateSymbolId);
-	for (const read of boundary.asyncReads) {
-		graphNodeIds.add(read.graphNodeId);
-		if (read.runnerSymbolId) symbolIds.add(read.runnerSymbolId);
-	}
-	for (const arm of boundaryArmRecordSets(boundary)) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
-	const settledEdgeIds = /* @__PURE__ */ new Set();
-	for (const edge of input.componentEdges ?? []) {
-		if (edge.asyncBoundaryId !== boundary.id) continue;
-		settledEdgeIds.add(edge.id);
-		for (const prop of edge.props) if (prop.kind === "graph-reference") graphNodeIds.add(prop.graphNodeId);
-	}
-	for (const row of input.boundRows) if (row.componentEdgePath.some((edgeId) => settledEdgeIds.has(edgeId))) symbolIds.add(row.id);
-}
-function collectSettledArmHostRecordClosure(completeView, boundary, graphNodeIds, symbolIds) {
-	const armHosts = /* @__PURE__ */ new Set();
-	for (const arm of boundaryArmRecordSets(boundary)) for (const locator of arm.locators ?? []) armHosts.add(locator.hostNodeId);
-	if (armHosts.size === 0) return;
-	for (const record of completeView.events) if (armHosts.has(record.hostNodeId)) for (const symbolId of record.symbolIds ?? []) symbolIds.add(symbolId);
-	for (const record of completeView.domUpdates) if (armHosts.has(record.hostNodeId)) {
-		graphNodeIds.add(record.graphNodeId);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-	}
-	for (const record of completeView.behaviors) if (armHosts.has(record.hostNodeId)) {
-		for (const read of record.inputGraphReads ?? []) graphNodeIds.add(read.graphNodeId);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-	}
-	for (const record of completeView.keyedRepeats ?? []) if (armHosts.has(record.parentHostNodeId)) {
-		if (record.collectionGraphNodeId) graphNodeIds.add(record.collectionGraphNodeId);
-		for (const rowEvent of record.rowEvents) for (const symbolId of rowEvent.symbolIds ?? []) symbolIds.add(symbolId);
-	}
-}
-function boundaryArmRecordSets(boundary) {
-	return Array.isArray(boundary.armRecords) ? boundary.armRecords : boundary.armRecords ? [boundary.armRecords] : [];
-}
-function unsettledAsyncBoundaryIndexes(state, view) {
-	const computed = new Map(state.computed.map((record) => [record.graphNodeId, record]));
-	const runners = { ...view.asyncRunners };
-	for (const boundary of view.asyncBoundaries) for (const read of boundary.asyncReads) if (read.runnerSymbolId) runners[read.graphNodeId] ??= read.runnerSymbolId;
-	return view.asyncBoundaries.flatMap((boundary, index) => {
-		const reachable = new Set(boundary.asyncReads.map((read) => read.graphNodeId));
-		for (const graphNodeId of reachable) {
-			const record = computed.get(graphNodeId);
-			if (!record) continue;
-			if (runners[graphNodeId] && record.snapshot?.status !== "fulfilled" && record.snapshot?.status !== "rejected") return [index];
-			for (const dependency of record.dependencies ?? []) reachable.add(dependency.graphNodeId);
-		}
-		return [];
-	});
-}
-function selectViewSubscribers(view, graphNodeIds, symbolIds, selected) {
-	view.domUpdates.forEach((record, index) => {
-		if (!graphNodeIds.has(record.graphNodeId)) return;
-		selected.domUpdates.add(index);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-	});
-	view.behaviors.forEach((record, index) => {
-		if (!(record.inputGraphReads ?? []).some((read) => graphNodeIds.has(read.graphNodeId))) return;
-		selected.behaviors.add(index);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-	});
-	(view.branches ?? []).forEach((record, index) => {
-		if (!(record.testReads ?? []).some((read) => graphNodeIds.has(read.graphNodeId))) return;
-		selected.branches.add(index);
-		if (record.symbolId) symbolIds.add(record.symbolId);
-		for (const arm of record.armRecords ?? []) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
-	});
-	view.asyncBoundaries.forEach((record, index) => {
-		if (!record.asyncReads.some((read) => graphNodeIds.has(read.graphNodeId))) return;
-		selected.boundaries.add(index);
-		if (record.updateSymbolId) symbolIds.add(record.updateSymbolId);
-		for (const read of record.asyncReads) if (read.runnerSymbolId) symbolIds.add(read.runnerSymbolId);
-		const arms = Array.isArray(record.armRecords) ? record.armRecords : record.armRecords ? [record.armRecords] : [];
-		for (const arm of arms) collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds);
-	});
-	(view.keyedRepeats ?? []).forEach((record, index) => {
-		if (!record.collectionGraphNodeId || !graphNodeIds.has(record.collectionGraphNodeId)) return;
-		selected.repeats.add(index);
-		for (const rowEvent of record.rowEvents) for (const symbolId of rowEvent.symbolIds ?? []) symbolIds.add(symbolId);
-	});
-}
-function collectCompleteArmRecordClosure(arm, graphNodeIds, symbolIds) {
-	for (const event of arm.events ?? []) for (const symbolId of event.symbolIds ?? []) symbolIds.add(symbolId);
-	for (const update of arm.domUpdates ?? []) {
-		if (typeof update.graphNodeId === "string") graphNodeIds.add(update.graphNodeId);
-		if (typeof update.symbolId === "string") symbolIds.add(update.symbolId);
-	}
-	for (const behavior of arm.behaviors ?? []) {
-		for (const read of behavior.inputGraphReads ?? []) if (typeof read.graphNodeId === "string") graphNodeIds.add(read.graphNodeId);
-		if (typeof behavior.symbolId === "string") symbolIds.add(behavior.symbolId);
-	}
-	for (const repeat of arm.keyedRepeats ?? []) {
-		if (repeat.collectionGraphNodeId) graphNodeIds.add(repeat.collectionGraphNodeId);
-		for (const event of repeat.rowEvents) for (const symbolId of event.symbolIds ?? []) symbolIds.add(symbolId);
-	}
-	for (const branch of arm.branches ?? []) {
-		if (branch.symbolId) symbolIds.add(branch.symbolId);
-		for (const read of branch.testReads ?? []) graphNodeIds.add(read.graphNodeId);
-		for (const nested of branch.armRecords ?? []) collectCompleteArmRecordClosure(nested, graphNodeIds, symbolIds);
-	}
-}
-function closeComputedGraph(graphNodeIds, state) {
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const computed of state.computed) {
-			const dependencies = computed.dependencies ?? [];
-			if (!graphNodeIds.has(computed.graphNodeId) && !dependencies.some((dependency) => graphNodeIds.has(dependency.graphNodeId))) continue;
-			if (!graphNodeIds.has(computed.graphNodeId)) {
-				graphNodeIds.add(computed.graphNodeId);
-				changed = true;
-			}
-			for (const dependency of dependencies) if (!graphNodeIds.has(dependency.graphNodeId)) {
-				graphNodeIds.add(dependency.graphNodeId);
-				changed = true;
-			}
-		}
-	}
-}
-function filterState(state, graphNodeIds) {
-	return {
-		...state,
-		cells: state.cells.filter((cell) => graphNodeIds.has(cell.graphNodeId)),
-		computed: state.computed.filter((computed) => graphNodeIds.has(computed.graphNodeId)),
-		storage: state.storage?.filter((cell) => graphNodeIds.has(cell.graphNodeId)),
-		sharedDefinitions: state.sharedDefinitions?.filter((definition) => definition.graphNodeIds.some((graphNodeId) => graphNodeIds.has(graphNodeId)))
-	};
-}
-function closureSize(graphNodeIds, symbolIds, selected) {
-	return graphNodeIds.size + symbolIds.size + Object.values(selected).reduce((total, records) => total + records.size, 0);
-}
-//#endregion
-//#region src/transform.ts
-let oxcTransformSyncPromise;
-function loadOxcTransformSync() {
-	oxcTransformSyncPromise ??= import("rolldown/experimental").then((mod) => mod.transformSync, () => void 0);
-	return oxcTransformSyncPromise;
-}
-async function stripEmittedTypes(code, moduleId, onlyRemoveTypeImports = false) {
-	const oxcTransformSync = await loadOxcTransformSync();
-	if (!oxcTransformSync) throw typeStripError(moduleId, "rolldown/experimental exposes no transformSync.");
-	let out;
-	try {
-		out = oxcTransformSync("markless-emitted.ts", code, onlyRemoveTypeImports ? { typescript: { onlyRemoveTypeImports: true } } : void 0);
-	} catch (error) {
-		throw typeStripError(moduleId, error instanceof Error ? error.message : String(error));
-	}
-	const errors = out.errors ?? [];
-	if (errors.length > 0 || !out.code) throw typeStripError(moduleId, errors.map((error) => error.message).join("; ") || "oxc produced no output.");
-	return out.code;
-}
-async function stripEmittedTypesFromFragment(code, moduleId, onlyRemoveTypeImports = false) {
-	if (await parsesAsJavaScript(code)) return code;
-	return (await stripEmittedTypes(code, moduleId, onlyRemoveTypeImports)).trim();
-}
-async function stripEmittedTypesFromExpression(source, moduleId) {
-	const stripped = await stripEmittedTypesFromFragment(source, moduleId);
-	return stripped.endsWith(";") ? stripped.slice(0, -1).trimEnd() : stripped;
-}
-async function parsesAsJavaScript(code) {
-	const oxcTransformSync = await loadOxcTransformSync();
-	if (!oxcTransformSync) return false;
-	try {
-		return (oxcTransformSync("markless-emitted.js", code).errors?.length ?? 0) === 0;
-	} catch {
-		return false;
-	}
-}
-function typeStripError(moduleId, message) {
-	return new MarklessCompileError(createCompileErrorPayload({
-		filename: moduleId,
-		source: "",
-		diagnostics: [],
-		details: `MARKLESS_TYPE_STRIP_FAILED: ${moduleId} could not have its TypeScript syntax stripped. ${message}`
-	}));
-}
-async function transformTsrxModule(input) {
-	return transformTsrxModuleWithPrerenderWakeClosure(input, false);
-}
-function marklessVirtualModuleSourceFile(moduleId) {
-	const bare = moduleId.startsWith("\0") ? moduleId.slice(1) : moduleId;
-	if (!bare.startsWith("virtual:markless:")) return null;
-	const rest = bare.slice(MARKLESS_VIRTUAL_PREFIX.length);
-	const kindEnd = rest.indexOf(":");
-	if (kindEnd <= 0) return null;
-	const encoded = rest.slice(kindEnd + 1).split(":")[0].replace(/\.css$/, "");
-	if (!encoded) return null;
-	try {
-		return decodeURIComponent(encoded);
-	} catch {
-		return null;
-	}
-}
-async function transformTsrxModuleWithPrerenderWakeClosure(input, linkedChildHasBrowserTriggers) {
-	const encodedFilename = encodeURIComponent(input.filename);
-	const payloadId = `${MARKLESS_VIRTUAL_PREFIX}payload:${encodedFilename}`;
-	const renderDataId = `${MARKLESS_VIRTUAL_PREFIX}render-data:${encodedFilename}`;
-	const resolverId = `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodedFilename}`;
-	const resumeId = resumeVirtualModuleId(input.filename);
-	const prerenderWakeId = prerenderWakeVirtualModuleId(input.filename);
-	const settleId = settleVirtualModuleId(input.filename);
-	const { compiled: compiledForAllClasses, blockingDiagnostics } = await compileWithBlockingDiagnostics(input, resolverId);
-	throwIfBlocked(input, blockingDiagnostics);
-	const runtimeDemandClass = input.runtimeDemandClass ?? "prerender";
-	const compiled = {
-		...compiledForAllClasses,
-		runtimeDemandMap: compiledForAllClasses.runtimeDemandMaps?.[runtimeDemandClass] ?? compiledForAllClasses.runtimeDemandMap
-	};
-	const compilerSymbolRows = compiled.symbolModules.modules.map((module) => ({
-		id: module.symbolId,
-		chunk: symbolVirtualModuleId(input.filename, module.symbolId),
-		exportName: scopedSymbolExportName(input.filename, module.exportName)
-	}));
-	const linkedBoundarySymbols = linkedRenderDataBoundarySymbols({
-		compiled,
-		link: input,
-		clientLink: input.environment === "client",
-		renderDataId,
-		resolverId,
-		symbolModuleId: (symbolId) => symbolVirtualModuleId(input.filename, symbolId),
-		boundaryExportName: (index) => scopedSymbolExportName(input.filename, `marklessLinkedBoundaryUpdate${index}`)
-	});
-	const symbolRows = [...compilerSymbolRows, ...linkedBoundarySymbols.map((symbol) => symbol.row)];
-	const behaviorSymbolIds = new Set((compiled.protocolView.behaviors ?? []).flatMap((behavior) => behavior.symbolId ? [behavior.symbolId] : []));
-	const behaviorSymbols = compilerSymbolRows.filter((symbol) => behaviorSymbolIds.has(symbol.id));
-	const importedBoundRows = compiled.boundSymbolResolver.rows.map((row) => row.loaderSymbolId ? {
-		...row,
-		baseSymbolId: row.loaderSymbolId
-	} : row);
-	const boundSymbolDescriptors = perBoundaryBoundSymbolDescriptors(compiled.renderData, importedBoundRows);
-	const resolverSymbols = uniqueSymbolsById([...input.symbols ?? [], ...symbolRows]);
-	const resolverSource = adaptImportedCaptureResolver(emitSymbolResolverModule({
-		buildId: input.buildId,
-		symbols: resolverSymbols,
-		boundSymbols: importedBoundRows
-	}), importedBoundRows.some((row) => row.loaderSymbolId !== void 0));
-	const symbolRoutes = componentEdgeSymbolRoutes(compiled, input.artifactChildMaterializations);
-	const executionLogModuleHookMode = input.executionLogModuleHooks === false ? "never" : input.executionLog;
-	const symbolManifestEntries = [...compiled.symbolModules.modules.map((module, index) => ({
-		symbolId: module.symbolId,
-		kind: module.kind,
-		exportName: compilerSymbolRows[index].exportName,
-		virtualModuleId: symbolVirtualModuleId(input.filename, module.symbolId)
-	})), ...linkedBoundarySymbols.map((symbol) => symbol.manifest)];
-	const prerenderTriggerGroups = input.prerenderRecordData && input.prerenderWakeVariant ? planPrerenderTriggerGroups({
-		filename: input.filename,
-		...input.prerenderRecordData,
-		completeView: containerScopedResumeView(compiled.protocolView),
-		triggerGroups: compiled.triggerGroups,
-		symbolResolver: compiled.symbolResolver,
-		boundRows: importedBoundRows,
-		componentEdges: compiled.semanticGraph.componentEdges
-	}) : [];
-	const selfWakeArmRendererId = prerenderTriggerGroups.some((group) => group.id === "self-wake") ? triggerGroupVirtualModuleId(input.filename, prerenderTriggerGroups.length) : void 0;
-	const styleScope = compiled.publicRenderPlan.styleScopes[0];
-	const styleId = styleScope ? `${MARKLESS_VIRTUAL_PREFIX}style:${encodedFilename}.css` : null;
-	const prerenderClosureNeedsWake = needsFullResume(compiled.protocolState, compiled.protocolView, compiled.runtimeDemandMap) || input.prerenderRecords === true && linkedChildHasBrowserTriggers;
-	const emitsPrerenderWakeVariant = input.prerenderWakeVariant === true && compiled.publicRenderModule.renderDataModuleSource !== void 0 && prerenderInterfacesComplete(compiled, input) && prerenderClosureNeedsWake;
-	const emitsPrerenderWakeFacade = input.prerenderWakeFacade === true && input.prerenderWakeVariant === true && compiled.publicRenderModule.renderDataModuleSource !== void 0 && prerenderInterfacesComplete(compiled, input) && prerenderClosureNeedsWake;
-	const manifestOwnsSymbolRoutes = input.prerenderWakeVariant !== true || input.preserveWakeSiblingClaims === true || emitsPrerenderWakeFacade;
-	const manifest = {
-		source: input.filename,
-		captureMetadata: compiled.captureAnalysis,
-		symbolRoutes: importedSymbolRoutes(symbolRoutes),
-		payload: { virtualModuleId: payloadId },
-		resolver: { virtualModuleId: emitsPrerenderWakeFacade ? prerenderWakeId : resolverId },
-		symbols: manifestOwnsSymbolRoutes ? symbolManifestEntries : [],
-		runtimeDemandMap: compiled.runtimeDemandMap
-	};
-	const settlePlan = planSettleModule({
-		boundaries: compiled.renderData?.boundaries,
-		asyncRunners: compiled.protocolView.asyncRunners,
-		descriptors: boundSymbolDescriptors,
-		symbols: resolverSymbols
-	});
-	const prerenderBootVariants = input.environment === "server" ? await compilePrerenderInlineResumerSources() : void 0;
-	const prerenderBoot = prerenderBootVariants ? {
-		...prerenderBootVariants,
-		...input.settleModuleUrl && settlePlan ? { settle: {
-			moduleUrl: input.settleModuleUrl,
-			boot: prerenderBootVariants.prerenderSettle,
-			bound: settlePlan.bound
-		} } : {}
-	} : void 0;
-	const linkedClientRenderData = input.environment === "client" && !input.prerenderRecords;
-	const canonicalRenderData = (input.prerenderRecords || linkedClientRenderData) && prerenderInterfacesComplete(compiled, input);
-	const virtualModules = [
-		...compiled.publicRenderModule.renderDataModuleSource ? [{
-			id: renderDataId,
-			type: "render-data",
-			...canonicalRenderData ? { canonicalRenderData: true } : {},
-			source: canonicalRenderData ? await prerenderDataModuleSource(compiled, input.importedModuleInterfaces, input.renderDataImportSources, input.artifactChildMaterializations, input.filename) : compiled.publicRenderModule.renderDataModuleSource
-		}] : [],
-		...styleScope && styleId ? [{
-			id: styleId,
-			type: "style",
-			source: styleScope.cssText
-		}] : [],
-		{
-			id: payloadId,
-			type: "payload",
-			source: payloadModule({
-				...compiled.payloadScripts,
-				runtimeDemandMap: compiled.runtimeDemandMap
-			})
-		},
-		{
-			id: resolverId,
-			type: "resolver",
-			source: resolverSource,
-			symbolClaims: [...new Set([...resolverSymbols.map((symbol) => symbol.id), ...importedBoundRows.map((symbol) => symbol.id)])]
-		},
-		{
-			id: resumeId,
-			type: "resume",
-			source: emitResumeModule({
-				payloadId,
-				resolverId,
-				payloadState: compiled.payloadScripts.state,
-				payloadView: containerScopedResumeView(compiled.payloadScripts.view),
-				runtimeDemandMap: compiled.runtimeDemandMap,
-				executionLog: input.executionLog,
-				needsFullResume: prerenderClosureNeedsWake,
-				prerenderDataId: input.prerenderRecords && prerenderInterfacesComplete(compiled, input) ? renderDataId : void 0,
-				hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
-				boundSymbolDescriptors,
-				symbols: symbolRows,
-				symbolRoutes
-			})
-		},
-		...emitsPrerenderWakeVariant ? [{
-			id: prerenderWakeId,
-			type: "prerender-wake",
-			source: emitResumeModule({
-				payloadId,
-				resolverId,
-				payloadState: compiled.payloadScripts.state,
-				payloadView: containerScopedResumeView(compiled.payloadScripts.view),
-				runtimeDemandMap: compiled.runtimeDemandMap,
-				executionLog: input.executionLog,
-				needsFullResume: prerenderClosureNeedsWake,
-				prerenderDataId: renderDataId,
-				prerenderTriggerGroups: prerenderTriggerGroups.map((group, index) => ({
-					...group,
-					moduleId: triggerGroupVirtualModuleId(input.filename, index)
-				})),
-				installResumeSummary: true,
-				recordsOnly: true,
-				hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
-				boundSymbolDescriptors,
-				symbols: symbolRows,
-				symbolRoutes
-			})
-		}] : [],
-		...emitsPrerenderWakeVariant && settlePlan ? [{
-			id: settleId,
-			type: "settle",
-			source: emitSettleModule(settlePlan)
-		}] : [],
-		...(input.prerenderWakeVariant ? prerenderTriggerGroups : []).map((group, index) => ({
-			id: triggerGroupVirtualModuleId(input.filename, index),
-			type: "trigger-group",
-			source: emitPrerenderTriggerGroupModule({
-				group,
-				symbols: uniqueSymbolsById([...input.symbols ?? [], ...symbolRows]),
-				boundRows: importedBoundRows,
-				symbolRoutes,
-				armRendererModuleId: group.id === "self-wake" ? selfWakeArmRendererId : void 0
-			})
-		})),
-		...selfWakeArmRendererId ? [{
-			id: selfWakeArmRendererId,
-			type: "trigger-group",
-			source: emitPrerenderBoundaryRendererModule(renderDataId)
-		}] : [],
-		...linkedBoundarySymbols.map((symbol) => symbol.module),
-		...await Promise.all(compiled.symbolModules.modules.map(async (module, index) => ({
-			id: symbolVirtualModuleId(input.filename, module.symbolId),
-			type: "symbol",
-			symbolId: module.symbolId,
-			exportName: symbolRows[index].exportName,
-			source: injectExecutionLogModuleHook(await stripEmittedTypes(rewriteSymbolModuleExport(module.source, module.exportName, symbolRows[index].exportName), symbolVirtualModuleId(input.filename, module.symbolId)), `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: styleImport + await stripEmittedTypes(emitSourceModule({
-			filename: input.filename,
-			dev: input.dev,
-			payloadId,
-			resolverId,
-			renderDataId,
-			environment: input.environment ?? "lib",
-			clientOutput: input.clientOutput ?? "full",
-			executionLog: input.executionLog,
-			headInjections: headInjections.length > 0 ? headInjections : void 0,
-			storageSeeds: storageSeeds.length > 0 ? storageSeeds : void 0,
-			inlineResumerSources,
-			prerenderBoot,
-			devResumeReexport: input.devResumeReexport === true,
-			needsFullResume: prerenderClosureNeedsWake,
-			prerenderRecords: input.prerenderRecords,
-			directCsr: input.directCsr,
-			hasComputedState: compiled.payloadScripts.state.computed.length > 0,
-			hasOverlayMarks: compiled.runtimeDemandMap.payloadRecords.some((record) => record.kind === "overlay"),
-			resumeModuleUrl: input.resumeModuleUrl,
-			prerenderWakeModuleUrl: input.prerenderWakeModuleUrl,
-			publicRenderModuleSource: compiled.publicRenderModule.moduleSource,
-			publicRenderRootExportName: compiled.publicRenderModule.rootExportName,
-			publicSsrModuleSource: compiled.publicRenderModule.ssrModuleSource,
-			publicRenderSsrExportName: compiled.publicRenderModule.ssrExportName,
-			publicRenderSsrComponentExports: compiled.publicRenderModule.ssrComponentExports,
-			canonicalRenderData: prerenderInterfacesComplete(compiled, input),
-			sharedDefinitionExports: compiled.moduleGraphInterface?.sharedDefinitions?.map((published) => published.exportName),
-			hasBoundSymbols: compiled.boundSymbolResolver.rows.length > 0,
-			symbols: symbolRows,
-			behaviorSymbols,
-			symbolRoutes
-		}), input.filename),
-		map: null,
-		virtualModules,
-		manifest,
-		moduleGraphInterface: compiled.moduleGraphInterface,
-		interfaceHash: moduleInterfaceHash(compiled.moduleGraphInterface),
-		moduleImports: compiled.semanticGraph.moduleImports,
-		artifactChildren: artifactChildCandidates(compiled)
-	};
-}
-function resolveAuthoredSpecifier(specifier, sourceFilename) {
-	if (!specifier.startsWith(".")) return specifier;
-	if (!isAbsolute(sourceFilename)) throw new Error(`MARKLESS_RENDER_DATA_READER_SPECIFIER_UNRESOLVABLE: ${JSON.stringify(specifier)} needs an absolute module filename, got ${JSON.stringify(sourceFilename)}.`);
-	return resolve(dirname(sourceFilename), specifier);
-}
-async function prerenderDataModuleSource(compiled, importedModuleInterfaces, renderDataImportSources, artifactChildMaterializations, sourceFilename) {
-	const importedComponents = /* @__PURE__ */ new Map();
-	for (const edge of compiled.semanticGraph.componentEdges) {
-		if (!edge.importSource || importedComponents.has(edge.childComponentName)) continue;
-		if (artifactChildMaterializations?.[edge.id]) continue;
-		const linked = importedModuleInterfaces?.[edge.importSource];
-		if (!linked) throw new Error(`MARKLESS_PRERENDER_RENDER_DATA_MISSING: Imported child ${JSON.stringify(edge.childComponentName)} from ${JSON.stringify(edge.importSource)} has no linked render-data artifact.`);
-		importedComponents.set(edge.childComponentName, {
-			source: renderDataImportSources?.[edge.importSource] ?? `virtual:markless:render-data:${encodeURIComponent(linked.filename)}`,
-			local: `marklessPrerenderImport${importedComponents.size}`
-		});
-	}
-	const renderDataId = `${MARKLESS_VIRTUAL_PREFIX}render-data:${encodeURIComponent(sourceFilename)}`;
-	const readerImports = /* @__PURE__ */ new Map();
-	const readerDeclarations = /* @__PURE__ */ new Map();
-	const componentEntries = [];
-	for (const definition of compiled.publicRenderModule.componentDefinitions) {
-		const { residueReaderSource, residueReaderImports, residueReaderDeclarations, rootsWidget: _rootsWidget, ...record } = definition;
-		for (const entry of residueReaderImports ?? []) {
-			if (readerImports.has(entry.line)) continue;
-			const rebound = entry.line.replace(JSON.stringify(entry.source), JSON.stringify(resolveAuthoredSpecifier(entry.source, sourceFilename)));
-			readerImports.set(entry.line, await stripEmittedTypesFromFragment(rebound, `${renderDataId}:reader-import`, true));
-		}
-		for (const line of residueReaderDeclarations ?? []) {
-			if (readerDeclarations.has(line)) continue;
-			readerDeclarations.set(line, await stripEmittedTypesFromFragment(line, `${renderDataId}:reader-declaration`));
-		}
-		const data = JSON.stringify(record);
-		const reader = residueReaderSource ? await stripEmittedTypesFromExpression(residueReaderSource, `${renderDataId}:reader:${String(definition.name)}`) : void 0;
-		componentEntries.push(`${JSON.stringify(String(definition.name))}:${reader ? `{...${data},readResidue:${reader}}` : data}`);
-	}
-	const preludes = [...readerImports.values(), ...readerDeclarations.values()];
-	return [
-		...compiled.publicRenderModule.componentDefinitions.some((definition) => {
-			const record = definition;
-			return record.rootsWidget === true || Object.values(record.initialValueKinds ?? {}).includes("shared-seed");
-		}) ? ["import { installMarklessSharedSeedPass } from '@markless/web/fns/shared-seed';", "installMarklessSharedSeedPass();"] : [],
-		...[...importedComponents.values()].map((entry) => `import { marklessPrerenderData as ${entry.local} } from ${JSON.stringify(entry.source)};`),
-		...preludes,
-		compiled.publicRenderModule.renderDataModuleSource,
-		`const marklessPrerenderComponents = {${componentEntries.join(",")}};`,
-		"export const marklessPrerenderData = {",
-		`\trootComponentName: ${JSON.stringify(compiled.renderData.root?.componentName ?? null)},`,
-		"	renderData: marklessRenderData,",
-		"	components: marklessPrerenderComponents,",
-		`\timports: {${[...importedComponents].map(([name, entry]) => `${JSON.stringify(name)}:${entry.local}`).join(",")}},`,
-		"};"
-	].join("\n");
-}
-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 ?? [],
-		importedModuleInterfaces: input.importedModuleInterfaces,
-		artifactChildMaterializations: input.artifactChildMaterializations,
-		omitAuthoredSource: normalizeExecutionLogMode(input.executionLog) === "never"
-	});
-	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 containerScopedResumeView(view) {
-	return {
-		...view,
-		locators: (view.locators ?? []).map((locator) => ({
-			...locator,
-			index: locator.index + 1
-		}))
-	};
-}
-function needsFullResume(state, _view, runtimeDemandMap) {
-	if ((state.storage?.length ?? 0) > 0) return true;
-	return runtimeDemandMap.payloadRecords.some((record) => RECORD_NEEDS_FULL_RESUME[record.kind](runtimeDemandMap));
-}
-const RECORD_NEEDS_FULL_RESUME = {
-	"async-boundary": () => true,
-	behavior: () => false,
-	branch: () => true,
-	"dom-update": () => false,
-	"element-handle": () => true,
-	[PROTOCOL_EVENT_ACTION_KIND.event]: () => false,
-	[PROTOCOL_EVENT_ACTION_KIND.externalDelegate]: () => false,
-	"keyed-repeat": (runtimeDemandMap) => !recordKindReplaced(runtimeDemandMap, "keyed-repeat"),
-	overlay: () => true
-};
-function recordKindReplaced(runtimeDemandMap, kind) {
-	return runtimeDemandMap.recordKinds.some((record) => record.kind === kind && record.replaced === true);
-}
-/**
-* What the settle module must import, and what the document must carry to use
-* it. Fails closed: a boundary whose runner symbol or whose bound base symbol
-* is not in this page's symbol rows produces no settle module at all, so the
-* page keeps the self-wake path rather than half a settle.
-*/
-function planSettleModule(input) {
-	const symbolById = new Map(input.symbols.map((symbol) => [symbol.id, symbol]));
-	const runners = [];
-	const derives = [];
-	const bound = {};
-	for (const boundary of input.boundaries ?? []) {
-		const node = boundary.runnerGraphNodeId;
-		if (!node || !boundary.protocolSupported) continue;
-		const runner = symbolById.get(input.asyncRunners?.[node] ?? "");
-		if (!runner) continue;
-		const rows = (input.descriptors?.[boundary.boundaryId] ?? []).map((descriptor) => ({
-			descriptor,
-			symbol: symbolById.get(descriptor.base)
-		}));
-		if (rows.some((row) => !row.symbol)) continue;
-		runners.push({
-			node,
-			symbol: runner
-		});
-		for (const row of rows) {
-			derives.push({
-				id: row.descriptor.id,
-				symbol: row.symbol
-			});
-			bound[boundary.boundaryId] = {
-				...bound[boundary.boundaryId],
-				[row.descriptor.id]: Object.fromEntries(row.descriptor.slots.map((slot) => [`${slot[0]}|${slot[1].join(".")}`, [slot[2], slot[3]]]))
-			};
-		}
-	}
-	return runners.length > 0 ? {
-		runners,
-		derives,
-		bound
-	} : void 0;
-}
-function perBoundaryBoundSymbolDescriptors(renderData, boundRows) {
-	if (boundRows.length === 0) return void 0;
-	const chunks = new Map(renderData.chunks.map((chunk) => [chunk.id, chunk]));
-	const descriptors = {};
-	for (const boundary of renderData.boundaries) {
-		const edges = componentEdgesReachableFrom(chunks, boundary.armChunkIds.try);
-		const rows = boundRows.filter((row) => row.ancestry.some((step) => edges.has(step.componentEdgeId)));
-		if (rows.length === 0) continue;
-		descriptors[boundary.boundaryId] = rows.map((row) => ({
-			id: row.id,
-			base: row.baseSymbolId,
-			slots: row.captureSlots.flatMap((slot) => slot.legacyGraphRead && slot.route.kind === "graph-reference" ? [[
-				slot.legacyGraphRead.graphNodeId,
-				slot.legacyGraphRead.path,
-				slot.route.graphNodeId,
-				slot.route.path
-			]] : [])
-		}));
-	}
-	return Object.keys(descriptors).length > 0 ? descriptors : void 0;
-}
-function componentEdgesReachableFrom(chunks, rootChunkId) {
-	const edges = /* @__PURE__ */ new Set();
-	const pending = [rootChunkId];
-	const visited = /* @__PURE__ */ new Set();
-	while (pending.length > 0) {
-		const id = pending.pop();
-		if (visited.has(id)) continue;
-		visited.add(id);
-		for (const slot of chunks.get(id)?.slots ?? []) if (slot.kind === "child-component") {
-			edges.add(slot.componentEdgeId);
-			pending.push(slot.childTemplateId);
-			if (slot.projectionChunkId) pending.push(slot.projectionChunkId);
-		} else if (slot.kind === "repeat") {
-			pending.push(slot.rowTemplateId);
-			if (slot.emptyTemplateId) pending.push(slot.emptyTemplateId);
-		} else if (slot.kind === "branch") pending.push(...slot.armTemplateIds);
-	}
-	return edges;
-}
-//#endregion
-//#region src/virtual-ids.ts
-const TSRX_SOURCE_FILE$1 = /\.tsrx(?:[?#].*)?$/;
-const MARKLESS_SYMBOL_SOURCE_QUERY_RE = /[?&]markless-symbols(?:[&#]|$)/;
-const MARKLESS_RESUME_SOURCE_QUERY_RE = /[?&]markless-resume(?:[&#]|$)/;
-const MARKLESS_RENDER_DATA_SOURCE_QUERY_RE = /[?&]markless-render-data(?:[&#]|$)/;
-const MARKLESS_REACHED_FROM_SOURCE_QUERY = "markless-reached-from";
-const MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE = /[?&]markless-prerender-wake(?:[&#]|$)/;
-const MARKLESS_ROUTE_SOURCE_QUERY_RE = /[?&]markless-route(?:[&#]|$)/;
-const RESUME_VIRTUAL_ID_RE = /^virtual:markless:resume:([^:]+)$/;
-const PRERENDER_WAKE_VIRTUAL_ID_RE = /^virtual:markless:prerender-wake:([^:]+)$/;
-const SETTLE_VIRTUAL_ID_RE = /^virtual:markless:settle:([^:]+)$/;
-const SYMBOL_VIRTUAL_STRING_RE$1 = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1/g;
-function stripBuildPrefix(fileName) {
-	return fileName.startsWith(MARKLESS_BUILD_PREFIX) ? fileName.slice(MARKLESS_BUILD_PREFIX.length) : fileName;
-}
-function virtualModuleSourceForLoad(module, options) {
-	if (!options.dev || module.type !== "resolver") return module.source;
-	if (!module.source.includes("moduleUrls[row[0]]")) return module.source;
-	return module.source.replace(SYMBOL_VIRTUAL_STRING_RE$1, (_match, _quote, virtualId) => JSON.stringify(devBrowserVirtualModuleUrl(virtualId, options.publicPath)));
-}
-function devBrowserSourceModuleUrl(source, _root, publicPath) {
-	const path = withQuery(joinURL("@fs", withoutLeadingSlash(source)), { import: null });
-	return publicPath ? publicPath(path) : joinURL("/", path);
-}
-function devBrowserVirtualModuleUrl(virtualId, publicPath) {
-	const path = joinURL("@id", resolveVirtualId(virtualId).replace("\0", "__x00__"));
-	return publicPath ? publicPath(path) : joinURL("/", path);
-}
-function clientSymbolEntries(input, root) {
-	if (!input || typeof input !== "object" || Array.isArray(input)) return [];
-	const sources = [];
-	for (const [name, value] of Object.entries(input)) {
-		if (!/symbol/i.test(name)) continue;
-		for (const entry of inputEntryValues(value)) if (typeof entry === "string" && TSRX_SOURCE_FILE$1.test(entry)) sources.push(normalizeInputSource(entry, root));
-	}
-	return sources;
-}
-function inputEntryValues(value) {
-	return Array.isArray(value) ? value.flatMap(inputEntryValues) : [value];
-}
-function normalizeInputSource(source, root) {
-	const path = pathname(source);
-	if (isAbsolute(path)) return path;
-	return pathname(resolve(root ?? "", path));
-}
-function isSymbolOnlySourceRequest(id) {
-	return MARKLESS_SYMBOL_SOURCE_QUERY_RE.test(id);
-}
-function isResumeSourceRequest(id) {
-	return MARKLESS_RESUME_SOURCE_QUERY_RE.test(id);
-}
-function isRenderDataSourceRequest(id) {
-	return MARKLESS_RENDER_DATA_SOURCE_QUERY_RE.test(id);
-}
-function renderDataReachedFromQuery(id) {
-	return new URLSearchParams(parsePath(id).search).get(MARKLESS_REACHED_FROM_SOURCE_QUERY) ?? void 0;
-}
-function materializedReachedRenderDataSource(source, routeRoot) {
-	return withQuery(source, {
-		"markless-render-data": null,
-		[MARKLESS_REACHED_FROM_SOURCE_QUERY]: routeRoot
-	});
-}
-function isPrerenderWakeSourceRequest(id) {
-	return MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE.test(id);
-}
-function isClientPrimarySourceRequest(id) {
-	return !(MARKLESS_SYMBOL_SOURCE_QUERY_RE.test(id) || MARKLESS_RESUME_SOURCE_QUERY_RE.test(id) || MARKLESS_RENDER_DATA_SOURCE_QUERY_RE.test(id) || MARKLESS_PRERENDER_WAKE_SOURCE_QUERY_RE.test(id) || MARKLESS_ROUTE_SOURCE_QUERY_RE.test(id));
-}
-function clientRouteArtifactReference(source) {
-	const symbolSource = source.includes("?") ? `${source}&markless-symbols` : `${source}?markless-symbols`;
-	const renderDataSource = source.includes("?") ? `${source}&markless-render-data` : `${source}?markless-render-data`;
-	return [
-		`const [symbolModule, renderDataModule] = await Promise.all([import(${JSON.stringify(symbolSource)}), import(${JSON.stringify(renderDataSource)})]);`,
-		"const marklessRouteArtifact = {",
-		"	renderData: renderDataModule.marklessPrerenderData,",
-		"	loadSymbol: symbolModule.loadSymbol,",
-		"};",
-		"export default marklessRouteArtifact;"
-	].join("\n");
-}
-function sourceForSymbolVirtualImporter(importer) {
-	if (!importer) return null;
-	return symbolVirtualModuleSourceFile(normalizeVirtualId$2(importer));
-}
-function sourceForResumeVirtualImporter(importer) {
-	if (!importer) return null;
-	const match = normalizeVirtualId$2(importer).match(RESUME_VIRTUAL_ID_RE);
-	return match?.[1] ? decodeURIComponent(match[1]) : null;
-}
-function resolverVirtualModuleSourceFile(id) {
-	const prefix = `${MARKLESS_VIRTUAL_PREFIX}resolver:`;
-	return id.startsWith(prefix) ? decodeURIComponent(id.slice(prefix.length)) : null;
-}
-function sourceForTriggerGroupVirtualImporter(importer) {
-	if (!importer) return null;
-	return triggerGroupVirtualModuleSourceFile(normalizeVirtualId$2(importer));
-}
-function sourceForPrerenderWakeVirtualImporter(importer) {
-	if (!importer) return null;
-	const match = normalizeVirtualId$2(importer).match(PRERENDER_WAKE_VIRTUAL_ID_RE);
-	return match?.[1] ? decodeURIComponent(match[1]) : null;
-}
-function sourceForSettleVirtualImporter(importer) {
-	if (!importer) return null;
-	const match = normalizeVirtualId$2(importer).match(SETTLE_VIRTUAL_ID_RE);
-	return match?.[1] ? decodeURIComponent(match[1]) : null;
-}
-function isRelativeImport(source) {
-	return source.startsWith("./") || source.startsWith("../");
-}
-function isMarklessRuntimeModule(id) {
-	const path = pathname(id);
-	return /[/\\](?:web|runtime|serializer)[/\\]src[/\\].+\.ts$/.test(path);
-}
-function executionLogRuntimeModuleId(id) {
-	const path = pathname(id);
-	const match = path.match(/[/\\](web|runtime|serializer)[/\\]src[/\\]([^?#]+)\.ts$/);
-	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : path;
-}
-function normalizeVirtualId$2(id) {
-	const bare = id.startsWith("\0") ? id.slice(1) : id;
-	if (!bare.startsWith("virtual:markless:")) return bare;
-	const queryIndex = bare.indexOf("?");
-	return `${MARKLESS_VIRTUAL_PREFIX}${(queryIndex === -1 ? bare : bare.slice(0, queryIndex)).slice(MARKLESS_VIRTUAL_PREFIX.length).split(":").map((segment) => {
-		try {
-			return encodeURIComponent(decodeURIComponent(segment));
-		} catch {
-			return segment;
-		}
-	}).join(":")}`;
-}
-function emittedBundleModuleIds(bundle) {
-	const ids = /* @__PURE__ */ new Set();
-	for (const output of Object.values(bundle)) {
-		if (!output || typeof output !== "object") continue;
-		const chunk = output;
-		if (chunk.type !== "chunk") continue;
-		if (typeof chunk.facadeModuleId === "string") ids.add(normalizeVirtualId$2(chunk.facadeModuleId));
-		if (Array.isArray(chunk.moduleIds)) {
-			for (const id of chunk.moduleIds) if (typeof id === "string") ids.add(normalizeVirtualId$2(id));
-		}
-	}
-	return ids;
-}
-function resolveVirtualId(id) {
-	if (id.startsWith("\0")) return id;
-	return `\0${id}`;
-}
-function pathname(id) {
-	return parsePath(id).pathname;
-}
-//#endregion
-//#region src/plugin-state.ts
-const CLAIM_ID_NAMING = {
-	sourcePathOf: pathname,
-	isResumeRequest: isResumeSourceRequest,
-	isWakeRequest: isPrerenderWakeSourceRequest
-};
-function createPluginState() {
-	const virtualModules = /* @__PURE__ */ new Map();
-	const moduleMetadata = new ModuleMetadataRegistry();
-	const prerenderWakeCapabilities = /* @__PURE__ */ new Map();
-	const moduleLinkArtifacts = /* @__PURE__ */ new Map();
-	const linkedTransformCache = /* @__PURE__ */ new Map();
-	const importedChildren = /* @__PURE__ */ new Map();
-	const importedChildSources = /* @__PURE__ */ new Set();
-	const emittedClientResolverSources = /* @__PURE__ */ new Set();
-	const transformVirtualModules = /* @__PURE__ */ new Map();
-	const virtualModuleOwners = /* @__PURE__ */ new Map();
-	const clientSymbolEntrySources = /* @__PURE__ */ new Set();
-	const prerenderWakeSources = /* @__PURE__ */ new Set();
-	const clientRouteArtifactSources = /* @__PURE__ */ new Set();
-	const clientRouteArtifactMaterializations = /* @__PURE__ */ new Map();
-	const transformedClientPrimarySources = /* @__PURE__ */ new Set();
-	const executionLogEstimatedSizes = /* @__PURE__ */ new Map();
-	const executionLogEmittedIds = /* @__PURE__ */ new Map();
-	return {
-		virtualModules,
-		moduleMetadata,
-		prerenderWakeCapabilities,
-		moduleLinkArtifacts,
-		linkedTransformCache,
-		importedChildren,
-		importedChildSources,
-		emittedClientResolverSources,
-		transformVirtualModules,
-		virtualModuleOwners,
-		clientSymbolEntrySources,
-		prerenderWakeSources,
-		clientRouteArtifactSources,
-		clientRouteArtifactMaterializations,
-		transformedClientPrimarySources,
-		executionLogEstimatedSizes,
-		executionLogEmittedIds,
-		regeneratingVirtualModules: /* @__PURE__ */ new Set(),
-		recoveringChildMetadata: /* @__PURE__ */ new Set(),
-		reset() {
-			clientSymbolEntrySources.clear();
-			clientRouteArtifactSources.clear();
-			clientRouteArtifactMaterializations.clear();
-			transformedClientPrimarySources.clear();
-			virtualModules.clear();
-			moduleMetadata.clear();
-			moduleLinkArtifacts.clear();
-			linkedTransformCache.clear();
-			importedChildren.clear();
-			importedChildSources.clear();
-			emittedClientResolverSources.clear();
-			transformVirtualModules.clear();
-			virtualModuleOwners.clear();
-			executionLogEstimatedSizes.clear();
-			executionLogEmittedIds.clear();
-		}
-	};
-}
-function registerTransformArtifacts(state, input) {
-	const ids = /* @__PURE__ */ new Set();
-	const renderDataHashes = /* @__PURE__ */ new Map();
-	for (const module of input.result.virtualModules) {
-		if (input.finalPublication === false && module.type === "resolver") continue;
-		const isClientSymbol = input.environment === "client" && module.type === "symbol";
-		const stored = isClientSymbol ? {
-			...module,
-			source: requalifyExecutionLogModuleHook(module.source, module.id)
-		} : module;
-		const current = state.virtualModules.get(module.id);
-		if (module.type === "resolver" && current?.type === "resolver") {
-			const verdict = linkedResolverClaimVerdict({
-				resolverId: module.id,
-				current: current.symbolClaims,
-				next: module.symbolClaims
-			});
-			if (verdict.action === "keep-current") continue;
-			if (verdict.action === "diverged") throw new Error(verdict.diagnostic.message);
-		}
-		if (module.type !== "render-data" || current?.type !== "render-data" || current.canonicalRenderData !== true || module.canonicalRenderData === true) state.virtualModules.set(module.id, stored);
-		ids.add(module.id);
-		const owners = state.virtualModuleOwners.get(module.id) ?? /* @__PURE__ */ new Set();
-		owners.add(input.owner);
-		state.virtualModuleOwners.set(module.id, owners);
-		if (module.type === "render-data") {
-			const renderData = planRenderDataModule({
-				source: input.source,
-				emittedModule: input.manifestSource,
-				moduleSource: module.source,
-				styleModules: input.result.virtualModules.flatMap((candidate) => candidate.type === "style" ? [candidate.id] : []),
-				manifest: input.result.manifest
-			});
-			renderDataHashes.set(resolveVirtualId(module.id), renderData.contentHash);
-		}
-		if (isClientSymbol) {
-			state.executionLogEstimatedSizes.set(module.id, stored.source.length);
-			if (hasExecutionLogModuleHook(stored.source)) state.executionLogEmittedIds.set(module.id, module.id);
-		}
-	}
-	state.moduleMetadata.recordCaptureMetadata(input.source, input.result.manifest);
-	if (input.finalPublication !== false) {
-		recordEmittedClaimOwnership(state, {
-			source: input.source,
-			emittedModule: input.manifestSource,
-			manifest: input.result.manifest,
-			virtualModules: input.result.virtualModules
-		});
-		if (input.tracksSourceClaimPublication === true) state.moduleMetadata.finishSourceSymbolClaims(input.source, input.manifestSource);
-	}
-	state.moduleLinkArtifacts.set(input.source, {
-		moduleGraphInterface: input.result.moduleGraphInterface,
-		interfaceHash: input.result.interfaceHash,
-		moduleImports: input.result.moduleImports
-	});
-	const previouslyOwned = state.transformVirtualModules.get(input.owner) ?? /* @__PURE__ */ new Set();
-	if (input.replaceOwnedArtifacts === true) {
-		for (const staleId of previouslyOwned) {
-			if (ids.has(staleId)) continue;
-			const owners = state.virtualModuleOwners.get(staleId);
-			owners?.delete(input.owner);
-			if (!owners || owners.size === 0) {
-				state.virtualModuleOwners.delete(staleId);
-				state.virtualModules.delete(staleId);
-			}
-		}
-		state.transformVirtualModules.set(input.owner, ids);
-	} else state.transformVirtualModules.set(input.owner, new Set([...previouslyOwned, ...ids]));
-	input.dev.record(input.source, ids, input.environment);
-	if (renderDataHashes.size > 0) input.updateDevPrerenderHashes?.(renderDataHashes);
-}
-function recordEmittedClaimOwnership(state, input) {
-	const ownership = planEmittedClaimOwnership({
-		source: input.source,
-		emittedModule: input.emittedModule,
-		manifest: input.manifest,
-		resolverModuleId: input.virtualModules.find((module) => module.type === "resolver")?.id,
-		wakeOwnsRoutes: state.moduleMetadata.hasSymbolClaims(input.manifest.resolver.virtualModuleId),
-		claimOwners: [...state.moduleMetadata.symbolClaimMap().keys()],
-		naming: CLAIM_ID_NAMING
-	});
-	const contradiction = ownership.diagnostics[0];
-	if (contradiction) throw new Error(contradiction.message);
-	for (const displaced of ownership.displacedOwners) state.moduleMetadata.deleteSymbolClaims(displaced);
-	state.moduleMetadata.recordSymbolClaims(ownership.owner, input.overrideManifest ?? ownership.manifest);
-}
-function registerRenderDataStyles(state, input) {
-	if (input.modules.length === 0) return;
-	const ids = new Set(state.transformVirtualModules.get(input.owner) ?? []);
-	for (const module of input.modules) {
-		state.virtualModules.set(module.id, module);
-		ids.add(module.id);
-		const owners = state.virtualModuleOwners.get(module.id) ?? /* @__PURE__ */ new Set();
-		owners.add(input.owner);
-		state.virtualModuleOwners.set(module.id, owners);
-	}
-	state.transformVirtualModules.set(input.owner, ids);
-	input.dev.record(input.source, input.modules.map((module) => module.id), "client");
-}
-//#endregion
-//#region src/dev-invalidation.ts
-function invalidateAllGeneratedModules(ctx, parent, currentEnvironment) {
-	const { state, internalOptions, dev, environment } = ctx;
-	const { virtualModules, moduleMetadata, prerenderWakeCapabilities, moduleLinkArtifacts, linkedTransformCache, prerenderWakeSources } = state;
-	const changedSource = pathname(parent);
-	moduleLinkArtifacts.delete(changedSource);
-	moduleMetadata.deleteCaptureMetadata(changedSource);
-	moduleMetadata.invalidateSourceSymbolClaims(changedSource, changedSource);
-	prerenderWakeCapabilities.delete(changedSource);
-	prerenderWakeSources.delete(changedSource);
-	for (const [key, cached] of linkedTransformCache) {
-		if (cached.source !== changedSource) continue;
-		moduleMetadata.invalidateSourceSymbolClaims(changedSource, cached.manifestSource);
-		linkedTransformCache.delete(key);
-	}
-	const ids = dev.clear(parent, currentEnvironment);
-	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];
-}
-async function invalidateEditedGeneratedModules(ctx, parent, currentEnvironment, nextSource) {
-	const { state } = ctx;
-	const { virtualModules, moduleMetadata, prerenderWakeCapabilities, moduleLinkArtifacts, linkedTransformCache } = state;
-	const changedSource = pathname(parent);
-	const cachedEntries = [...linkedTransformCache].filter(([key, cached]) => cached.source === changedSource && (!currentEnvironment || key.startsWith(`${currentEnvironment}\0`)));
-	if (cachedEntries.length === 0) return invalidateAllGeneratedModules(ctx, parent, currentEnvironment);
-	const nextEntries = await Promise.all(cachedEntries.map(async ([key, cached]) => {
-		const nextInput = {
-			...cached.input,
-			source: nextSource
-		};
-		return [
-			key,
-			cached,
-			nextInput,
-			await transformTsrxModuleWithPrerenderWakeClosure(nextInput, cached.linkedChildHasBrowserTriggers)
-		];
-	}));
-	if (nextEntries.some(([, cached, , next]) => !linkedRenderDataOnlyChange(cached.result, next))) return invalidateAllGeneratedModules(ctx, parent, currentEnvironment);
-	const refreshed = new Map(nextEntries.map(([key, , , next]) => [key, next]));
-	const foldEntries = [...linkedTransformCache].flatMap(([key, cached]) => cached.source === changedSource ? [{
-		cached,
-		result: refreshed.get(key) ?? cached.result
-	}] : []);
-	const linkResult = nextEntries[nextEntries.length - 1][3];
-	const captured = (result) => (result.manifest.captureMetadata?.extractedSymbols.length ?? 0) > 0;
-	const captureManifest = nextEntries.findLast(([, , , next]) => captured(next))?.[3].manifest ?? foldEntries.findLast(({ result }) => captured(result))?.result.manifest ?? linkResult.manifest;
-	moduleLinkArtifacts.set(changedSource, {
-		moduleGraphInterface: linkResult.moduleGraphInterface,
-		interfaceHash: linkResult.interfaceHash,
-		moduleImports: linkResult.moduleImports
-	});
-	moduleMetadata.recordCaptureMetadata(changedSource, captureManifest);
-	prerenderWakeCapabilities.set(changedSource, foldEntries.some(({ cached, result }) => linkedManifestHasBrowserTriggers(result.manifest) || cached.linkedChildHasBrowserTriggers));
-	const renderDataIds = /* @__PURE__ */ new Set();
-	for (const [key, cached, nextInput, next] of nextEntries) {
-		linkedTransformCache.set(key, {
-			...cached,
-			code: nextSource,
-			input: nextInput,
-			result: next
-		});
-		recordEmittedClaimOwnership(state, {
-			source: changedSource,
-			emittedModule: cached.manifestSource,
-			manifest: next.manifest,
-			virtualModules: next.virtualModules,
-			...isRenderDataSourceRequest(cached.manifestSource) ? { overrideManifest: renderDataClaimManifest(next.manifest, cached.manifestSource) } : {}
-		});
-		for (const module of next.virtualModules) {
-			if (module.type !== "render-data") continue;
-			virtualModules.set(module.id, module);
-			renderDataIds.add(resolveVirtualId(module.id));
-		}
-	}
-	return [...renderDataIds];
-}
-//#endregion
-//#region src/build/bundle-graph.ts
-const SLOW_BUNDLE_TOTAL = 300 * 1024 / 8 * .5;
-const SMALL_BUNDLE_TOTAL = 1e3;
-function convertManifestToBundleGraph(manifest, bundleGraphAdders) {
-	const graph = bundleGraphRecords(manifest, bundleGraphAdders);
-	const dag = defDGraph(bundleGraphEdges(graph));
-	const reduced = dag.copy();
-	for (const name of dag.nodes()) for (const dep of dag.immediateDependencies(name)) for (const transitive of dag.transitiveDependencies(dep)) reduced.removeEdge(name, transitive);
-	const nodes = Object.keys(graph).sort().map((name) => {
-		const bundle = graph[name];
-		const dynamicImports = (bundle?.dynamicImports ?? []).map((dep) => [dep, dynamicImportMarker(bundle, graph[dep])]).sort((a, b) => a[1] - b[1] || a[0].localeCompare(b[0]));
-		const deps = [...reduced.immediateDependencies(name)].sort();
-		let lastMarker;
-		for (const [dep, marker] of dynamicImports) {
-			if (marker !== lastMarker) {
-				deps.push(marker);
-				lastMarker = marker;
-			}
-			deps.push(dep);
-		}
-		return [name, deps];
-	});
-	const indexes = /* @__PURE__ */ new Map();
-	let index = 0;
-	for (const [name, deps] of nodes) {
-		indexes.set(name, index);
-		index += 1 + deps.length;
-	}
-	return nodes.flatMap(([name, deps]) => [name, ...deps.map((dep) => {
-		if (typeof dep === "number") return dep;
-		return indexes.get(dep);
-	})]);
-}
-function createPreloadGraphAdder(addEntries) {
-	return (manifest) => addEntries({
-		manifest,
-		hasBundle: (bundleName) => !!manifest.bundles[bundleName],
-		bundlesForOrigins: (origins) => bundlesForOrigins(manifest, origins)
-	});
-}
-function bundlesForOrigins(manifest, origins) {
-	const normalizedOrigins = new Set(origins.map(normalizeManifestOrigin));
-	const bundles = [];
-	for (const [bundleName, bundle] of Object.entries(manifest.bundles)) if (bundle.origins?.some((origin) => normalizedOrigins.has(normalizeManifestOrigin(origin)))) bundles.push(bundleName);
-	return bundles.sort();
-}
-function bundleGraphRecords(manifest, bundleGraphAdders) {
-	const graph = { ...manifest.bundles };
-	const runtimeBundles = runtimeBundleNamesByModuleId(manifest);
-	for (const module of manifest.modules) {
-		const runtimeModuleIdsBySymbolId = new Map((module.runtimeDemandMap?.symbols ?? []).map((symbol) => [symbol.symbolId, symbol.runtimeModuleIds]));
-		for (const symbol of module.symbols) {
-			if (!symbol.fileName) continue;
-			const imports = [...manifest.bundles[symbol.fileName]?.imports ?? [], ...module.resolver.fileName ? [module.resolver.fileName] : []];
-			const runtimeDemandBundles = (runtimeModuleIdsBySymbolId.get(symbol.symbolId) ?? []).flatMap((id) => runtimeBundles.get(id) ?? []);
-			const symbolBundle = {
-				size: 0,
-				total: 0,
-				dynamicImports: [...new Set([symbol.fileName, ...runtimeDemandBundles])]
-			};
-			if (imports.length > 0) symbolBundle.imports = imports;
-			graph[symbol.symbolId] = symbolBundle;
-		}
-	}
-	for (const [bundleName, bundle] of Object.entries(graph)) for (const symbolId of bundle.symbols ?? []) {
-		if (symbolId === bundleName) continue;
-		graph[symbolId] = appendDynamicImport(graph[symbolId] ?? {
-			size: 0,
-			total: 0
-		}, bundleName);
-	}
-	if (bundleGraphAdders) {
-		const combined = {
-			...manifest,
-			bundles: graph
-		};
-		for (const add of bundleGraphAdders) Object.assign(graph, add(combined));
-	}
-	for (const bundleName of Object.keys(graph)) {
-		const bundle = graph[bundleName];
-		if (!bundle) continue;
-		graph[bundleName] = {
-			...bundle,
-			imports: bundle.imports?.filter((dep) => graph[dep]) ?? [],
-			dynamicImports: bundle.dynamicImports?.filter((dep) => graph[dep]) ?? []
-		};
-	}
-	const used = /* @__PURE__ */ new Set();
-	for (const bundle of Object.values(graph)) {
-		for (const dep of bundle.imports ?? []) used.add(dep);
-		for (const dep of bundle.dynamicImports ?? []) used.add(dep);
-	}
-	for (const [bundleName, bundle] of Object.entries(graph)) if (!used.has(bundleName) && !bundle.imports?.length && !bundle.dynamicImports?.length) delete graph[bundleName];
-	return graph;
-}
-function appendDynamicImport(bundle, dependency) {
-	if (bundle.dynamicImports?.includes(dependency)) return bundle;
-	return {
-		...bundle,
-		dynamicImports: [...bundle.dynamicImports ?? [], dependency]
-	};
-}
-function runtimeBundleNamesByModuleId(manifest) {
-	const entries = /* @__PURE__ */ new Map();
-	for (const [bundleName, bundle] of Object.entries(manifest.bundles)) for (const origin of bundle.origins ?? []) {
-		const runtimeModuleId = runtimeModuleIdFromOrigin(origin);
-		if (!runtimeModuleId) continue;
-		entries.set(runtimeModuleId, [...entries.get(runtimeModuleId) ?? [], bundleName]);
-	}
-	for (const [id, names] of entries) entries.set(id, names.sort());
-	return entries;
-}
-function runtimeModuleIdFromOrigin(origin) {
-	const normalized = normalizeManifestOrigin(origin);
-	for (const [prefix, marker] of [["web", "packages/web/src/"], ["core", "packages/core/src/"]]) {
-		const index = normalized.lastIndexOf(marker);
-		if (index === -1 || !normalized.endsWith(".ts")) continue;
-		return `${prefix}/${normalized.slice(index + marker.length, -3)}`;
-	}
-}
-function dynamicImportMarker(bundle, dependency) {
-	let probability = .5;
-	if (hasRelatedOrigin(bundle, dependency)) probability += .25;
-	if ((dependency?.total ?? 0) > SLOW_BUNDLE_TOTAL) if (probability > .5) probability += .02;
-	else probability -= .02;
-	if ((dependency?.total ?? 0) < SMALL_BUNDLE_TOTAL) probability += .15;
-	probability = Math.min(probability, .99);
-	return -Math.round(probability * 10);
-}
-function hasRelatedOrigin(bundle, dependency) {
-	return !!bundle?.origins?.some((origin) => dependency?.origins?.some((depOrigin) => depOrigin.startsWith(origin)));
-}
-function* bundleGraphEdges(graph) {
-	for (const [bundleName, bundle] of Object.entries(graph)) {
-		yield [bundleName, null];
-		for (const dep of bundle.imports ?? []) yield [bundleName, dep];
-	}
-}
-function normalizeManifestOrigin(origin) {
-	return withoutLeadingSlash(normalize(origin));
-}
-//#endregion
-//#region src/build/dynamic-import-scan.ts
-function scanEmittedDynamicImports(code, chunkFileName) {
-	if (!code.includes("import(")) return [];
-	let ast;
-	try {
-		ast = parseJavaScriptModule(code);
-	} catch {
-		return [];
-	}
-	const specifiers = /* @__PURE__ */ new Set();
-	const visit = (node) => {
-		if (!node || typeof node !== "object") return;
-		if (node.type === "ImportExpression") {
-			const specifier = staticSpecifier(node.source ?? node.arguments);
-			if (specifier?.startsWith(".")) specifiers.add(join(dirname(chunkFileName), specifier));
-		}
-		for (const child of childNodes$1(node)) visit(child);
-	};
-	visit(ast);
-	return [...specifiers];
-}
-function staticSpecifier(source) {
-	const node = Array.isArray(source) ? source[0] : source;
-	if (!node || typeof node !== "object") return void 0;
-	const astNode = node;
-	if (astNode.type === "Literal" || astNode.type === "StringLiteral") return typeof astNode.value === "string" ? astNode.value : void 0;
-	if (astNode.type === "TemplateLiteral" && (astNode.expressions ?? []).length === 0) {
-		const quasi = astNode.quasis?.[0];
-		return quasi?.value?.cooked ?? quasi?.cooked;
-	}
-}
-function childNodes$1(node) {
-	const children = [];
-	for (const [key, value] of Object.entries(node)) {
-		if (key === "loc" || key === "span" || key === "range") continue;
-		if (Array.isArray(value)) {
-			for (const item of value) if (isAstNode$1(item)) children.push(item);
-			continue;
-		}
-		if (isAstNode$1(value)) children.push(value);
-	}
-	return children;
-}
-function isAstNode$1(value) {
-	return !!value && typeof value === "object" && "type" in value;
-}
-//#endregion
-//#region src/build/head-links.ts
-const STYLESHEET_ASSET_RE = /\.css$/;
-function collectHeadLinkInjections(bundle, options = {}) {
-	const publicPath = options.publicPath ?? ((fileName) => fileName);
-	const stylesheetFiles = stylesheetFilesFromViteMetadata(bundle);
-	if (stylesheetFiles.size === 0) {
-		for (const item of Object.values(bundle)) if (item.type === "asset" && STYLESHEET_ASSET_RE.test(item.fileName)) stylesheetFiles.add(item.fileName);
-	}
-	return [...stylesheetFiles].sort().map((fileName) => stylesheetInjection(publicPath(fileName)));
-}
-function stylesheetFilesFromViteMetadata(bundle) {
-	const stylesheetFiles = /* @__PURE__ */ new Set();
-	for (const item of Object.values(bundle)) {
-		if (item.type !== "chunk") continue;
-		for (const fileName of item.viteMetadata?.importedCss ?? []) stylesheetFiles.add(fileName);
-	}
-	return stylesheetFiles;
-}
-function collectModulePreloadInjections(preloadSource, options = {}) {
-	const buildMetadata = isBuildMetadata(preloadSource) ? preloadSource : void 0;
-	const bundleGraph = buildMetadata ? buildMetadata.bundleGraph : preloadSource;
-	const roots = [
-		...buildMetadata ? symbolRootsFromBuildMetadata(buildMetadata) : (bundleGraph ?? []).filter((name) => typeof name === "string" && name.startsWith("symbol:")).map((name) => ({
-			name,
-			priority: "high"
-		})),
-		...(options.entryChunks ?? []).map((name) => ({
-			name,
-			priority: "auto",
-			edges: "dynamic-only"
-		})),
-		...(options.wakeChunks ?? []).map((name) => ({
-			name,
-			priority: "auto"
-		}))
-	];
-	return planModulePreloads({
-		base: options.publicPath ? options.publicPath(MARKLESS_BUILD_PREFIX) : joinURL("/", MARKLESS_BUILD_PREFIX),
-		bundleGraph,
-		roots
-	}).map(modulePreloadInjection);
-}
-function symbolRootsFromBuildMetadata(metadata) {
-	const roots = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const module of metadata.modules) for (const symbol of module.symbols) {
-		if (!symbol.fileName || seen.has(symbol.symbolId)) continue;
-		seen.add(symbol.symbolId);
-		roots.push({
-			name: symbol.symbolId,
-			priority: "high"
-		});
-	}
-	return roots;
-}
-function isBuildMetadata(value) {
-	return !!value && typeof value === "object" && !Array.isArray(value) && Array.isArray(value.modules);
-}
-function injectHeadLinks(bundle, injections) {
-	if (injections.length === 0) return;
-	const links = [...new Map(injections.map((injection) => [headLinkKey(injection), injection])).values()].map(headLinkTag).join("");
-	for (const output of Object.values(bundle)) {
-		if (!isHtmlAssetWithSource(output)) continue;
-		output.source = output.source.includes("</head>") ? output.source.replace("</head>", `${links}</head>`) : `${links}${output.source}`;
-	}
-}
-function headLinkTag(injection) {
-	if (injection.tag === "link" && injection.attributes?.rel === "modulepreload") return `<link ${Object.entries(injection.attributes).map(([name, value]) => compactAttribute(name, value)).join(" ")}>`;
-	const attributes = Object.entries(injection.attributes ?? {}).map(([name, value]) => `${name}="${value.replaceAll("\"", "&quot;")}"`);
-	const open = attributes.length > 0 ? `<${injection.tag} ${attributes.join(" ")}>` : `<${injection.tag}>`;
-	return injection.children === void 0 ? open : `${open}${injection.children}</${injection.tag}>`;
-}
-function headLinkKey(injection) {
-	return JSON.stringify([
-		injection.tag,
-		injection.location,
-		Object.entries(injection.attributes ?? {}),
-		injection.children
-	]);
-}
-function compactAttribute(name, value) {
-	if (name === "crossorigin" && value === "anonymous") return name;
-	return /^[^\s"'`=<>]+$/.test(value) ? `${name}=${value}` : `${name}="${value.replaceAll("\"", "&quot;")}"`;
-}
-function isHtmlAssetWithSource(output) {
-	if (!output || typeof output !== "object") return false;
-	const asset = output;
-	return asset.type === "asset" && typeof asset.fileName === "string" && asset.fileName.endsWith(".html") && typeof asset.source === "string";
-}
-function modulePreloadInjection(preload) {
-	const attributes = {
-		rel: "modulepreload",
-		href: preload.href,
-		crossorigin: "anonymous"
-	};
-	if (preload.fetchPriority && preload.fetchPriority !== "auto") attributes.fetchpriority = preload.fetchPriority;
-	return {
-		tag: "link",
-		location: "head",
-		attributes
-	};
-}
-function stylesheetInjection(href) {
-	return {
-		tag: "link",
-		location: "head",
-		attributes: {
-			rel: "stylesheet",
-			href
-		}
-	};
-}
-//#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 = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1/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$1(bundle);
-	const symbolFiles = collectGeneratedSymbolFiles(chunks);
-	let rewritten = 0;
-	const unresolved = /* @__PURE__ */ new Set();
-	for (const chunk of chunks.values()) {
-		if (!chunk.code.includes(SYMBOL_VIRTUAL_PREFIX)) continue;
-		const result = rewriteSymbolVirtualStrings(chunk, symbolFiles);
-		chunk.code = result.code;
-		rewritten += result.rewritten;
-		for (const id of result.unresolved) unresolved.add(id);
-	}
-	return {
-		rewritten,
-		unresolved: [...unresolved].sort()
-	};
-}
-/**
-* Returns the final chunk routes encoded in generated symbol tables. These
-* routes feed computed import() calls, so bundler dynamic-import metadata and
-* a plain import-expression scan cannot observe them.
-*/
-function scanGeneratedSymbolTableImports(code, chunkFileName) {
-	const imports = /* @__PURE__ */ new Set();
-	for (const match of code.matchAll(SYMBOL_MANIFEST_TUPLE_RE)) for (const specifier of parseStringList(match[2]) ?? []) if (specifier.startsWith(".")) imports.add(resolveChunkSpecifier$1(chunkFileName, specifier));
-	return [...imports];
-}
-/**
-* 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$1(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$1(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$1(bundle) {
-	const chunks = /* @__PURE__ */ new Map();
-	for (const output of Object.values(bundle)) if (isGeneratedChunk$1(output)) chunks.set(output.fileName, output);
-	return chunks;
-}
-function collectGeneratedSymbolFiles(chunks) {
-	const symbolFiles = /* @__PURE__ */ new Map();
-	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$1(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$1(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$1(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);
-}
-function rewriteSymbolVirtualStrings(chunk, symbolFiles) {
-	let rewritten = 0;
-	const unresolved = /* @__PURE__ */ new Set();
-	return {
-		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$1(chunk.fileName, fileName);
-			}));
-		}).replace(SYMBOL_VIRTUAL_STRING_RE, (match, _quote, virtualId) => {
-			const fileName = symbolFiles.get(virtualId);
-			if (!fileName) {
-				unresolved.add(virtualId);
-				return match;
-			}
-			rewritten++;
-			return JSON.stringify(relativeChunkSpecifier$1(chunk.fileName, fileName));
-		})),
-		rewritten,
-		unresolved: [...unresolved]
-	};
-}
-function compactSymbolManifestTables(code) {
-	return code.replace(SYMBOL_MANIFEST_TUPLE_RE, (match, prefix, moduleUrlsSource, exportNamesSource, symbolRowsSource, suffix) => {
-		const moduleUrls = parseStringArray(moduleUrlsSource);
-		if (!moduleUrls) return match;
-		const nextModuleUrls = [];
-		const moduleIndexMap = /* @__PURE__ */ new Map();
-		const seen = /* @__PURE__ */ new Map();
-		for (const [index, moduleUrl] of moduleUrls.entries()) {
-			let nextIndex = seen.get(moduleUrl);
-			if (nextIndex === void 0) {
-				nextIndex = nextModuleUrls.length;
-				seen.set(moduleUrl, nextIndex);
-				nextModuleUrls.push(moduleUrl);
-			}
-			moduleIndexMap.set(index, nextIndex);
-		}
-		if (nextModuleUrls.length === moduleUrls.length) return match;
-		const nextSymbolRows = symbolRowsSource.replace(SYMBOL_ROW_RE, (rowMatch, rowPrefix, moduleIndexSource, rowSuffix) => {
-			const moduleIndex = Number(moduleIndexSource);
-			const nextModuleIndex = moduleIndexMap.get(moduleIndex);
-			if (nextModuleIndex === void 0) return rowMatch;
-			return `${rowPrefix}${nextModuleIndex}${rowSuffix}`;
-		});
-		return `${prefix}${JSON.stringify(nextModuleUrls)},${exportNamesSource},${nextSymbolRows}${suffix}`;
-	});
-}
-function parseStringArray(source) {
-	const values = [];
-	let end = 1;
-	for (const match of source.matchAll(STRING_LITERAL_RE)) {
-		values.push(match[2]);
-		end = (match.index ?? 0) + match[0].length;
-	}
-	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$1(importerFileName, targetFileName) {
-	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
-	return value.startsWith(".") ? value : `./${value}`;
-}
-function isGeneratedChunk$1(value) {
-	if (!value || typeof value !== "object") return false;
-	const chunk = value;
-	return chunk.type === "chunk" && typeof chunk.fileName === "string" && typeof chunk.code === "string" && Array.isArray(chunk.moduleIds);
-}
-function normalizeVirtualId$1(id) {
-	return id.startsWith("\0") ? id.slice(1) : id;
-}
-//#endregion
-//#region src/build/build-metadata.ts
-function createBuildMetadata(bundle, transformManifests, root, options = {}) {
-	const canonPath = options.canonPath ?? ((fileName) => fileName);
-	const publicPath = options.publicPath ?? ((fileName) => fileName);
-	const modules = [...transformManifests].map(cloneTransformManifest);
-	const metadata = {
-		version: 1,
-		modules,
-		bundles: {},
-		assets: {},
-		injections: [...options.injections ?? [], ...collectHeadLinkInjections(bundle, { publicPath })]
-	};
-	for (const item of Object.values(bundle)) {
-		if (item.type === "asset") {
-			if (item.fileName.endsWith(".js.map")) continue;
-			metadata.assets[item.fileName] = assetInfo(item);
-			continue;
-		}
-		const bundleFileName = canonPath(item.fileName);
-		const origins = getOrigins(item, root);
-		const asyncBundle = {
-			size: item.code.length,
-			total: item.code.length
-		};
-		const imports = mapBundleNames(bundle, item.imports, canonPath);
-		if (imports.length > 0) asyncBundle.imports = imports;
-		const dynamicImports = [...new Set([
-			...mapBundleNames(bundle, item.dynamicImports, canonPath),
-			...mapBundleNames(bundle, scanEmittedDynamicImports(item.code, item.fileName), canonPath),
-			...mapBundleNames(bundle, scanGeneratedSymbolTableImports(item.code, item.fileName), canonPath)
-		])];
-		if (dynamicImports.length > 0) asyncBundle.dynamicImports = dynamicImports;
-		if (origins.length > 0) asyncBundle.origins = origins;
-		finalizeVirtualModuleReferences(modules, item, bundleFileName);
-		const symbols = modules.flatMap((module) => module.symbols.filter((symbol) => symbol.fileName === bundleFileName).map((symbol) => symbol.symbolId));
-		if (symbols.length > 0) asyncBundle.symbols = symbols;
-		metadata.bundles[bundleFileName] = asyncBundle;
-	}
-	computeTotals(metadata.bundles);
-	sortBuildMetadata(metadata);
-	if (options.bundleGraphAsset) {
-		metadata.bundleGraph = convertManifestToBundleGraph(metadata, options.bundleGraphAdders);
-		metadata.bundleGraphAsset = options.bundleGraphAsset;
-		metadata.assets[options.bundleGraphAsset] = {
-			name: "bundle-graph.json",
-			size: JSON.stringify(metadata.bundleGraph).length
-		};
-	}
-	return metadata;
-}
-function cloneTransformManifest(manifest) {
-	return {
-		source: manifest.source,
-		payload: { ...manifest.payload },
-		resolver: { ...manifest.resolver },
-		symbols: manifest.symbols.map((symbol) => ({ ...symbol })),
-		runtimeDemandMap: manifest.runtimeDemandMap
-	};
-}
-function finalizeVirtualModuleReferences(modules, item, bundleFileName) {
-	const ids = new Set([item.facadeModuleId ?? void 0, ...item.moduleIds].filter((id) => !!id).map(normalizeVirtualModuleId));
-	for (const module of modules) {
-		for (const reference of [module.payload, module.resolver]) if (ids.has(normalizeVirtualModuleId(reference.virtualModuleId))) reference.fileName = bundleFileName;
-		for (const symbol of module.symbols) if (ids.has(normalizeVirtualModuleId(symbol.virtualModuleId))) symbol.fileName = bundleFileName;
-	}
-}
-function normalizeVirtualModuleId(id) {
-	if (id.startsWith("\0")) return id.slice(1);
-	return id;
-}
-function assetInfo(item) {
-	return {
-		name: item.names?.[0] ?? item.name,
-		size: item.source.length
-	};
-}
-function mapBundleNames(bundle, names, canonPath) {
-	return names.flatMap((name) => {
-		const item = bundle[name];
-		if (item) return [canonPath(item.fileName)];
-		return [canonPath(name)];
-	});
-}
-function getOrigins(item, root) {
-	return item.moduleIds.filter((id) => !id.startsWith("\0")).map((id) => {
-		if (root) return relative(root, id);
-		return id;
-	}).sort();
-}
-function computeTotals(bundles) {
-	const collect = (name, seen) => {
-		const bundle = bundles[name];
-		if (!bundle || seen.has(name)) return;
-		seen.add(name);
-		for (const dep of bundle.imports ?? []) collect(dep, seen);
-	};
-	for (const name of Object.keys(bundles)) {
-		const seen = /* @__PURE__ */ new Set();
-		collect(name, seen);
-		bundles[name].total = [...seen].reduce((sum, dep) => sum + (bundles[dep]?.size ?? 0), 0);
-	}
-}
-function sortBuildMetadata(metadata) {
-	metadata.modules = metadata.modules.sort((a, b) => a.source.localeCompare(b.source));
-	metadata.bundles = sortRecord$1(metadata.bundles);
-	metadata.assets = sortRecord$1(metadata.assets ?? {});
-	metadata.injections?.sort((a, b) => injectionKey(a).localeCompare(injectionKey(b)));
-	for (const bundle of Object.values(metadata.bundles)) {
-		bundle.imports?.sort();
-		bundle.dynamicImports?.sort();
-		bundle.origins?.sort();
-		bundle.symbols?.sort();
-	}
-	for (const module of metadata.modules) module.symbols.sort((a, b) => a.symbolId.localeCompare(b.symbolId));
-}
-function sortRecord$1(record) {
-	const next = {};
-	for (const key of Object.keys(record).sort()) {
-		const value = record[key];
-		if (value !== void 0) next[key] = value;
-	}
-	return next;
-}
-function injectionKey(injection) {
-	return `${injection.location}:${injection.tag}:${injection.attributes?.href ?? ""}`;
-}
-//#endregion
-//#region src/build/execution-sizes.ts
-const MARKLESS_EXECUTION_SIZES = `${MARKLESS_BUILD_PREFIX}execution-sizes.json`;
-const CONTENT_HASH_MODULE_SPECIFIER = /chunk-[A-Za-z0-9_-]+\.js/g;
-const CONTENT_HASH_PLACEHOLDER = "chunk-________.js";
-function canonicalizeContentHashSpecifiers(source) {
-	return source.replace(CONTENT_HASH_MODULE_SPECIFIER, CONTENT_HASH_PLACEHOLDER);
-}
-async function createExecutionSizesAsset(bundle, metadata, canonPath = (fileName) => fileName, attribution, options = {}) {
-	const entries = {};
-	const sizeByChunk = /* @__PURE__ */ new Map();
-	const chunkSize = async (item, chunk) => {
-		const cached = sizeByChunk.get(chunk);
-		if (cached) return cached;
-		const size = {
-			raw: item.code.length,
-			gzip: await gzipByteLength(canonicalizeContentHashSpecifiers(item.code)),
-			chunk
-		};
-		sizeByChunk.set(chunk, size);
-		return size;
-	};
-	const symbolLogIdsByChunk = /* @__PURE__ */ new Map();
-	for (const module of metadata.modules) for (const symbol of module.symbols) {
-		if (!symbol.fileName) continue;
-		const chunk = symbolLogIdsByChunk.get(symbol.fileName) ?? [];
-		chunk.push(stripResolvedIdMarker(symbol.virtualModuleId));
-		symbolLogIdsByChunk.set(symbol.fileName, chunk);
-	}
-	for (const item of Object.values(bundle)) {
-		if (item.type !== "chunk") continue;
-		const chunk = canonPath(item.fileName);
-		const logIds = new Set([...item.moduleIds.flatMap((id) => chunkModuleLogId(id) ?? []), ...symbolLogIdsByChunk.get(chunk) ?? []]);
-		if (logIds.size === 0) continue;
-		if (logIds.has("virtual:markless:dev-log") && logIds.size > 1) {
-			const cohabitingIds = [...logIds].filter((id) => id !== MARKLESS_EXECUTION_LOG_MODULE_ID).sort();
-			throw new Error(`Markless execution sizes require an isolated dev-log chunk; chunk "${chunk}" also contains logged module ids: ${cohabitingIds.join(", ")}.`);
-		}
-		const size = await chunkSize(item, chunk);
-		for (const id of logIds) entries[id] = id === "virtual:markless:dev-log" ? {
-			...size,
-			instrument: true
-		} : size;
-		const emittedSpecifier = `./${chunk.split("/").pop()}`;
-		entries[emittedSpecifier] ??= size;
-	}
-	const unshipped = {};
-	if (options.executionLogActive === true) {
-		const absorbing = absorbingChunkIndex(bundle);
-		const unmappable = [];
-		for (const required of requiredExecutionLogIds(metadata, options.hookedIds, absorbing)) {
-			if (entries[required.id]) continue;
-			const item = absorbing.get(required.id);
-			if (!item) {
-				if (required.shipped) unmappable.push(required.id);
-				else if (required.hooked) unshipped[required.id] = UNSHIPPED_HOOK_REASON;
-				continue;
-			}
-			const size = await chunkSize(item, canonPath(item.fileName));
-			entries[required.id] = required.id === "virtual:markless:dev-log" ? {
-				...size,
-				instrument: true
-			} : size;
-		}
-		if (unmappable.length > 0) throw new Error(`Markless execution sizes are incomplete: no chunk carries ${unmappable.sort().join(", ")}. Every id this build can log must join build/execution-sizes.json, or the in-page console reports "bytes unknown" for a real execution.`);
-	}
-	return {
-		type: "asset",
-		fileName: MARKLESS_EXECUTION_SIZES,
-		source: JSON.stringify({
-			...sortRecord(entries),
-			...Object.keys(unshipped).length > 0 ? { unshipped: sortRecord(unshipped) } : {},
-			...attribution && Object.keys(attribution).length > 0 ? { attribution: sortNestedRecord(attribution) } : {}
-		})
-	};
-}
-const UNSHIPPED_HOOK_REASON = "hooked at transform time (before chunk assignment exists); no client chunk carries this module, so it can never execute in a browser";
-function requiredExecutionLogIds(metadata, hookedIds = /* @__PURE__ */ new Map(), absorbing = /* @__PURE__ */ new Map()) {
-	const required = /* @__PURE__ */ new Map();
-	const add = (id, shipped, hooked = false) => {
-		const current = required.get(id);
-		if (!current || shipped && !current.shipped) required.set(id, {
-			id,
-			shipped,
-			hooked: hooked || current?.hooked
-		});
-	};
-	for (const [id, moduleId] of hookedIds) add(id, absorbing.has(moduleId), true);
-	add(MARKLESS_EXECUTION_LOG_MODULE_ID, false);
-	for (const id of EXECUTION_LOG_DISPATCH_MODULE_IDS) add(id, false);
-	for (const module of metadata.modules) for (const symbol of module.symbols) add(stripResolvedIdMarker(symbol.virtualModuleId), !!symbol.fileName);
-	return [...required.values()];
-}
-function absorbingChunkIndex(bundle) {
-	const index = /* @__PURE__ */ new Map();
-	for (const item of Object.values(bundle)) {
-		if (item.type !== "chunk") continue;
-		for (const raw of [...item.moduleIds, item.facadeModuleId ?? ""]) {
-			if (!raw) continue;
-			const id = stripResolvedIdMarker(raw);
-			if (!index.has(id)) index.set(id, item);
-			const logId = workspaceModuleLogId(id);
-			if (logId && !index.has(logId)) index.set(logId, item);
-		}
-	}
-	return index;
-}
-function workspaceModuleLogId(path) {
-	const match = path.match(/[/\\]([a-z0-9-]+)[/\\]src[/\\]([^?#]+)\.ts$/);
-	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : null;
-}
-function chunkModuleLogId(id) {
-	const path = stripResolvedIdMarker(id);
-	if (path === "virtual:markless:dev-log") return path;
-	const match = path.match(/[/\\](web|runtime|serializer)[/\\]src[/\\]([^?#]+)\.ts$/);
-	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : null;
-}
-function stripResolvedIdMarker(id) {
-	return id.startsWith("\0") ? id.slice(1) : id;
-}
-async function gzipByteLength(code) {
-	const encoded = new TextEncoder().encode(code);
-	const reader = new ReadableStream({ start(controller) {
-		controller.enqueue(encoded);
-		controller.close();
-	} }).pipeThrough(new CompressionStream("gzip")).getReader();
-	let total = 0;
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		total += value.byteLength;
-	}
-	return total;
-}
-function sortRecord(record) {
-	const next = {};
-	for (const key of Object.keys(record).sort()) next[key] = record[key];
-	return next;
-}
-function sortNestedRecord(record) {
-	const next = {};
-	for (const key of Object.keys(record).sort()) next[key] = sortRecord({ ...record[key] });
-	return next;
-}
-//#endregion
-//#region src/build/preload-cleanup.ts
-function stripEmptyVitePreloadWrappers(code) {
-	return stripImportedVitePreloadHelper(stripUnusedVitePreloadHelper(stripAsyncEmptyPreloadWrappers(stripDirectEmptyPreloadWrappers(code))));
-}
-const IMPORT_DECLARATION_CANDIDATE_RE = /\bimport\s*\{[\s\S]*?\}\s*from\s*["'][^"']+["'];?/g;
-function stripDirectEmptyPreloadWrappers(code) {
-	let next = "";
-	let cursor = 0;
-	let changed = false;
-	const wrapperRE = /\b[$A-Z_a-z][$\w]*\(\(\)\s*=>\s*/g;
-	for (let match = wrapperRE.exec(code); match; match = wrapperRE.exec(code)) {
-		const callStart = match.index;
-		const bodyStart = match.index + match[0].length;
-		if (!code.startsWith("import(", bodyStart)) continue;
-		const wrapper = findEmptyPreloadWrapper(code, callStart, bodyStart);
-		if (!wrapper) continue;
-		next += code.slice(cursor, callStart);
-		next += code.slice(bodyStart, wrapper.firstArgumentEnd);
-		cursor = wrapper.callEnd + 1;
-		wrapperRE.lastIndex = cursor;
-		changed = true;
-	}
-	if (!changed) return code;
-	return next + code.slice(cursor);
-}
-function stripAsyncEmptyPreloadWrappers(code) {
-	let next = "";
-	let cursor = 0;
-	let changed = false;
-	const wrapperRE = /\b[$A-Z_a-z][$\w]*\(\s*async\s*\(\)\s*=>\s*\{/g;
-	for (let match = wrapperRE.exec(code); match; match = wrapperRE.exec(code)) {
-		const callStart = match.index;
-		const callOpen = code.indexOf("(", callStart);
-		if (callOpen < 0) continue;
-		const firstArgumentEnd = findTopLevelComma(code, callOpen + 1);
-		if (firstArgumentEnd < 0) continue;
-		const wrapper = findEmptyPreloadWrapper(code, callStart, callOpen + 1);
-		if (!wrapper) continue;
-		const loader = code.slice(callOpen + 1, firstArgumentEnd);
-		next += code.slice(cursor, callStart);
-		next += `(${loader})()`;
-		cursor = wrapper.callEnd + 1;
-		wrapperRE.lastIndex = cursor;
-		changed = true;
-	}
-	if (!changed) return code;
-	return next + code.slice(cursor);
-}
-function findEmptyPreloadWrapper(code, callStart, bodyStart) {
-	const callOpen = code.indexOf("(", callStart);
-	if (callOpen < 0 || callOpen >= bodyStart) return void 0;
-	const firstArgumentEnd = findTopLevelComma(code, callOpen + 1);
-	if (firstArgumentEnd < 0) return void 0;
-	let cursor = skipSpaces(code, firstArgumentEnd + 1);
-	if (code[cursor] !== "[" || code[cursor + 1] !== "]") return void 0;
-	cursor = skipSpaces(code, cursor + 2);
-	if (code[cursor] === ")") return {
-		firstArgumentEnd,
-		callEnd: cursor
-	};
-	if (code[cursor] !== ",") return void 0;
-	cursor = skipSpaces(code, cursor + 1);
-	if (!code.startsWith("import.meta.url", cursor)) return void 0;
-	cursor = skipSpaces(code, cursor + 15);
-	if (code[cursor] !== ")") return void 0;
-	return {
-		firstArgumentEnd,
-		callEnd: cursor
-	};
-}
-function findTopLevelComma(code, start) {
-	let depth = 1;
-	let quote = null;
-	let escaped = false;
-	for (let index = start; index < code.length; index++) {
-		const char = code[index];
-		if (quote) {
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\") {
-				escaped = true;
-				continue;
-			}
-			if (char === quote) quote = null;
-			continue;
-		}
-		if (char === "\"" || char === "'" || char === "`") {
-			quote = char;
-			continue;
-		}
-		if (char === "(" || char === "[" || char === "{") {
-			depth++;
-			continue;
-		}
-		if (char === ")" || char === "]" || char === "}") {
-			depth--;
-			if (depth === 0) return -1;
-			continue;
-		}
-		if (char === "," && depth === 1) return index;
-	}
-	return -1;
-}
-function skipSpaces(code, start) {
-	let cursor = start;
-	while (/\s/.test(code[cursor] ?? "")) cursor++;
-	return cursor;
-}
-function stripImportedVitePreloadHelper(code) {
-	const helper = findImportedVitePreloadHelper(code);
-	if (!helper) return code;
-	const withoutImport = code.slice(0, helper.importStart) + code.slice(helper.importEnd);
-	if (hasCallableReference(withoutImport, helper.preloadFunction)) return code;
-	const initCall = `${escapeRegExp$1(helper.initFunction)}\\(\\)`;
-	return withoutImport.replace(new RegExp(String.raw`,${initCall},`, "g"), ",").replace(new RegExp(String.raw`\{${initCall},`, "g"), "{").replace(new RegExp(String.raw`,${initCall},`, "g"), ",").replace(new RegExp(String.raw`,${initCall}\}`, "g"), "}").replace(new RegExp(String.raw`\{${initCall}\}`, "g"), "{}");
-}
-function findImportedVitePreloadHelper(code) {
-	for (const match of code.matchAll(IMPORT_DECLARATION_CANDIDATE_RE)) {
-		const importStart = match.index ?? -1;
-		if (importStart < 0) continue;
-		const statement = match[0];
-		const declaration = asNodes(tryParseJavaScriptModule(statement)?.body).find((node) => node.type === "ImportDeclaration");
-		if (!declaration) continue;
-		let preloadFunction;
-		let initFunction;
-		for (const specifier of asNodes(declaration.specifiers)) {
-			if (specifier.type !== "ImportSpecifier") continue;
-			const imported = identifierName(specifier.imported);
-			const local = identifierName(specifier.local);
-			if (!imported || !local) continue;
-			if (imported === "__vitePreload") preloadFunction = local;
-			if (imported === "init_preload_helper") initFunction = local;
-		}
-		if (preloadFunction && initFunction) return {
-			importStart,
-			importEnd: importStart + statement.length,
-			preloadFunction,
-			initFunction
-		};
-	}
-}
-function stripUnusedVitePreloadHelper(code) {
-	const marker = code.indexOf("vite:preloadError");
-	if (marker < 0) return code;
-	const helper = findVitePreloadHelperModule(code, marker);
-	if (!helper) return code;
-	const statementEnd = code[helper.removeStart] === "," && code[helper.removeEnd - 1] === ";" ? ";" : "";
-	const outsideHelper = code.slice(0, helper.removeStart) + statementEnd + code.slice(helper.removeEnd);
-	if (hasCallableReference(outsideHelper, helper.preloadFunction)) return code;
-	let withoutHelper = outsideHelper;
-	const chain = findVitePreloadHelperInitChain(withoutHelper, helper.moduleVariable);
-	if (chain) withoutHelper = removeInitCall(withoutHelper.slice(0, chain.removeStart) + withoutHelper.slice(chain.removeEnd), chain.entryVariable);
-	return removeInitCall(withoutHelper, helper.moduleVariable);
-}
-function findVitePreloadHelperModule(code, marker) {
-	const initStart = code.lastIndexOf("=e((()=>{", marker);
-	if (initStart < 0) return void 0;
-	const moduleVariable = readIdentifierBefore(code, initStart);
-	if (!moduleVariable) return void 0;
-	const bodyStart = initStart + 9;
-	const bodyEnd = findModuleInitEnd(code, initStart);
-	if (bodyEnd < 0) return void 0;
-	const helperBody = code.slice(bodyStart, bodyEnd);
-	const preloadFunction = helperBody.match(/,([$A-Z_a-z][$\w]*)=function\([^)]*\)\{let\s+[$A-Z_a-z][$\w]*=Promise\.resolve\(\)/)?.[1];
-	if (!preloadFunction) return void 0;
-	const firstHelperVariable = helperBody.match(/^([$A-Z_a-z][$\w]*)=/)?.[1];
-	if (!firstHelperVariable) return void 0;
-	const removeStart = findHelperDeclarationStart(code, initStart, firstHelperVariable);
-	if (removeStart < 0) return void 0;
-	return {
-		moduleVariable,
-		preloadFunction,
-		removeStart,
-		removeEnd: bodyEnd + 4
-	};
-}
-function findVitePreloadHelperInitChain(code, moduleVariable) {
-	const match = new RegExp(`var\\s+([$A-Z_a-z][$\\w]*)=e\\(\\(\\(\\)=>\\{${escapeRegExp$1(moduleVariable)}\\(\\)\\}\\)\\),([$A-Z_a-z][$\\w]*)=e\\(\\(\\(\\)=>\\{\\1\\(\\)\\}\\)\\);`).exec(code);
-	if (!match) return void 0;
-	return {
-		entryVariable: match[2],
-		removeStart: match.index,
-		removeEnd: match.index + match[0].length
-	};
-}
-function removeInitCall(code, entryVariable) {
-	return code.replace(new RegExp(`,${escapeRegExp$1(entryVariable)}\\(\\)`), "").replace(new RegExp(`${escapeRegExp$1(entryVariable)}\\(\\),`), "").replace(new RegExp(`\\{${escapeRegExp$1(entryVariable)}\\(\\)\\}`), "{}");
-}
-function readIdentifierBefore(code, index) {
-	let end = index;
-	while (/\s/.test(code[end - 1] ?? "")) end--;
-	let start = end;
-	while (/[$\w]/.test(code[start - 1] ?? "")) start--;
-	const value = code.slice(start, end);
-	return /^[$A-Z_a-z][$\w]*$/.test(value) ? value : void 0;
-}
-function findModuleInitEnd(code, initStart) {
-	return code.indexOf("}));", initStart);
-}
-function findHelperDeclarationStart(code, initStart, firstHelperVariable) {
-	const commaStart = code.lastIndexOf(`,${firstHelperVariable},`, initStart);
-	if (commaStart >= 0) return commaStart;
-	const varStart = code.lastIndexOf(`var ${firstHelperVariable},`, initStart);
-	if (varStart >= 0) return varStart;
-	return -1;
-}
-function escapeRegExp$1(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function hasCallableReference(code, name) {
-	const ast = tryParseJavaScriptModule(code);
-	if (!ast) return true;
-	let found = false;
-	walkReferenceScopes(ast, [], (node, scopes) => {
-		if (node.type !== "CallExpression") return;
-		const callee = node.callee;
-		if (identifierName(callee) !== name) return;
-		if (isDeclaredInScope(name, scopes)) return;
-		found = true;
-	});
-	return found;
-}
-function walkReferenceScopes(node, scopes, visit) {
-	if (!node || typeof node !== "object") return;
-	if (node.type === "Program") {
-		const scope = collectScopeDeclarations(asNodes(node.body));
-		visit(node, [scope]);
-		for (const child of asNodes(node.body)) walkReferenceScopes(child, [scope], visit);
-		return;
-	}
-	if (isFunctionNode(node)) {
-		const scope = /* @__PURE__ */ new Set();
-		collectBindingNames(node.id, scope);
-		for (const parameter of asNodes(node.params)) collectBindingNames(parameter, scope);
-		const nextScopes = [...scopes, scope];
-		visit(node, nextScopes);
-		walkReferenceScopes(node.body, nextScopes, visit);
-		return;
-	}
-	if (node.type === "BlockStatement") {
-		const scope = collectScopeDeclarations(asNodes(node.body));
-		const nextScopes = [...scopes, scope];
-		visit(node, nextScopes);
-		for (const child of asNodes(node.body)) walkReferenceScopes(child, nextScopes, visit);
-		return;
-	}
-	visit(node, scopes);
-	for (const child of childNodes(node)) walkReferenceScopes(child, scopes, visit);
-}
-function collectScopeDeclarations(nodes) {
-	const declarations = /* @__PURE__ */ new Set();
-	for (const node of nodes) {
-		if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
-			collectBindingNames(node.id, declarations);
-			continue;
-		}
-		if (node.type === "ImportDeclaration") {
-			for (const specifier of asNodes(node.specifiers)) collectBindingNames(specifier.local, declarations);
-			continue;
-		}
-		if (node.type === "VariableDeclaration") for (const declaration of asNodes(node.declarations)) collectBindingNames(declaration.id, declarations);
-	}
-	return declarations;
-}
-function collectBindingNames(node, names) {
-	if (!node) return;
-	const name = identifierName(node);
-	if (name) {
-		names.add(name);
-		return;
-	}
-	for (const child of childNodes(node)) collectBindingNames(child, names);
-}
-function isDeclaredInScope(name, scopes) {
-	return scopes.some((scope) => scope.has(name));
-}
-function isFunctionNode(node) {
-	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
-}
-function tryParseJavaScriptModule(code) {
-	try {
-		return parseJavaScriptModule(code);
-	} catch {
-		return;
-	}
-}
-function childNodes(node) {
-	const children = [];
-	for (const [key, value] of Object.entries(node)) {
-		if (ignoredAstKeys.has(key)) continue;
-		if (Array.isArray(value)) {
-			for (const item of value) if (isAstNode(item)) children.push(item);
-			continue;
-		}
-		if (isAstNode(value)) children.push(value);
-	}
-	return children;
-}
-function asNodes(value) {
-	return Array.isArray(value) ? value.filter(isAstNode) : [];
-}
-function isAstNode(value) {
-	return typeof value === "object" && value !== null && typeof value.type === "string";
-}
-function identifierName(node) {
-	return node?.type === "Identifier" && typeof node.name === "string" ? node.name : void 0;
-}
-const ignoredAstKeys = new Set([
-	"closingElement",
-	"id",
-	"leadingComments",
-	"loc",
-	"metadata",
-	"openingElement",
-	"parent",
-	"range",
-	"trailingComments"
-]);
-//#endregion
-//#region src/build/symbol-facade-cleanup.ts
-const TSRX_SOURCE_FILE = /\.tsrx(?:[?#].*)?$/;
-const SYMBOL_INIT_EXPORT_PREFIX = "init__virtual_markless_symbol";
-const STRING_LITERAL_SOURCE = String.raw`(?:"[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*'|` + "`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`)";
-const FUNCTION_DECLARATION_RE = /\bfunction\s+([$A-Z_a-z][$\w]*)\s*\(\s*([$A-Z_a-z][$\w]*)\s*\)\s*\{/g;
-const LOCAL_DYNAMIC_IMPORT_HELPER_RE = /import\(\s*(["'`])([^"'`]+)\1\s*\)\.then\(\s*\(?\s*([$A-Z_a-z][$\w]*)\s*\)?\s*=>\s*([$A-Z_a-z][$\w]*)\(\s*\3\s*,\s*(["'`])([^"'`]*)\5\s*\)\s*\)/g;
-const LOCAL_DYNAMIC_IMPORT_RE = /import\(\s*(["'`])([^"'`]+)\1\s*\)(?:\.then\(\s*\(?\s*([$A-Z_a-z][$\w]*)\s*\)?\s*=>\s*\3\.([$A-Z_a-z][$\w]*)\s*\))?/g;
-function rewriteGeneratedSymbolFacadeImports(bundle) {
-	const chunks = collectChunks(bundle);
-	const rewrites = findSymbolFacadeRewrites(chunks);
-	const removedFacades = /* @__PURE__ */ new Set();
-	if (rewrites.size === 0) return removedFacades;
-	for (const chunk of chunks.values()) {
-		if (!isGeneratedAsyncChunk(chunk)) continue;
-		const result = rewriteDynamicImportSpecifiers(chunk, rewrites);
-		chunk.code = result.code;
-		chunk.dynamicImports = unique(chunk.dynamicImports.map((fileName) => result.rewrittenFacades.has(fileName) ? rewrites.get(fileName)?.target.fileName ?? fileName : fileName));
-	}
-	for (const rewrite of rewrites.values()) {
-		const facadeId = rewrite.facade.facadeModuleId;
-		if (facadeId && !rewrite.target.moduleIds.includes(facadeId)) rewrite.target.moduleIds = [...rewrite.target.moduleIds, facadeId];
-	}
-	for (const rewrite of rewrites.values()) {
-		deleteBundleChunk(bundle, rewrite.facade.fileName);
-		chunks.delete(rewrite.facade.fileName);
-		removedFacades.add(rewrite.facade.fileName);
-	}
-	return removedFacades;
-}
-function rewriteGeneratedSymbolInitExports(bundle) {
-	const chunks = collectChunks(bundle);
-	const rewrites = findSymbolInitExportRewrites(chunks);
-	if (rewrites.length === 0) return { renamed: 0 };
-	const replacements = /* @__PURE__ */ new Map();
-	for (const rewrite of rewrites) {
-		rewrite.chunk.exports = rewrite.collapsed ? [...rewrite.collapsed.exports] : rewrite.chunk.exports.map((name) => rewrite.names.get(name) ?? name);
-		if (rewrite.collapsed) rewrite.chunk.code = rewrite.collapsed.code;
-		for (const [from, to] of rewrite.names) replacements.set(from, to);
-	}
-	for (const chunk of chunks.values()) {
-		if (!isGeneratedAsyncChunk(chunk)) continue;
-		chunk.code = replaceIdentifierNames(chunk.code, replacements);
-	}
-	return { renamed: replacements.size };
-}
-function compactGeneratedDirectSymbolLoaders(bundle) {
-	let compacted = 0;
-	for (const chunk of collectChunks(bundle).values()) {
-		if (!isGeneratedAsyncChunk(chunk)) continue;
-		if (!chunk.code.includes("?import(")) continue;
-		const result = compactDirectSymbolLoadersInCode(chunk.code);
-		if (result.compacted === 0) continue;
-		chunk.code = result.code;
-		compacted += result.compacted;
-	}
-	return { compacted };
-}
-function collectChunks(bundle) {
-	const chunks = /* @__PURE__ */ new Map();
-	for (const output of Object.values(bundle)) if (isGeneratedChunk(output)) chunks.set(output.fileName, output);
-	return chunks;
-}
-function findSymbolFacadeRewrites(chunks) {
-	const rewrites = /* @__PURE__ */ new Map();
-	for (const chunk of chunks.values()) {
-		const rewrite = findSymbolFacadeRewrite(chunk, chunks);
-		if (rewrite) rewrites.set(chunk.fileName, rewrite);
-	}
-	return rewrites;
-}
-function findSymbolInitExportRewrites(chunks) {
-	const rewrites = [];
-	for (const chunk of chunks.values()) {
-		const rewrite = findSymbolInitExportRewrite(chunk);
-		if (rewrite) rewrites.push(rewrite);
-	}
-	return rewrites;
-}
-function findSymbolInitExportRewrite(chunk) {
-	if (!isGeneratedAsyncChunk(chunk)) return void 0;
-	const initExports = chunk.exports.filter(isGeneratedSymbolInitExport);
-	if (initExports.length === 0) return void 0;
-	const names = /* @__PURE__ */ new Map();
-	const used = new Set(chunk.exports.filter((name) => !isGeneratedSymbolInitExport(name)));
-	const collapsed = collapseGeneratedSymbolInitExports(chunk.code, initExports);
-	if (collapsed) {
-		for (const name of initExports) if (name !== SYMBOL_INIT_EXPORT_PREFIX) names.set(name, SYMBOL_INIT_EXPORT_PREFIX);
-		return {
-			chunk,
-			names,
-			collapsed
-		};
-	}
-	for (const name of initExports) {
-		const next = compactSymbolInitExportName(name, used);
-		used.add(next);
-		if (next !== name) names.set(name, next);
-	}
-	return names.size > 0 ? {
-		chunk,
-		names
-	} : void 0;
-}
-function findSymbolFacadeRewrite(chunk, chunks) {
-	if (!isGeneratedSymbolFacade(chunk)) return void 0;
-	if (chunk.imports.length !== 1 || chunk.dynamicImports.length > 0) return void 0;
-	const parsed = parseSymbolFacade(chunk.code);
-	if (!parsed) return void 0;
-	const target = chunks.get(chunk.imports[0]);
-	if (!target) return void 0;
-	const targetExports = new Set(target.exports);
-	if (!chunk.exports.every((name) => targetExports.has(name))) return void 0;
-	if (!parsed.initExports.every((name) => targetExports.has(name))) return void 0;
-	return {
-		facade: chunk,
-		target,
-		initExports: parsed.initExports
-	};
-}
-function isGeneratedSymbolFacade(chunk) {
-	return (chunk.facadeModuleId ? normalizeVirtualId(chunk.facadeModuleId) : "").startsWith(`${MARKLESS_VIRTUAL_PREFIX}symbol:`);
-}
-function isGeneratedSymbolInitExport(name) {
-	return name === SYMBOL_INIT_EXPORT_PREFIX || name.startsWith(`${SYMBOL_INIT_EXPORT_PREFIX}_`) || /^\$\d+$/.test(name.slice(29));
-}
-function compactSymbolInitExportName(name, used) {
-	const suffix = name.match(/\$(\d+)$/)?.[1];
-	let candidate = suffix ? `${SYMBOL_INIT_EXPORT_PREFIX}$${suffix}` : SYMBOL_INIT_EXPORT_PREFIX;
-	let nextSuffix = suffix ? Number(suffix) : 0;
-	while (used.has(candidate)) {
-		nextSuffix++;
-		candidate = `${SYMBOL_INIT_EXPORT_PREFIX}$${nextSuffix}`;
-	}
-	return candidate;
-}
-function collapseGeneratedSymbolInitExports(code, initExports) {
-	if (initExports.length < 2) return void 0;
-	const match = code.match(/export\s*\{\s*([^}]*)\s*\}\s*;?\s*$/);
-	if (!match || match.index === void 0) return void 0;
-	const specifiers = parseExportSpecifiers(match[1]);
-	if (!specifiers) return void 0;
-	if (specifiers.some((specifier) => !isIdentifier(specifier.local))) return void 0;
-	const initExportSet = new Set(initExports);
-	const initLocals = unique(specifiers.filter((specifier) => initExportSet.has(specifier.exported)).map((specifier) => specifier.local));
-	if (initLocals.length < 2) return void 0;
-	const nonInitSpecifiers = specifiers.filter((specifier) => !initExportSet.has(specifier.exported));
-	if (nonInitSpecifiers.some((specifier) => specifier.exported === SYMBOL_INIT_EXPORT_PREFIX)) return;
-	const initLocal = uniqueIdentifier("$i", code);
-	return {
-		code: `${code.slice(0, match.index)}function ${initLocal}(){${initLocals.map((local) => `${local}()`).join(";")}}export{${[`${initLocal} as ${SYMBOL_INIT_EXPORT_PREFIX}`, ...nonInitSpecifiers.map(formatExportSpecifier)].join(",")}};`,
-		exports: [SYMBOL_INIT_EXPORT_PREFIX, ...nonInitSpecifiers.map((specifier) => specifier.exported)]
-	};
-}
-function rewriteDynamicImportSpecifiers(chunk, rewrites) {
-	const rewrittenFacades = /* @__PURE__ */ new Set();
-	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 rewrite = rewrites.get(importedFileName);
-			if (!rewrite) return match;
-			if (!rewrite.target.exports.includes(exportName)) return match;
-			const nextSpecifier = relativeChunkSpecifier(chunk.fileName, rewrite.target.fileName);
-			rewrittenFacades.add(importedFileName);
-			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 rewrite = rewrites.get(importedFileName);
-			if (!rewrite) return match;
-			if (rewrite.initExports.length > 0 && (!parameter || !exportName)) return match;
-			const nextSpecifier = relativeChunkSpecifier(chunk.fileName, rewrite.target.fileName);
-			rewrittenFacades.add(importedFileName);
-			const nextImport = `import(${quote}${nextSpecifier}${quote})`;
-			if (!parameter || !exportName || rewrite.initExports.length === 0) return nextImport;
-			return `${nextImport}.then(${parameter}=>(${[...rewrite.initExports.map((name) => `${parameter}.${name}()`), `${parameter}.${exportName}`].join(",")}))`;
-		}),
-		rewrittenFacades
-	};
-}
-function compactDirectSymbolLoadersInCode(code) {
-	let next = "";
-	let cursor = 0;
-	let compacted = 0;
-	for (let match = FUNCTION_DECLARATION_RE.exec(code); match; match = FUNCTION_DECLARATION_RE.exec(code)) {
-		const functionStart = match.index;
-		const bodyStart = FUNCTION_DECLARATION_RE.lastIndex;
-		const bodyEnd = findBlockEnd(code, bodyStart - 1);
-		if (bodyEnd < 0) continue;
-		const body = code.slice(bodyStart, bodyEnd);
-		const mapName = uniqueIdentifier("$s", `${code}${next}`);
-		const moduleCacheName = uniqueIdentifier("$m", `${code}${next}${mapName}`);
-		const replacement = compactDirectSymbolLoaderFunction({
-			functionName: match[1],
-			parameterName: match[2],
-			body,
-			mapName,
-			moduleCacheName
-		});
-		if (!replacement) {
-			FUNCTION_DECLARATION_RE.lastIndex = bodyEnd + 1;
-			continue;
-		}
-		next += code.slice(cursor, functionStart);
-		next += replacement;
-		cursor = bodyEnd + 1;
-		compacted++;
-		FUNCTION_DECLARATION_RE.lastIndex = cursor;
-	}
-	if (compacted === 0) return {
-		code,
-		compacted
-	};
-	return {
-		code: next + code.slice(cursor),
-		compacted
-	};
-}
-function compactDirectSymbolLoaderFunction(input) {
-	const returnSource = input.body.trim();
-	if (!returnSource.startsWith("return ")) return void 0;
-	const parsed = parseDirectSymbolLoaderBranches(returnSource.slice(7), input.parameterName);
-	if (!parsed) return void 0;
-	const first = parsed.branches[0];
-	if (parsed.branches.some((branch) => branch.importSpecifier !== first.importSpecifier || branch.helperName !== first.helperName)) return;
-	const generatedCount = generatedSymbolRangeCount(parsed.branches);
-	if (generatedCount !== void 0) return [
-		`let ${input.moduleCacheName};`,
-		`function ${input.functionName}(${input.parameterName}){`,
-		`let t=+${input.parameterName}.slice(7);`,
-		`if(${input.parameterName}===\`symbol:\${t}\`&&t>=0&&t<${generatedCount}){`,
-		`if(${input.moduleCacheName})return ${first.helperName}(${input.moduleCacheName},\`symbol_\${t}\`);`,
-		`return import(${JSON.stringify(first.importSpecifier)})`,
-		`.then(${first.moduleParameter}=>(${input.moduleCacheName}=${first.moduleParameter},${first.helperName}(${first.moduleParameter},\`symbol_\${t}\`)))`,
-		`}`,
-		`return ${parsed.fallback}`,
-		"}"
-	].join("");
-	const exportVariable = input.parameterName === "t" ? "n" : "t";
-	const mapEntries = parsed.branches.map((branch) => `${JSON.stringify(branch.symbolId)}:${JSON.stringify(branch.exportName)}`).join(",");
-	return [
-		`const ${input.mapName}={${mapEntries}};`,
-		`let ${input.moduleCacheName};`,
-		`function ${input.functionName}(${input.parameterName}){`,
-		`let ${exportVariable}=${input.mapName}[${input.parameterName}];`,
-		`if(${exportVariable}){`,
-		`if(${input.moduleCacheName})return ${first.helperName}(${input.moduleCacheName},${exportVariable});`,
-		`return import(${JSON.stringify(first.importSpecifier)})`,
-		`.then(${first.moduleParameter}=>(${input.moduleCacheName}=${first.moduleParameter},${first.helperName}(${first.moduleParameter},${exportVariable})))`,
-		`}`,
-		`return ${parsed.fallback}`,
-		"}"
-	].join("");
-}
-function parseDirectSymbolLoaderBranches(source, parameterName) {
-	const branches = [];
-	const branchRE = directSymbolLoaderBranchRE(parameterName);
-	let cursor = 0;
-	while (cursor < source.length) {
-		const match = source.slice(cursor).match(branchRE);
-		if (!match) break;
-		const symbolId = simpleStringLiteralValue(match[1]);
-		const importSpecifier = simpleStringLiteralValue(match[2]);
-		const moduleParameter = match[3];
-		const helperName = match[4];
-		const helperArgument = match[5];
-		const exportName = simpleStringLiteralValue(match[6]);
-		if (symbolId === void 0 || importSpecifier === void 0 || exportName === void 0 || moduleParameter !== helperArgument) return;
-		branches.push({
-			symbolId,
-			importSpecifier,
-			moduleParameter,
-			helperName,
-			exportName
-		});
-		cursor += match[0].length;
-	}
-	const fallback = source.slice(cursor);
-	if (branches.length < 2 || !fallback.startsWith("Promise.reject(")) return void 0;
-	return {
-		branches,
-		fallback
-	};
-}
-function generatedSymbolRangeCount(branches) {
-	for (const [index, branch] of branches.entries()) if (branch.symbolId !== `symbol:${index}` || branch.exportName !== `symbol_${index}`) return;
-	return branches.length;
-}
-function directSymbolLoaderBranchRE(parameterName) {
-	return new RegExp(`^${escapeRegExp(parameterName)}\\s*===\\s*(${STRING_LITERAL_SOURCE})\\s*\\?\\s*import\\(\\s*(${STRING_LITERAL_SOURCE})\\s*\\)\\.then\\(\\s*\\(?\\s*([$A-Z_a-z][$\\w]*)\\s*\\)?\\s*=>\\s*([$A-Z_a-z][$\\w]*)\\(\\s*([$A-Z_a-z][$\\w]*)\\s*,\\s*(${STRING_LITERAL_SOURCE})\\s*\\)\\s*\\)\\s*:`);
-}
-function simpleStringLiteralValue(source) {
-	const quote = source[0];
-	if (quote !== "\"" && quote !== "'" && quote !== "`" || source[source.length - 1] !== quote) return;
-	return source.slice(1, -1);
-}
-function findBlockEnd(code, open) {
-	let depth = 0;
-	let quote = null;
-	let escaped = false;
-	for (let index = open; index < code.length; index++) {
-		const char = code[index];
-		if (quote) {
-			if (escaped) {
-				escaped = false;
-				continue;
-			}
-			if (char === "\\") {
-				escaped = true;
-				continue;
-			}
-			if (char === quote) quote = null;
-			continue;
-		}
-		if (char === "\"" || char === "'" || char === "`") {
-			quote = char;
-			continue;
-		}
-		if (char === "{") {
-			depth++;
-			continue;
-		}
-		if (char === "}") {
-			depth--;
-			if (depth === 0) return index;
-		}
-	}
-	return -1;
-}
-function resolveChunkSpecifier(importerFileName, specifier) {
-	return normalize(join(dirname(importerFileName), specifier));
-}
-function relativeChunkSpecifier(importerFileName, targetFileName) {
-	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
-	return value.startsWith(".") ? value : `./${value}`;
-}
-function isGeneratedAsyncChunk(chunk) {
-	return chunk.moduleIds.some((id) => {
-		return normalizeVirtualId(id).startsWith("virtual:markless:") || TSRX_SOURCE_FILE.test(id);
-	});
-}
-function deleteBundleChunk(bundle, fileName) {
-	for (const [key, output] of Object.entries(bundle)) if (isGeneratedChunk(output) && output.fileName === fileName) delete bundle[key];
-}
-function isGeneratedChunk(value) {
-	if (!value || typeof value !== "object") return false;
-	const chunk = value;
-	return chunk.type === "chunk" && typeof chunk.fileName === "string" && typeof chunk.code === "string" && Array.isArray(chunk.exports) && Array.isArray(chunk.imports) && Array.isArray(chunk.dynamicImports) && Array.isArray(chunk.moduleIds);
-}
-function unique(values) {
-	return [...new Set(values)];
-}
-function replaceIdentifierNames(code, replacements) {
-	const names = [...replacements.keys()].sort((a, b) => b.length - a.length);
-	let next = code;
-	for (const name of names) next = next.replace(identifierNameRE(name), replacements.get(name));
-	return next;
-}
-function identifierNameRE(name) {
-	return new RegExp(`(?<![$\\w])${escapeRegExp(name)}(?![$\\w])`, "g");
-}
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function isLocalSpecifier(specifier) {
-	return specifier.startsWith("./") || specifier.startsWith("../");
-}
-function parseSymbolFacade(code) {
-	const match = code.trim().match(/^import\s*\{\s*([^}]*)\s*\}\s*from\s*(["'`])([^"'`]+)\2\s*;\s*([\s\S]*?)\s*export\s*\{\s*([^}]*)\s*\}\s*;?\s*$/);
-	if (!match) return void 0;
-	const imports = parseImportSpecifiers(match[1]);
-	const exportLocals = parseExportLocalNames(match[5]);
-	if (!imports || !exportLocals) return void 0;
-	const body = match[4].trim();
-	const initLocals = body ? body.split(";").map((statement) => statement.trim()).filter(Boolean).map((statement) => statement.match(/^([$A-Z_a-z][$\w]*)\(\)$/)?.[1]) : [];
-	if (initLocals.some((name) => !name)) return void 0;
-	for (const local of exportLocals) if (!imports.has(local)) return void 0;
-	return { initExports: unique(initLocals.filter((local) => !!local).map((local) => imports.get(local)).filter((name) => !!name)) };
-}
-function parseImportSpecifiers(value) {
-	const imports = /* @__PURE__ */ new Map();
-	for (const part of value.split(",")) {
-		const specifier = part.trim();
-		if (!specifier) continue;
-		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
-		const imported = (aliased?.[1] ?? specifier).trim();
-		const local = (aliased?.[2] ?? specifier).trim();
-		if (!isIdentifier(imported) || !isIdentifier(local)) return void 0;
-		imports.set(local, imported);
-	}
-	return imports;
-}
-function parseExportLocalNames(value) {
-	const locals = [];
-	for (const part of value.split(",")) {
-		const specifier = part.trim();
-		if (!specifier) continue;
-		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
-		const local = (aliased?.[1] ?? specifier).trim();
-		const exported = (aliased?.[2] ?? specifier).trim();
-		if (!isIdentifier(local) || !isIdentifier(exported)) return void 0;
-		locals.push(local);
-	}
-	return locals;
-}
-function parseExportSpecifiers(value) {
-	const specifiers = [];
-	for (const part of value.split(",")) {
-		const specifier = part.trim();
-		if (!specifier) continue;
-		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
-		const local = (aliased?.[1] ?? specifier).trim();
-		const exported = (aliased?.[2] ?? specifier).trim();
-		if (!isIdentifier(local) || !isIdentifier(exported)) return void 0;
-		specifiers.push({
-			local,
-			exported
-		});
-	}
-	return specifiers;
-}
-function formatExportSpecifier(specifier) {
-	return specifier.local === specifier.exported ? specifier.local : `${specifier.local} as ${specifier.exported}`;
-}
-function uniqueIdentifier(base, code) {
-	let candidate = base;
-	let index = 0;
-	while (identifierNameRE(candidate).test(code)) {
-		index++;
-		candidate = `${base}${index}`;
-	}
-	return candidate;
-}
-function isIdentifier(value) {
-	return /^[$A-Z_a-z][$\w]*$/.test(value);
-}
-function normalizeVirtualId(id) {
-	return id.startsWith("\0") ? id.slice(1) : id;
-}
-//#endregion
-//#region src/build/bundle-finalize.ts
-async function finalizeBundle(context, bundle, input) {
-	const { options, moduleMetadata } = input;
-	recordProductionResumeModuleUrls(bundle, options.productionResumeModuleUrls, options.publicPath);
-	if (options.prerenderWakeChannel === true) {
-		recordProductionPrerenderWakeModuleUrls(bundle, options.productionPrerenderWakeModuleUrls, options.publicPath);
-		recordProductionSettleModuleUrls(bundle, options.productionSettleModuleUrls ??= /* @__PURE__ */ new Map(), options.publicPath);
-	}
-	stripEmptyPreloadWrappersFromChunks(bundle);
-	const removedSymbolFacades = rewriteGeneratedSymbolFacadeImports(bundle);
-	rewriteGeneratedSymbolInitExports(bundle);
-	compactGeneratedDirectSymbolLoaders(bundle);
-	const manifestBundle = bundleWithoutRemovedChunks(bundle, removedSymbolFacades);
-	const tableRewrite = rewriteGeneratedSymbolTableUrls(manifestBundle);
-	if (tableRewrite.unresolved.length > 0) context.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 emittedSymbolClaims = moduleMetadata.emittedSymbolClaimMap(emittedBundleModuleIds(manifestBundle));
-	const attributionClaims = [...moduleMetadata.symbolClaimManifests()];
-	const tableIntegrity = verifyGeneratedSymbolTableRoutes(manifestBundle, emittedSymbolClaims.values());
-	if (tableIntegrity.errors.length > 0) context.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, emittedSymbolClaims.values(), input.root, {
-		bundleGraphAsset: MARKLESS_BUNDLE_GRAPH,
-		bundleGraphAdders: options.bundleGraphAdders,
-		canonPath: stripBuildPrefix,
-		publicPath: options.publicPath,
-		injections: options.devInjections
-	});
-	const executionLogInjection = executionLogActivationInjection(options.executionLog);
-	if (executionLogInjection) injectHeadLinks(bundle, [executionLogInjection]);
-	injectHeadLinks(bundle, collectModulePreloadInjections(clientManifest, {
-		publicPath: options.publicPath,
-		wakeChunks: options.prerender || options.prerenderWakeChannel === true ? productionWakeModuleChunks(bundle) : void 0,
-		entryChunks: Object.values(bundle).filter((output) => !!output && typeof output === "object" && output.type === "chunk" && output.isEntry === true).map((chunk) => stripBuildPrefix(chunk.fileName))
-	}));
-	context.emitFile({
-		type: "asset",
-		fileName: MARKLESS_BUNDLE_GRAPH,
-		source: JSON.stringify(clientManifest.bundleGraph)
-	});
-	context.emitFile(await createExecutionSizesAsset(manifestBundle, clientManifest, stripBuildPrefix, executionLogInjection ? input.executionAttributionTables(attributionClaims) : void 0, {
-		executionLogActive: executionLogInjection !== null,
-		hookedIds: input.executionLogEmittedIds
-	}));
-	context.emitFile({
-		type: "asset",
-		fileName: `${MARKLESS_BUILD_PREFIX}execution-demand.json`,
-		source: JSON.stringify(Object.fromEntries(clientManifest.modules.filter((module) => module.runtimeDemandMap).map((module) => [module.source, module.runtimeDemandMap])))
-	});
-}
-function bundleWithoutRemovedChunks(bundle, removedFileNames) {
-	if (removedFileNames.size === 0) return bundle;
-	const next = {};
-	for (const [key, output] of Object.entries(bundle)) {
-		if (isChunkFile(output) && removedFileNames.has(output.fileName)) continue;
-		next[key] = output;
-	}
-	return next;
-}
-function stripEmptyPreloadWrappersFromChunks(bundle) {
-	for (const output of Object.values(bundle)) {
-		if (!isChunkWithCode(output)) continue;
-		const nextCode = stripEmptyVitePreloadWrappers(output.code);
-		if (nextCode !== output.code) output.code = nextCode;
-	}
-}
-function isChunkFile(output) {
-	if (!output || typeof output !== "object") return false;
-	const chunk = output;
-	return chunk.type === "chunk" && typeof chunk.fileName === "string";
-}
-function isChunkWithCode(output) {
-	if (!output || typeof output !== "object") return false;
-	const chunk = output;
-	return chunk.type === "chunk" && typeof chunk.code === "string";
-}
-function recordProductionSettleModuleUrls(bundle, urls, publicPath) {
-	for (const output of Object.values(bundle)) {
-		if (!output || typeof output !== "object") continue;
-		const chunk = output;
-		if (chunk.type !== "chunk" || typeof chunk.facadeModuleId !== "string" || typeof chunk.fileName !== "string") continue;
-		const source = sourceForSettleVirtualImporter(chunk.facadeModuleId);
-		if (source) urls.set(source, publicPath?.(chunk.fileName) ?? `/${chunk.fileName}`);
-	}
-}
-function recordProductionResumeModuleUrls(bundle, urls, publicPath) {
-	if (!urls) return;
-	for (const output of Object.values(bundle)) {
-		if (!output || typeof output !== "object") continue;
-		const chunk = output;
-		if (chunk.type !== "chunk" || typeof chunk.facadeModuleId !== "string" || typeof chunk.fileName !== "string") continue;
-		const source = sourceForResumeVirtualImporter(chunk.facadeModuleId);
-		if (source) urls.set(source, publicPath?.(chunk.fileName) ?? `/${chunk.fileName}`);
-	}
-}
-function recordProductionPrerenderWakeModuleUrls(bundle, urls, publicPath) {
-	if (!urls) return;
-	for (const output of Object.values(bundle)) {
-		if (!output || typeof output !== "object") continue;
-		const chunk = output;
-		if (chunk.type !== "chunk" || typeof chunk.facadeModuleId !== "string" || typeof chunk.fileName !== "string") continue;
-		const source = sourceForPrerenderWakeVirtualImporter(chunk.facadeModuleId);
-		if (source) urls.set(source, publicPath?.(chunk.fileName) ?? `/${chunk.fileName}`);
-	}
-}
-function productionWakeModuleChunks(bundle) {
-	const chunks = [];
-	for (const output of Object.values(bundle)) {
-		if (!output || typeof output !== "object") continue;
-		const chunk = output;
-		if (chunk.type === "chunk" && typeof chunk.facadeModuleId === "string" && typeof chunk.fileName === "string" && (sourceForResumeVirtualImporter(chunk.facadeModuleId) || sourceForPrerenderWakeVirtualImporter(chunk.facadeModuleId))) chunks.push(stripBuildPrefix(chunk.fileName));
-	}
-	return chunks;
-}
-//#endregion
-//#region src/link-driver.ts
-function symbolRouteSource(source) {
-	return withQuery(source, { "markless-symbols": null });
-}
-function resolverVirtualModuleId(source) {
-	return `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodeURIComponent(source)}`;
-}
-function linkedClaims(metadata, sources) {
-	for (const source of sources) metadata.assertSourceClaimsSealed(source);
-	return linkClaimManifests({
-		byEmittedModule: metadata.symbolClaimMap(),
-		sources: sources.map((source) => ({
-			source,
-			resolverId: resolverVirtualModuleId(source)
-		}))
-	});
-}
-function sourceSymbolManifest(metadata, source) {
-	const artifact = linkedClaims(metadata, [source]);
-	const contradiction = artifact.diagnostics[0];
-	if (contradiction) throw new Error(contradiction.message);
-	return artifact.bySource[source];
-}
-async function resolveModuleLinkRequests(context, requests, fallbackSource) {
-	const entries = await Promise.all(requests.map(async (request) => {
-		const resolved = await context.resolve(request.specifier, request.parent, { skipSelf: true });
-		const id = typeof resolved === "string" ? resolved : resolved && "id" in resolved ? String(resolved.id) : void 0;
-		return [moduleLinkResolutionKey(request.specifier, request.parent), id === void 0 ? {
-			id: pathname(fallbackSource(request.parent, request.specifier)),
-			external: false,
-			kind: "fallback"
-		} : {
-			id: pathname(id),
-			external: typeof resolved === "object" && resolved !== null ? Boolean(resolved.external) : false,
-			kind: "resolved"
-		}];
-	}));
-	return Object.fromEntries(entries);
-}
-async function resolveImportedModuleInterfaces(context, parent, moduleImports, fallbackSource) {
-	const requests = linkedModuleImportRequests(parent, moduleImports);
-	return planLinkedModuleChildren(requests, await resolveModuleLinkRequests(context, requests, fallbackSource));
-}
-const BARREL_WALK_ROUNDS = 32;
-async function linkBarrelComponentInterfaces(context, parent, moduleImports, artifacts, buildId) {
-	const resolution = {};
-	const interfacesByFile = /* @__PURE__ */ new Map();
-	const passInput = () => ({
-		parent,
-		moduleImports,
-		resolution,
-		moduleInterface: (filename) => interfacesByFile.get(filename),
-		rebase: (target) => {
-			const specifier = relative(dirname(parent), target);
-			return specifier.startsWith(".") ? specifier : `./${specifier}`;
-		}
-	});
-	let artifact = linkBarrelComponents(passInput());
-	for (let round = 0; artifact.pendingResolutions.length + artifact.pendingInterfaces.length > 0; round += 1) {
-		if (round === BARREL_WALK_ROUNDS) throw new Error(`MARKLESS_COMPONENT_BARREL_UNRESOLVED: Module ${JSON.stringify(parent)} re-exports through more than ${BARREL_WALK_ROUNDS} chained barrels.`);
-		await Promise.all(artifact.pendingResolutions.map(async (request) => {
-			const resolved = await context.resolve(request.specifier, request.parent, { skipSelf: true });
-			const id = typeof resolved === "string" ? resolved : resolved?.id;
-			resolution[moduleLinkResolutionKey(request.specifier, request.parent)] = id ? pathname(String(id)) : null;
-		}));
-		await Promise.all(artifact.pendingInterfaces.map(async (filename) => {
-			interfacesByFile.set(filename, await barrelModuleInterface(filename, artifacts, buildId));
-		}));
-		artifact = linkBarrelComponents(passInput());
-	}
-	const [diagnostic] = artifact.diagnostics;
-	if (diagnostic) throw new Error(diagnostic.message);
-	return {
-		interfaces: artifact.interfaces,
-		children: artifact.children
-	};
-}
-async function barrelModuleInterface(filename, artifacts, buildId) {
-	const known = artifacts.get(filename)?.moduleGraphInterface;
-	if (known) return known;
-	if (!existsSync(filename) || !statSync(filename).isFile()) return null;
-	return (await compileTsrxModuleLinkArtifact({
-		filename,
-		source: readFileSync(filename, "utf8"),
-		buildId
-	})).moduleGraphInterface;
-}
-async function resolveImportedChildren(context, parent, manifest, fallbackSource) {
-	const requests = linkedSymbolRouteRequests(parent, manifest.symbolRoutes);
-	return planLinkedModuleChildren(requests, await resolveModuleLinkRequests(context, requests, fallbackSource));
-}
-async function forceImportedModules(context, children, moduleArtifacts, metadata, options, environment) {
-	for (const child of children) {
-		const loadSource = linkedModuleLoadSource(child, moduleArtifacts.has(child.source));
-		if (loadSource !== void 0) {
-			if (options.dev === true) await options.devServer?.transformRequest(loadSource, environment);
-			else if (typeof context.load === "function") await context.load({ id: loadSource });
-		}
-		const plan = linkedModuleClaimPlan({
-			child,
-			captureMetadata: metadata.captureMetadataForSource(child.source),
-			clientEnvironment: environment === "client",
-			completeWakeVariants: options.prerenderWakeChannel === true,
-			symbolRouteSource,
-			resumeSource: (source) => withQuery(source, { "markless-resume": null }),
-			wakeSource: (source) => withQuery(source, { "markless-prerender-wake": null })
-		});
-		if (plan.expectClaims && typeof context.getModuleInfo === "function") metadata.expectSourceSymbolClaims(child.source, plan.claimSources);
-		if (plan.claimSources.length > 0) {
-			if (options.dev === true) await Promise.all(plan.claimSources.map((source) => options.devServer?.transformRequest(source, environment)));
-			else if (typeof context.load === "function") await Promise.all(plan.claimSources.map((id) => context.load?.({ id })));
-		}
-		if (plan.seal) await metadata.sealSourceSymbolClaims(child.source);
-	}
-	await awaitChildClaimPublications(metadata, children);
-}
-/**
-* Re-enters the publication barrier immediately before claims are read. A server
-* transform publishes no client claims, so it has no seal of its own, and any
-* await between forcing a child and reading it reopens the window a sibling can
-* start compiling in. Callers must invoke this with no further await before the
-* read: the registry state it settles is the state the read sees.
-*/
-async function awaitChildClaimPublications(metadata, children) {
-	for (const child of children) await metadata.awaitSourceClaimsPublished(child.source);
-}
-function mergeLinkedModuleChildren(...sets) {
-	return uniqueLinkedModuleChildren(sets.flat());
-}
-function linkModuleGraph(children, readers) {
-	return linkImportedModules({
-		children,
-		moduleArtifacts: readers.moduleArtifacts,
-		captureMetadataForSource: (source) => readers.metadata.captureMetadataForSource(source),
-		parentCaptureMetadataForSource: (parent) => parentCaptureMetadata(parent, readers),
-		symbolRouteSource,
-		...readers.renderDataReachRoot !== void 0 && readers.reachedRenderDataSource ? {
-			renderDataReachRoot: readers.renderDataReachRoot,
-			reachedRenderDataSource: readers.reachedRenderDataSource
-		} : {}
-	});
-}
-function parentCaptureMetadata(parent, readers) {
-	return readers.parentManifest?.captureMetadata ?? readers.metadata.captureMetadataForSource(pathname(parent));
-}
-function moduleIsEntry(context, id) {
-	try {
-		return context.getModuleInfo?.(id)?.isEntry === true;
-	} catch {
-		return false;
-	}
-}
-function warnDelegateImportFailures(pluginContext, result) {
-	if (typeof pluginContext.warn !== "function" || result.importFailures.length === 0) return;
-	const failed = new Set(result.importFailures.map((failure) => failure.source));
-	for (const diagnostic of result.diagnostics) if (diagnostic.source !== void 0 && failed.has(diagnostic.source)) pluginContext.warn(diagnostic.message);
-}
-async function materializeDelegateChildren(context, parent, candidates) {
-	const resolution = {};
-	for (const candidate of delegateChildResolutionRequests(candidates)) {
-		const resolved = await context.resolve(candidate.importSource, parent, { skipSelf: true });
-		const id = typeof resolved === "string" ? resolved : resolved?.id;
-		if (id) resolution[candidate.edgeId] = pathname(id);
-	}
-	const children = planDelegateChildren(candidates, resolution);
-	const byEdge = new Map(candidates.map((candidate) => [candidate.edgeId, candidate]));
-	const loaded = /* @__PURE__ */ new Map();
-	const unloadable = /* @__PURE__ */ new Map();
-	const renderings = {};
-	for (const child of children) {
-		const candidate = byEdge.get(child.edgeId);
-		const source = child.source;
-		if (!child.loadable || !candidate || source === void 0) continue;
-		if (!isAbsolute$1(source) || !existsSync(source) || !statSync(source).isFile()) continue;
-		const failed = unloadable.get(source);
-		if (failed) {
-			failed.edgeIds.push(child.edgeId);
-			continue;
-		}
-		let module = loaded.get(source);
-		if (!module) {
-			try {
-				module = await import(pathToFileURL(source).href);
-			} catch (error) {
-				unloadable.set(source, {
-					message: error instanceof Error ? error.message : String(error),
-					edgeIds: [child.edgeId]
-				});
-				continue;
-			}
-			loaded.set(source, module);
-		}
-		const component = candidate.importKind === "default" ? module.default : candidate.importKind === "namespace" ? module : module[candidate.importedName ?? candidate.componentName];
-		const renderSsr = component?.renderSsr;
-		if (typeof renderSsr !== "function") continue;
-		const plan = delegateChildRenderPlan(candidate);
-		if (!plan.ok) throw new Error(plan.diagnostic.message);
-		const rendering = delegateChildRendering(candidate, await renderSsr.call(component, plan.props));
-		if (!rendering.ok) throw new Error(rendering.diagnostic.message);
-		renderings[child.edgeId] = rendering.rendering;
-	}
-	const importFailures = [...unloadable].map(([source, failure]) => ({
-		source,
-		edgeIds: [...failure.edgeIds],
-		message: failure.message
-	}));
-	const linked = linkDelegateChildren({
-		children,
-		renderings,
-		importFailures
-	});
-	return {
-		materializations: linked.materializations,
-		importFailures,
-		diagnostics: linked.diagnostics
-	};
-}
-function fallbackImportedSource(parent, specifier) {
-	const source = specifier.split("?")[0];
-	return isRelativeImport(source) ? resolve(dirname(parent), source) : source;
-}
-function linkedInterfaces(imports, artifacts, claims = []) {
-	return computeLinkedInterfaces({
-		imports: imports.map((imported) => ({
-			specifier: imported.specifier,
-			source: imported.source,
-			interfaceHash: artifacts.get(imported.source)?.interfaceHash,
-			moduleInterface: artifacts.get(imported.source)?.moduleGraphInterface
-		})),
-		claims
-	});
-}
-function linkedInterfaceClaims(imports, metadata) {
-	return imports.map((imported) => ({
-		source: imported.source,
-		symbols: sourceSymbolManifest(metadata, imported.source)?.symbols ?? []
-	}));
-}
-function throwLinkedModuleChildDiagnostics(metadata, children, parentManifest) {
-	const [diagnostic] = linkedModuleChildDiagnostics(children, {
-		captureMetadataForSource: (source) => metadata.captureMetadataForSource(source),
-		parentCaptureMetadataForSource: (parent) => parentManifest?.captureMetadata ?? metadata.captureMetadataForSource(pathname(parent))
-	});
-	if (diagnostic) throw new Error(diagnostic.message);
-}
-//#endregion
-//#region src/hooks/generate-bundle.ts
-async function generateBundleHook(ctx, pluginContext, bundle) {
-	const { internalOptions, linkedChildren } = ctx;
-	const { moduleMetadata, executionLogEmittedIds } = ctx.state;
-	throwLinkedModuleChildDiagnostics(moduleMetadata, [...linkedChildren.values()]);
-	if (ctx.getEnvironment(pluginContext) !== "client") return;
-	await finalizeBundle(pluginContext, bundle, {
-		options: internalOptions,
-		moduleMetadata,
-		root: ctx.getRoot(),
-		executionLogEmittedIds,
-		executionAttributionTables: ctx.attributionTables
-	});
-}
-//#endregion
-//#region src/hooks/resolve-load.ts
-async function resolveIdHook(ctx, pluginContext, source, importer) {
-	const { importedChildSources } = ctx.state;
-	if (source.startsWith("@markless/web/fns/")) {
-		const resolved = import.meta.resolve(source);
-		if (resolved?.startsWith("file://")) return { id: decodeURIComponent(resolved.slice(7)) };
-	}
-	if (source.startsWith("@markless/web/inline/")) {
-		const resolvedRoot = import.meta.resolve("@markless/web");
-		if (resolvedRoot?.startsWith("file://") && resolvedRoot.endsWith("/index.ts")) {
-			const helperPath = source.slice(14);
-			return { id: decodeURIComponent(resolvedRoot.slice(7, -8) + `${helperPath}.ts`) };
-		}
-	}
-	const normalized = normalizeVirtualId$2(source);
-	if (normalized === "virtual:markless:dev-log") return {
-		id: resolveVirtualId(MARKLESS_EXECUTION_LOG_MODULE_ID),
-		moduleSideEffects: true
-	};
-	const virtualModule = await virtualModuleForRequest(ctx, normalized, ctx.getEnvironment(pluginContext));
-	if (virtualModule) {
-		const directQuery = virtualModule.type === "style" && /(?:[?&])direct(?:[=&]|$)/.test(source) ? "?direct" : "";
-		return {
-			id: `${resolveVirtualId(normalized)}${directQuery}`,
-			moduleSideEffects: true
-		};
-	}
-	const missingSymbolSource = symbolVirtualModuleSourceFile(normalized);
-	if (missingSymbolSource && importedChildSources.has(missingSymbolSource)) throw new Error(`MARKLESS_CHILD_SYMBOL_MISSING: Linked child ${JSON.stringify(missingSymbolSource)} does not provide requested symbol module ${JSON.stringify(normalized)}. Rebuild the child with the current Markless compiler and clear any stale build cache.`);
-	const symbolSource = sourceForSymbolVirtualImporter(importer);
-	if (symbolSource && isRelativeImport(source)) return await pluginContext.resolve(source, symbolSource, { skipSelf: true });
-	const triggerGroupSource = sourceForTriggerGroupVirtualImporter(importer);
-	if (triggerGroupSource && isRelativeImport(source)) return await pluginContext.resolve(source, triggerGroupSource, { skipSelf: true });
-	const resumeSource = sourceForResumeVirtualImporter(importer) ?? sourceForPrerenderWakeVirtualImporter(importer);
-	if (resumeSource && isRelativeImport(source)) return await pluginContext.resolve(source, resumeSource, { skipSelf: true });
-	return null;
-}
-async function loadHook(ctx, pluginContext, id) {
-	const { internalOptions } = ctx;
-	const { moduleMetadata, executionLogEstimatedSizes } = ctx.state;
-	if (normalizeVirtualId$2(id) === "virtual:markless:dev-log") {
-		const embedsDevSizes = internalOptions.dev === true && ctx.getEnvironment(pluginContext) === "client";
-		return executionLogVirtualModuleSource({
-			moduleSizes: embedsDevSizes ? executionLogEstimatedSizes : void 0,
-			attribution: embedsDevSizes ? ctx.attributionTables(moduleMetadata.symbolClaimMap().values()) : void 0,
-			sizesUrl: internalOptions.dev === true ? void 0 : internalOptions.publicPath?.(MARKLESS_EXECUTION_SIZES) ?? `/${MARKLESS_EXECUTION_SIZES}`
-		});
-	}
-	const normalizedId = normalizeVirtualId$2(id);
-	const resolverSource = resolverVirtualModuleSourceFile(normalizedId);
-	if (resolverSource && ctx.getEnvironment(pluginContext) === "client" && internalOptions.dev !== true && internalOptions.prerenderWakeChannel === true && typeof pluginContext.getModuleInfo === "function") {
-		const queryClaimSources = [
-			withQuery(resolverSource, { "markless-resume": null }),
-			withQuery(resolverSource, { "markless-prerender-wake": null }),
-			withQuery(resolverSource, { "markless-symbols": null })
-		];
-		moduleMetadata.expectSourceSymbolClaims(resolverSource, queryClaimSources.filter((source) => pluginContext.getModuleInfo(source) != null));
-		await moduleMetadata.sealSourceSymbolClaims(resolverSource);
-	}
-	const module = await virtualModuleForRequest(ctx, normalizedId, ctx.getEnvironment(pluginContext));
-	if (module) return virtualModuleSourceForLoad(module, {
-		dev: internalOptions.dev === true && ctx.getEnvironment(pluginContext) === "client",
-		publicPath: internalOptions.publicPath
-	});
-	return null;
-}
-async function virtualModuleForRequest(ctx, normalizedId, currentEnvironment) {
-	const { internalOptions } = ctx;
-	const { virtualModules, regeneratingVirtualModules } = ctx.state;
-	const registered = virtualModules.get(normalizedId);
-	if (registered || internalOptions.dev !== true) return registered;
-	const source = marklessVirtualModuleSourceFile(normalizedId);
-	if (!source || !TSRX_SOURCE_FILE$1.test(source) || regeneratingVirtualModules.has(normalizedId)) return;
-	regeneratingVirtualModules.add(normalizedId);
-	try {
-		internalOptions.devServer?.invalidateModule?.(source, currentEnvironment);
-		await internalOptions.devServer?.transformRequest(source, currentEnvironment);
-	} finally {
-		regeneratingVirtualModules.delete(normalizedId);
-	}
-	return virtualModules.get(normalizedId);
-}
-async function recoverImportedChildMetadata(ctx, child, currentEnvironment) {
-	const { internalOptions } = ctx;
-	const { moduleMetadata, recoveringChildMetadata } = ctx.state;
-	if (!TSRX_SOURCE_FILE$1.test(child.source) || moduleMetadata.captureMetadataForSource(child.source) !== void 0 || recoveringChildMetadata.has(child.source)) return;
-	recoveringChildMetadata.add(child.source);
-	try {
-		internalOptions.devServer?.invalidateModule?.(child.source, currentEnvironment);
-		await internalOptions.devServer?.transformRequest(child.source, currentEnvironment);
-	} finally {
-		recoveringChildMetadata.delete(child.source);
-	}
-}
-//#endregion
-//#region src/hooks/transform-emit.ts
-async function emitClientRouteArtifact(request, transformed) {
-	const { ctx, pluginContext, source } = request;
-	const { clientRouteArtifactMaterializations } = ctx.state;
-	const delegates = await materializeDelegateChildren(pluginContext, source, transformed.artifactChildren);
-	warnDelegateImportFailures(pluginContext, delegates);
-	const artifactChildMaterializations = delegates.materializations;
-	if (Object.keys(artifactChildMaterializations).length > 0) clientRouteArtifactMaterializations.set(source, artifactChildMaterializations);
-	registerClientRouteArtifactSource(ctx, source);
-	return {
-		code: clientRouteArtifactReference(source),
-		map: null
-	};
-}
-function registerFirstPassArtifacts(request, transformed) {
-	const { ctx, source, currentEnvironment, renderDataRequest, plan } = request;
-	const { internalOptions, dev, state } = ctx;
-	const { moduleMetadata, moduleLinkArtifacts } = state;
-	const { cacheKey, manifestSource } = plan;
-	if (!renderDataRequest) registerTransformArtifacts(state, {
-		owner: cacheKey,
-		source,
-		manifestSource,
-		result: transformed,
-		dev,
-		environment: currentEnvironment,
-		finalPublication: false,
-		tracksSourceClaimPublication: false,
-		updateDevPrerenderHashes: internalOptions.updateDevPrerenderHashes
-	});
-	else {
-		moduleMetadata.recordCaptureMetadata(source, transformed.manifest);
-		moduleMetadata.recordSymbolClaims(manifestSource, renderDataClaimManifest(transformed.manifest, manifestSource));
-		moduleLinkArtifacts.set(source, {
-			interfaceHash: transformed.interfaceHash,
-			moduleGraphInterface: transformed.moduleGraphInterface,
-			moduleImports: transformed.moduleImports
-		});
-	}
-}
-function registerFinalTransformArtifacts(request, transformed) {
-	const { ctx, source, currentEnvironment, renderDataRequest, plan } = request;
-	const { internalOptions, dev, state } = ctx;
-	const { moduleMetadata } = state;
-	const { cacheKey, manifestSource, publishesClientClaims } = plan;
-	if (!renderDataRequest) registerTransformArtifacts(state, {
-		owner: cacheKey,
-		source,
-		manifestSource,
-		result: transformed,
-		dev,
-		environment: currentEnvironment,
-		finalPublication: true,
-		tracksSourceClaimPublication: publishesClientClaims,
-		replaceOwnedArtifacts: true,
-		updateDevPrerenderHashes: internalOptions.updateDevPrerenderHashes
-	});
-	else {
-		moduleMetadata.recordCaptureMetadata(source, transformed.manifest);
-		moduleMetadata.recordSymbolClaims(manifestSource, renderDataClaimManifest(transformed.manifest, manifestSource));
-	}
-}
-function recordLinkedTransform(request, transformed, linkedTransformInput, linked) {
-	const { ctx, code, source, plan } = request;
-	const { moduleMetadata, moduleLinkArtifacts, linkedTransformCache } = ctx.state;
-	const { cacheKey, manifestSource } = plan;
-	const { resolvedInterfaceImports, resolvedChildren, linkedChildHasBrowserTriggers } = linked;
-	linkedTransformCache.set(cacheKey, {
-		source,
-		manifestSource,
-		code,
-		importedInterfaceHashes: linkedInterfaces(resolvedInterfaceImports, moduleLinkArtifacts).signature,
-		importedSymbolClaims: linkedInterfaces(resolvedInterfaceImports, moduleLinkArtifacts, linkedInterfaceClaims(mergeLinkedModuleChildren(resolvedInterfaceImports, resolvedChildren), moduleMetadata)).claimSignature,
-		input: linkedTransformInput,
-		result: transformed,
-		linkedChildHasBrowserTriggers
-	});
-}
-async function emitTransformResult(request, transformed, resolvedChildren) {
-	const { ctx, pluginContext, id, source, currentEnvironment, renderDataRequest, prerenderWakeRequest, plan } = request;
-	const { internalOptions, dev, state } = ctx;
-	const { virtualModules, clientSymbolEntrySources, importedChildSources, emittedClientResolverSources, transformedClientPrimarySources } = state;
-	const { cacheKey, manifestSource } = plan;
-	if (currentEnvironment === "client" && isClientPrimarySourceRequest(id)) transformedClientPrimarySources.add(source);
-	if (currentEnvironment === "client" && renderDataRequest) {
-		const renderDataModule = transformed.virtualModules.find((module) => module.type === "render-data");
-		if (renderDataModule) {
-			const styleModules = transformed.virtualModules.filter((module) => module.type === "style");
-			registerRenderDataStyles(state, {
-				owner: cacheKey,
-				source,
-				modules: styleModules,
-				dev
-			});
-			const renderData = planRenderDataModule({
-				source,
-				emittedModule: manifestSource,
-				moduleSource: renderDataModule.source,
-				styleModules: styleModules.map((module) => module.id),
-				manifest: transformed.manifest,
-				linkedModules: virtualModules.keys()
-			});
-			throwIfRenderDataUnlinked(renderData);
-			return {
-				code: [...renderData.styleModules.map((styleModule) => `import ${JSON.stringify(styleModule)};`), renderDataModule.source].join("\n"),
-				map: null
-			};
-		}
-	}
-	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 {
-			code: resumeModule.source,
-			map: null
-		};
-	}
-	if (currentEnvironment === "client" && prerenderWakeRequest) {
-		const wakeModule = transformed.virtualModules.find((module) => module.type === "prerender-wake");
-		return wakeModule ? {
-			code: `export { resumeContainerEvent } from ${JSON.stringify(wakeModule.id)};`,
-			map: null
-		} : {
-			code: [
-				"export async function resumeContainerEvent() {",
-				"	throw new Error('MARKLESS_PRERENDER_WAKE_ROUTE_INELIGIBLE');",
-				"}"
-			].join("\n"),
-			map: null
-		};
-	}
-	if (currentEnvironment === "client" && !internalOptions.dev) for (const module of transformed.virtualModules.filter((item) => {
-		if (item.type === "symbol") return true;
-		if (item.type === "trigger-group") return true;
-		if (item.type === "settle") return clientSymbolEntrySources.has(source);
-		if (item.type === "resolver") return (importedChildSources.has(source) || (transformed.manifest.captureMetadata?.boundResolverRows?.length ?? 0) > 0) && !emittedClientResolverSources.has(source);
-		return (item.type === "resume" || item.type === "prerender-wake") && internalOptions.emitResumeModules === true && clientSymbolEntrySources.has(source);
-	})) {
-		pluginContext.emitFile({
-			type: "chunk",
-			id: module.id,
-			preserveSignature: "strict"
-		});
-		if (module.type === "resolver") emittedClientResolverSources.add(source);
-	}
-	return transformed;
-}
-function registerClientRouteArtifactSource(ctx, source) {
-	const { internalOptions } = ctx;
-	const { clientRouteArtifactSources, transformedClientPrimarySources } = ctx.state;
-	const registration = linkedRouteArtifactRegistration({
-		source,
-		registered: clientRouteArtifactSources.has(source),
-		primaryTransformed: transformedClientPrimarySources.has(source),
-		dev: internalOptions.dev === true
-	});
-	if (registration.action === "already-registered") return;
-	if (registration.action === "late") throw new Error(registration.diagnostics[0].message);
-	if (registration.action === "reinvalidate") {
-		invalidateAllGeneratedModules(ctx, source, "client");
-		transformedClientPrimarySources.delete(source);
-		internalOptions.devServer?.invalidateModule?.(source, "client");
-	}
-	clientRouteArtifactSources.add(source);
-}
-function throwIfRenderDataUnlinked(renderData) {
-	const unlinked = renderData.diagnostics[0];
-	if (unlinked) throw new Error(unlinked.message);
-}
-//#endregion
-//#region src/hooks/transform-link.ts
-async function materializeOwnDelegateChildren(request, result, input) {
-	const { ctx, source, currentEnvironment } = request;
-	const { clientRouteArtifactMaterializations } = ctx.state;
-	let transformed = result;
-	let linkedTransformInput = input;
-	const artifactChildMaterializations = currentEnvironment === "client" && clientRouteArtifactMaterializations.has(source) ? clientRouteArtifactMaterializations.get(source) : await scopedDelegateMaterializations(request, transformed);
-	if (Object.keys(artifactChildMaterializations).length > 0) {
-		linkedTransformInput = {
-			...linkedTransformInput,
-			artifactChildMaterializations
-		};
-		transformed = await transformTsrxModuleWithPrerenderWakeClosure(linkedTransformInput, false);
-	}
-	return {
-		transformed,
-		input: linkedTransformInput
-	};
-}
-async function scopedDelegateMaterializations(request, transformed) {
-	const { pluginContext, id, source, currentEnvironment, materializedRenderDataReach } = request;
-	if (!delegateMaterializationScope({
-		clientEnvironment: currentEnvironment === "client",
-		symbolOnlyRequest: isSymbolOnlySourceRequest(id),
-		moduleEntry: moduleIsEntry(pluginContext, id),
-		renderDataReached: materializedRenderDataReach !== void 0
-	})) return {};
-	const delegates = await materializeDelegateChildren(pluginContext, source, transformed.artifactChildren);
-	warnDelegateImportFailures(pluginContext, delegates);
-	return delegates.materializations;
-}
-async function linkTransformChildren(request, result, input, reusedLinkedTransform) {
-	const { ctx, pluginContext, currentEnvironment, materializedRenderDataReach, plan } = request;
-	const { internalOptions, linkedChildren } = ctx;
-	const { moduleMetadata, moduleLinkArtifacts, importedChildSources, prerenderWakeCapabilities } = ctx.state;
-	const { manifestSource } = plan;
-	let transformed = result;
-	let linkedTransformInput = input;
-	const resolvedInterfaceImports = await resolveImportedModuleInterfaces(pluginContext, manifestSource, transformed.moduleImports, fallbackImportedSource);
-	const barrelComponents = await linkBarrelComponentInterfaces(pluginContext, manifestSource, transformed.moduleImports, moduleLinkArtifacts, internalOptions.buildId);
-	const barrelLinkedInterfaces = () => ({
-		...barrelComponents.interfaces,
-		...linkedInterfaces(barrelComponents.children, moduleLinkArtifacts).interfaces
-	});
-	if (!reusedLinkedTransform && barrelComponents.children.length > 0) {
-		await forceImportedModules(pluginContext, mergeLinkedModuleChildren(barrelComponents.children), moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
-		linkedTransformInput = {
-			...linkedTransformInput,
-			importedModuleInterfaces: barrelLinkedInterfaces()
-		};
-		transformed = await transformTsrxModuleWithPrerenderWakeClosure(linkedTransformInput, false);
-	}
-	const resolvedChildren = await resolveImportedChildren(pluginContext, manifestSource, transformed.manifest, fallbackImportedSource);
-	for (const child of resolvedChildren) {
-		linkedChildren.set(linkedModuleChildKey(child), child);
-		importedChildSources.add(child.source);
-	}
-	await forceImportedModules(pluginContext, mergeLinkedModuleChildren(resolvedInterfaceImports, barrelComponents.children, resolvedChildren), moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
-	for (const child of resolvedChildren) if (internalOptions.dev === true) {
-		await recoverImportedChildMetadata(ctx, child, currentEnvironment);
-		throwLinkedModuleChildDiagnostics(moduleMetadata, [child], transformed.manifest);
-	}
-	await awaitChildClaimPublications(moduleMetadata, resolvedChildren);
-	const linkedChildHasBrowserTriggers = linkedChildrenHaveBrowserTriggers({
-		children: resolvedChildren,
-		symbolClaimsForSource: (source) => sourceSymbolManifest(moduleMetadata, source),
-		browserTriggerCapability: (source) => prerenderWakeCapabilities.get(source)
-	});
-	if (!reusedLinkedTransform && (resolvedChildren.length > 0 || resolvedInterfaceImports.length > 0 || barrelComponents.children.length > 0)) {
-		const symbols = linkedImportedSymbolInputs({
-			children: resolvedChildren,
-			captureMetadataForSource: (source) => moduleMetadata.captureMetadataForSource(source),
-			symbolClaimsForSource: (source) => sourceSymbolManifest(moduleMetadata, source)
-		});
-		const linkedGraph = linkModuleGraph(resolvedInterfaceImports, {
-			moduleArtifacts: moduleLinkArtifacts,
-			metadata: moduleMetadata,
-			parentManifest: transformed.manifest,
-			...materializedRenderDataReach ? {
-				renderDataReachRoot: materializedRenderDataReach,
-				reachedRenderDataSource: materializedReachedRenderDataSource
-			} : {}
-		});
-		const renderDataImportSources = materializedRenderDataReach ? renderDataReachImportSources(linkedGraph) : void 0;
-		linkedTransformInput = {
-			...linkedTransformInput,
-			symbols,
-			importedModuleInterfaces: {
-				...barrelLinkedInterfaces(),
-				...linkedGraph.interfaces
-			},
-			...renderDataImportSources ? { renderDataImportSources } : {}
-		};
-		transformed = await transformTsrxModuleWithPrerenderWakeClosure(linkedTransformInput, linkedChildHasBrowserTriggers);
-	}
-	return {
-		transformed,
-		input: linkedTransformInput,
-		resolvedChildren,
-		resolvedInterfaceImports,
-		linkedChildHasBrowserTriggers
-	};
-}
-async function sealWakeAggregate(request, result, input, linkedChildHasBrowserTriggers) {
-	const { ctx, pluginContext, source, currentEnvironment, plan } = request;
-	const { internalOptions } = ctx;
-	const { moduleMetadata, moduleLinkArtifacts, prerenderWakeCapabilities } = ctx.state;
-	let transformed = result;
-	prerenderWakeCapabilities.set(source, plan.wakeCapability(linkedManifestHasBrowserTriggers(transformed.manifest), linkedChildHasBrowserTriggers));
-	if (plan.aggregateEligible) {
-		const aggregateInput = {
-			...input,
-			clientOutput: void 0,
-			prerenderWakeFacade: false,
-			prerenderWakeVariant: false
-		};
-		let aggregate = await transformTsrxModuleWithPrerenderWakeClosure(aggregateInput, linkedChildHasBrowserTriggers);
-		const aggregateChildren = await resolveImportedChildren(pluginContext, source, aggregate.manifest, fallbackImportedSource);
-		await forceImportedModules(pluginContext, aggregateChildren, moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
-		const aggregateSymbolInputs = () => linkedImportedSymbolInputs({
-			children: aggregateChildren,
-			captureMetadataForSource: (child) => moduleMetadata.captureMetadataForSource(child),
-			symbolClaimsForSource: (child) => sourceSymbolManifest(moduleMetadata, child)
-		});
-		let aggregateSymbols = aggregateSymbolInputs();
-		for (let attempt = 0; linkedImportedClaimsMissing({
-			children: aggregateChildren,
-			symbols: aggregateSymbols,
-			captureMetadataForSource: (child) => moduleMetadata.captureMetadataForSource(child)
-		}); attempt += 1) {
-			if (attempt === 9) throw new Error(`MARKLESS_IMPORTED_SYMBOL_CLAIMS_UNREADY: Source ${JSON.stringify(source)} could not seal imported symbol claims after final publications.`);
-			await new Promise((resolve) => setTimeout(resolve, 0));
-			for (const child of aggregateChildren) await moduleMetadata.sealSourceSymbolClaims(child.source);
-			aggregateSymbols = aggregateSymbolInputs();
-		}
-		aggregate = await transformTsrxModuleWithPrerenderWakeClosure({
-			...aggregateInput,
-			symbols: aggregateSymbols
-		}, linkedChildHasBrowserTriggers);
-		const resolver = aggregate.virtualModules.find((module) => module.type === "resolver");
-		if (resolver) transformed = {
-			...transformed,
-			virtualModules: transformed.virtualModules.map((module) => module.type === "resolver" ? resolver : module)
-		};
-	}
-	return transformed;
-}
-//#endregion
-//#region src/hooks/transform-request.ts
-function planTransformHookRequest(ctx, pluginContext, code, id, currentEnvironment) {
-	const { internalOptions } = ctx;
-	const { prerenderWakeSources, clientSymbolEntrySources, clientRouteArtifactSources, clientRouteArtifactMaterializations } = ctx.state;
-	const source = pathname(id);
-	const renderDataRequest = isRenderDataSourceRequest(id);
-	const prerenderWakeRequest = isPrerenderWakeSourceRequest(id);
-	const clientRouteArtifact = MARKLESS_ROUTE_SOURCE_QUERY_RE.test(id);
-	const materializedRenderDataReach = currentEnvironment === "client" && renderDataRequest ? linkedRenderDataReachRoot({
-		source,
-		materializedSources: clientRouteArtifactMaterializations,
-		reachedFrom: renderDataReachedFromQuery(id)
-	}) : void 0;
-	if (currentEnvironment === "client" && prerenderWakeRequest) {
-		clientSymbolEntrySources.add(source);
-		prerenderWakeSources.add(source);
-	}
-	const clientOutput = currentEnvironment === "client" && (clientSymbolEntrySources.has(source) && internalOptions.prerender !== true && !clientRouteArtifactSources.has(source) && isClientPrimarySourceRequest(id) && moduleIsEntry(pluginContext, id) || isSymbolOnlySourceRequest(id)) ? "symbols-only" : void 0;
-	const plan = planTransformRequest({
-		environment: currentEnvironment,
-		source,
-		requestId: id,
-		request: {
-			resume: isResumeSourceRequest(id),
-			prerenderWake: prerenderWakeRequest,
-			renderData: renderDataRequest,
-			routeArtifact: clientRouteArtifact,
-			clientPrimary: isClientPrimarySourceRequest(id)
-		},
-		options: {
-			dev: internalOptions.dev === true,
-			prerender: internalOptions.prerender === true,
-			prerenderWakeChannel: internalOptions.prerenderWakeChannel === true
-		},
-		hasWakeSources: prerenderWakeSources.size > 0,
-		renderDataReached: materializedRenderDataReach !== void 0,
-		routeArtifactSource: clientRouteArtifactSources.has(source),
-		clientOutput,
-		getModuleInfoAvailable: typeof pluginContext.getModuleInfo === "function"
-	});
-	const { prerenderRecords } = plan;
-	return {
-		ctx,
-		pluginContext,
-		code,
-		id,
-		source,
-		currentEnvironment,
-		renderDataRequest,
-		prerenderWakeRequest,
-		clientRouteArtifact,
-		materializedRenderDataReach,
-		plan,
-		transformInput: {
-			filename: source,
-			source: code,
-			dev: plan.dev,
-			buildId: internalOptions.buildId,
-			executionLog: normalizeExecutionLogMode(internalOptions.executionLog),
-			executionLogModuleHooks: currentEnvironment === "client" && normalizeExecutionLogMode(internalOptions.executionLog) !== "never",
-			inlineResumerDebug: internalOptions.inlineResumerDebug === true,
-			prerenderRecords,
-			directCsr: currentEnvironment === "client" && internalOptions.emitResumeModules !== true && internalOptions.prerender !== true && !renderDataRequest && !prerenderWakeRequest && !isResumeSourceRequest(id) && !isSymbolOnlySourceRequest(id) && !clientRouteArtifact,
-			runtimeDemandClass: currentEnvironment === "client" && internalOptions.emitResumeModules === true && !prerenderRecords && !clientRouteArtifactSources.has(source) ? "plain-ssr" : "prerender",
-			prerenderWakeVariant: internalOptions.prerenderWakeChannel === true && (prerenderWakeRequest || plan.ssrPrerenderArtifacts && clientSymbolEntrySources.has(source)),
-			prerenderWakeFacade: prerenderWakeRequest,
-			preserveWakeSiblingClaims: currentEnvironment === "client" && (isResumeSourceRequest(id) || isSymbolOnlySourceRequest(id)),
-			environment: currentEnvironment,
-			clientOutput,
-			resumeModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? devBrowserSourceModuleUrl(source, ctx.getRoot(), internalOptions.publicPath) : currentEnvironment === "server" ? internalOptions.productionResumeModuleUrls?.get(source) : void 0,
-			prerenderWakeModuleUrl: currentEnvironment === "server" ? internalOptions.productionPrerenderWakeModuleUrls?.get(source) : void 0,
-			settleModuleUrl: currentEnvironment === "server" ? internalOptions.productionSettleModuleUrls?.get(source) : 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: plan.devResumeReexport,
-			prerenderRecordData: currentEnvironment === "client" ? ctx.prerenderRecordsBySource?.get(source) : void 0
-		}
-	};
-}
-//#endregion
-//#region src/hooks/transform-hook.ts
-async function transformHook(ctx, pluginContext, code, id) {
-	const currentEnvironment = ctx.getEnvironment(pluginContext);
-	const virtualId = normalizeVirtualId$2(id);
-	if (!TSRX_SOURCE_FILE$1.test(id)) return transformNonTsrxModule(ctx, pluginContext, code, id, currentEnvironment);
-	if (virtualId.startsWith("virtual:markless:")) return null;
-	const request = planTransformHookRequest(ctx, pluginContext, code, id, currentEnvironment);
-	const { plan, source } = request;
-	const { manifestSource, publishesClientClaims } = plan;
-	if (publishesClientClaims) ctx.state.moduleMetadata.beginSourceSymbolClaims(source, manifestSource);
-	try {
-		return await runTransformSteps(request);
-	} catch (error) {
-		ctx.state.moduleMetadata.releaseSourceSymbolClaims(source, manifestSource);
-		throw error;
-	}
-}
-async function runTransformSteps(request) {
-	const { clientRouteArtifact, currentEnvironment } = request;
-	const firstPass = await runFirstPassTransform(request);
-	let transformed = firstPass.result;
-	let linkedTransformInput = firstPass.input;
-	const reusedLinkedTransform = firstPass.reused;
-	if (currentEnvironment === "client" && clientRouteArtifact) return await emitClientRouteArtifact(request, transformed);
-	if (!reusedLinkedTransform) {
-		const rerun = await materializeOwnDelegateChildren(request, transformed, linkedTransformInput);
-		transformed = rerun.transformed;
-		linkedTransformInput = rerun.input;
-	}
-	registerFirstPassArtifacts(request, transformed);
-	const linked = await linkTransformChildren(request, transformed, linkedTransformInput, reusedLinkedTransform);
-	transformed = linked.transformed;
-	linkedTransformInput = linked.input;
-	transformed = await sealWakeAggregate(request, transformed, linkedTransformInput, linked.linkedChildHasBrowserTriggers);
-	registerFinalTransformArtifacts(request, transformed);
-	recordLinkedTransform(request, transformed, linkedTransformInput, linked);
-	return await emitTransformResult(request, transformed, linked.resolvedChildren);
-}
-function transformNonTsrxModule(ctx, pluginContext, code, id, currentEnvironment) {
-	const { internalOptions } = ctx;
-	const { executionLogEstimatedSizes, executionLogEmittedIds } = ctx.state;
-	if (currentEnvironment === "client" && internalOptions.dev !== true && internalOptions.prerender === true && normalizeExecutionLogMode(internalOptions.executionLog) !== "never" && pluginContext.getModuleInfo(id)?.isEntry === true) return {
-		code: `${code}\nglobalThis.__mxLoadLog ||= () => import(${JSON.stringify(MARKLESS_EXECUTION_LOG_MODULE_ID)});\nglobalThis.__mxLoadLog().then(log => log.logMarklessRenderSummary());`,
-		map: null
-	};
-	if (currentEnvironment === "client" && normalizeExecutionLogMode(internalOptions.executionLog) !== "never" && isMarklessRuntimeModule(id)) {
-		executionLogEstimatedSizes.set(executionLogRuntimeModuleId(id), code.length);
-		executionLogEmittedIds.set(executionLogRuntimeModuleId(id), pathname(id));
-		return {
-			code: injectExecutionLogModuleHook(code, executionLogRuntimeModuleId(id), internalOptions.executionLog),
-			map: null
-		};
-	}
-	return null;
-}
-async function runFirstPassTransform(request) {
-	const { ctx, pluginContext, code, source, currentEnvironment, plan, transformInput } = request;
-	const { internalOptions } = ctx;
-	const { moduleMetadata, moduleLinkArtifacts, linkedTransformCache } = ctx.state;
-	const { cacheKey, manifestSource } = plan;
-	const cached = linkedTransformCache.get(cacheKey);
-	let linkedTransformResult;
-	let linkedTransformInput = transformInput;
-	let reusedLinkedTransform = false;
-	if (cached?.code === code) {
-		const cachedImports = await resolveImportedModuleInterfaces(pluginContext, manifestSource, cached.result.moduleImports, fallbackImportedSource);
-		await forceImportedModules(pluginContext, cachedImports, moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
-		const cachedLink = linkedInterfaces(cachedImports, moduleLinkArtifacts, linkedInterfaceClaims(cachedImports, moduleMetadata));
-		if (cached.importedInterfaceHashes === cachedLink.signature && cached.importedSymbolClaims === cachedLink.claimSignature) {
-			linkedTransformResult = cached.result;
-			linkedTransformInput = cached.input;
-			reusedLinkedTransform = true;
-		}
-	}
-	if (linkedTransformResult === void 0) try {
-		linkedTransformResult = await transformTsrxModule(transformInput);
-	} catch (error) {
-		let provisional;
-		try {
-			provisional = await compileTsrxModuleLinkArtifact(transformInput);
-		} catch {
-			throw error;
-		}
-		moduleLinkArtifacts.set(source, provisional);
-		const provisionalImports = await resolveImportedModuleInterfaces(pluginContext, manifestSource, provisional.moduleImports, fallbackImportedSource);
-		let provisionalBarrels;
-		try {
-			provisionalBarrels = await linkBarrelComponentInterfaces(pluginContext, manifestSource, provisional.moduleImports, moduleLinkArtifacts, internalOptions.buildId);
-		} catch {
-			throw error;
-		}
-		const provisionalChildren = mergeLinkedModuleChildren(provisionalImports, provisionalBarrels.children);
-		if (provisionalChildren.length === 0 && Object.keys(provisionalBarrels.interfaces).length === 0) throw error;
-		await forceImportedModules(pluginContext, provisionalChildren, moduleLinkArtifacts, moduleMetadata, internalOptions, currentEnvironment);
-		linkedTransformInput = {
-			...transformInput,
-			importedModuleInterfaces: {
-				...provisionalBarrels.interfaces,
-				...linkModuleGraph(provisionalChildren, {
-					moduleArtifacts: moduleLinkArtifacts,
-					metadata: moduleMetadata
-				}).interfaces
-			}
-		};
-		linkedTransformResult = await transformTsrxModule(linkedTransformInput);
-	}
-	return {
-		result: linkedTransformResult,
-		input: linkedTransformInput,
-		reused: reusedLinkedTransform
-	};
-}
-//#endregion
-//#region src/rolldown.ts
-const marklessClient = (options = {}) => createMarklessRolldownPlugin({
-	environment: "client",
-	options
-});
-const marklessServer = (options = {}) => createMarklessRolldownPlugin({
-	environment: "server",
-	options
-});
-const marklessLib = (options = {}) => createMarklessRolldownPlugin({
-	environment: "lib",
-	options
-});
-function createMarklessRolldownPlugin(input) {
-	const environment = input.environment;
-	const internalOptions = input.options ?? {};
-	const state = createPluginState();
-	const { importedChildren, clientSymbolEntrySources } = state;
-	const dev = createMarklessDevGraph();
-	const linkedChildren = importedChildren;
-	let root = internalOptions.rootDir;
-	const name = pluginName(environment);
-	function getEnvironment(context) {
-		if (typeof environment === "function") return environment(context);
-		return environment;
-	}
-	function getRoot() {
-		return root ?? internalOptions.rootDir;
-	}
-	function attributionTables(manifests) {
-		return computeExecutionAttribution({
-			moduleManifests: manifests,
-			childTable: importedChildren.values(),
-			root: getRoot(),
-			resolveSpecifier: fallbackImportedSource,
-			encodeSource: encodedSymbolSource
-		}).tables;
-	}
-	const context = {
-		state,
-		internalOptions,
-		dev,
-		environment,
-		linkedChildren,
-		prerenderRecordsBySource: input.prerenderRecordsBySource,
-		getEnvironment,
-		getRoot,
-		attributionTables
-	};
-	return {
-		api: { invalidateGeneratedModules(parent, currentEnvironment, nextSource) {
-			if (nextSource !== void 0) return invalidateEditedGeneratedModules(context, parent, currentEnvironment, nextSource);
-			return invalidateAllGeneratedModules(context, parent, currentEnvironment);
-		} },
-		name,
-		options(input) {
-			if (getEnvironment(this) !== "client") return input;
-			return {
-				...input,
-				preserveEntrySignatures: input.preserveEntrySignatures ?? "allow-extension"
-			};
-		},
-		async buildStart(input) {
-			if (!root) root = internalOptions.rootDir ?? input.cwd;
-			state.reset();
-			dev.reset();
-			const currentRoot = getRoot();
-			if (getEnvironment(this) === "client") for (const source of clientSymbolEntries(input.input, currentRoot)) clientSymbolEntrySources.add(source);
-		},
-		outputOptions(output) {
-			return outputDefaults(output, getEnvironment(this));
-		},
-		async resolveId(source, importer) {
-			return await resolveIdHook(context, this, source, importer);
-		},
-		async load(id) {
-			return await loadHook(context, this, id);
-		},
-		async transform(code, id) {
-			return await transformHook(context, this, code, id);
-		},
-		generateBundle: {
-			order: "post",
-			async handler(_, bundle) {
-				await generateBundleHook(context, this, bundle);
-			}
-		}
-	};
-}
-function pluginName(environment) {
-	if (typeof environment === "function") return "markless:rolldown";
-	return `markless:rolldown:${environment}`;
-}
-//#endregion
-export { createBuildMetadata as a, createPreloadGraphAdder as c, MARKLESS_BUILD_PREFIX as d, MARKLESS_BUNDLE_GRAPH as f, marklessServer as i, preflightTsrxModuleDiagnostics as l, marklessClient as n, collectHeadLinkInjections as o, outputDefaults as p, marklessLib as r, convertManifestToBundleGraph as s, createMarklessRolldownPlugin as t, transformTsrxModule as u };