@markless/bundler 0.3.2 → 0.4.0

package/dist/rolldown.d.ts

@@ -9,6 +9,9 @@ type BuiltPrerenderRecords = {
   readonly view: ProtocolViewPayload;
 };
 //#endregion
+//#region src/hooks/hook-context.d.ts
+type Environment = MarklessEnvironment | ((context: unknown) => MarklessEnvironment);
+//#endregion
 //#region src/build/chunking.d.ts
 declare const MARKLESS_BUILD_PREFIX = "build/";
 declare const MARKLESS_BUNDLE_GRAPH = "build/bundle-graph.json";
@@ -71,7 +74,6 @@ declare function collectHeadLinkInjections(bundle: HeadLinkBundle, options?: {
 declare function transformTsrxModule(input: TransformTsrxModuleInput): Promise<TransformTsrxModuleResult>;
 //#endregion
 //#region src/rolldown.d.ts
-type Environment = MarklessEnvironment | ((context: unknown) => MarklessEnvironment);
 type MarklessRolldownPlugin = Plugin & {
   api: MarklessRolldownPluginApi;
 };

package/dist/rolldown.js

@@ -1,3 +1,3 @@
-import { l as resumeVirtualModuleId, s as prerenderWakeVirtualModuleId, t as MARKLESS_VIRTUAL_PREFIX } from "./source-module-BCEdLQvG.js";
-import { a as createBuildMetadata, c as collectHeadLinkInjections, d as outputDefaults, f as convertManifestToBundleGraph, i as marklessServer, l as MARKLESS_BUILD_PREFIX, n as marklessClient, p as createPreloadGraphAdder, r as marklessLib, s as transformTsrxModule, t as createMarklessRolldownPlugin, u as MARKLESS_BUNDLE_GRAPH } from "./rolldown-DAsY_7V1.js";
+import { l as resumeVirtualModuleId, s as prerenderWakeVirtualModuleId, t as MARKLESS_VIRTUAL_PREFIX } from "./source-module-DI20i0ZG.js";
+import { a as createBuildMetadata, c as createPreloadGraphAdder, d as MARKLESS_BUILD_PREFIX, f as MARKLESS_BUNDLE_GRAPH, i as marklessServer, n as marklessClient, o as collectHeadLinkInjections, p as outputDefaults, r as marklessLib, s as convertManifestToBundleGraph, t as createMarklessRolldownPlugin, u as transformTsrxModule } from "./rolldown-CB2Xpf-E.js";
 export { MARKLESS_BUILD_PREFIX, MARKLESS_BUNDLE_GRAPH, MARKLESS_VIRTUAL_PREFIX, collectHeadLinkInjections, convertManifestToBundleGraph, createBuildMetadata, createMarklessRolldownPlugin, createPreloadGraphAdder, marklessClient, marklessLib, marklessServer, outputDefaults, prerenderWakeVirtualModuleId, resumeVirtualModuleId, transformTsrxModule };

package/dist/{source-module-BCEdLQvG.js → source-module-DI20i0ZG.js}

@@ -479,14 +479,20 @@ function payloadModule(payload) {
 		""
 	].join("\n");
 }
+/** The module-local name a direct-CSR module's root renders under. */
+function csrRootLocalName(rootExportName) {
+	return `marklessCsr${rootExportName}`;
+}
 function emitPublicRenderModule(source, input) {
-	if (!input.executionLogEnabled || !input.rootExportName) return source;
+	if (!input.rootExportName) return source;
 	const declaration = `export function ${input.rootExportName}()`;
-	if (!source.includes(declaration)) return source;
+	if (!source.includes(declaration)) throw new Error(`MARKLESS_CSR_ROOT_DECLARATION_MISSING: ${input.rootExportName}`);
+	const localName = csrRootLocalName(input.rootExportName);
+	if (!input.executionLogEnabled) return source.replace(declaration, `function ${localName}()`);
 	const implementationName = `marklessRender${input.rootExportName}`;
 	return [
 		source.replace(declaration, `function ${implementationName}()`),
-		`export function ${input.rootExportName}() {`,
+		`function ${localName}() {`,
 		`\tconst output = ${implementationName}();`,
 		"	globalThis.__mxLoadLog().then(log => log.logMarklessRenderSummary());",
 		"	return output;",
@@ -501,9 +507,13 @@ function emitSourceModule(input) {
 	const symbolsOnly = input.environment === "client" && input.clientOutput === "symbols-only";
 	const routeSymbols = input.environment === "client" && input.symbolRoutes.length > 0;
 	const canonicalRenderData = input.environment === "client" && !symbolsOnly && !input.prerenderRecords && input.canonicalRenderData === true && input.publicRenderRootExportName === null && !!input.publicSsrModuleSource && !!input.renderDataId;
+	const emitsSsrBody = !!input.publicSsrModuleSource && !(input.environment === "client" && (symbolsOnly || !input.prerenderRecords && !input.dev));
+	const csrRootName = input.environment !== "server" && !symbolsOnly && !input.prerenderRecords && input.publicRenderRootExportName ? csrRootLocalName(input.publicRenderRootExportName) : null;
 	return [
-		!input.publicSsrModuleSource && !input.publicRenderModuleSource || symbolsOnly || !input.renderDataId || input.environment === "client" && !input.publicRenderModuleSource && !input.prerenderRecords && !input.dev && !canonicalRenderData ? "" : canonicalRenderData ? `import { marklessPrerenderData } from '${input.renderDataId}';` : `import { marklessRenderData } from '${input.renderDataId}';`,
+		!input.publicSsrModuleSource && !input.publicRenderModuleSource || symbolsOnly || !input.renderDataId || input.environment === "client" && !input.publicRenderModuleSource && !input.prerenderRecords && !input.dev && !canonicalRenderData ? "" : canonicalRenderData ? emitsSsrBody ? `import { marklessPrerenderData, marklessRenderData } from '${input.renderDataId}';` : `import { marklessPrerenderData } from '${input.renderDataId}';` : `import { marklessRenderData } from '${input.renderDataId}';`,
 		symbolsOnly ? "" : `import { state as payloadState, view as payloadView, runtimeDemandMap as payloadRuntimeDemandMap } from '${input.payloadId}';`,
+		input.environment === "client" && input.directCsr === true && input.hasComputedState === true ? ["import { installMarklessDerivedReconcile } from '@markless/web/fns/reconcile-plane';", "installMarklessDerivedReconcile();"].join("\n") : null,
+		input.environment === "client" && input.hasOverlayMarks === true ? emitOverlayLoaderInstall() : null,
 		"",
 		emitLoadSymbol(input),
 		input.behaviorSymbols?.length ? emitDirectSourceSymbolLoader(input.behaviorSymbols, "readMarklessBehaviorSourceSymbol").replace("function loadSymbol(", "function loadBehaviorSymbol(") : "",
@@ -518,8 +528,9 @@ function emitSourceModule(input) {
 			executionLogEnabled: input.executionLog !== "never",
 			rootExportName: input.publicRenderRootExportName
 		}),
-		input.environment === "client" && (symbolsOnly || !input.prerenderRecords && !input.dev) ? "" : input.publicSsrModuleSource,
+		emitsSsrBody ? input.publicSsrModuleSource : "",
 		routeSymbols ? emitLazySymbolRouteFunction(input.symbolRoutes, "marklessSsrLoadSymbolRoute", "marklessLoadLocalSymbol") : "",
+		routeSymbols && !symbolsOnly && input.directCsr === true ? emitComposedArmRecordsInstall() : null,
 		symbolsOnly && routeSymbols ? "export { marklessSsrLoadSymbolRoute as loadSymbol };" : "",
 		symbolsOnly ? "" : emitCompiledAppDefault({
 			environment: input.environment,
@@ -531,28 +542,111 @@ function emitSourceModule(input) {
 			resumeModuleUrl: input.resumeModuleUrl,
 			prerenderWakeModuleUrl: input.prerenderWakeModuleUrl,
 			rootExportName: input.publicRenderRootExportName,
+			csrRootName,
 			symbolLoaderName: routeSymbols ? "marklessSsrLoadSymbolRoute" : "loadSymbol",
 			ssrExportName: input.publicRenderSsrExportName,
+			ssrComponents: input.publicRenderSsrComponentExports ?? [],
 			canonicalRenderData,
 			prerenderRecords: input.prerenderRecords,
 			dev: input.dev
 		}),
+		...emitSharedDefinitionExports(input.sharedDefinitionExports ?? [], input.publicRenderSsrComponentExports ?? []),
 		""
 	].filter((line) => line !== null).join("\n");
 }
+const MARKLESS_SHARED_CALL_UNCOMPILED = "MARKLESS_SHARED_CALL_UNCOMPILED";
+/**
+* One real ES named export per authored shared definition, bound to a callable
+* that only ever throws.
+*
+* The export exists for two reasons, and neither is "run the definition".
+* Linking first: a `.ts` barrel writing `export { nscShared as state } from
+* './family.tsrx'` is resolved before anything runs, and the emitted module
+* replacing the authored one wholesale made that a SyntaxError. Failing closed
+* second: a compiled consumer's `family.state()` is lowered by the compiler and
+* never reaches this binding, so anything that DOES reach it is an uncompiled
+* call site, which cannot be served correctly — a shared instance resolves
+* against the widget the caller renders under, and an uncompiled call has no
+* such caller. It throws by name rather than quietly becoming a second,
+* unratified runtime API.
+*/
+function emitSharedDefinitionExports(sharedExports, ssrComponents) {
+	if (sharedExports.length === 0) return [];
+	const taken = new Set([...RESERVED_MODULE_BINDINGS, ...ssrComponents.map((component) => component.exportName)]);
+	return sharedExports.map((name) => {
+		if (taken.has(name)) throw new Error(`MARKLESS_SHARED_EXPORT_NAME_RESERVED: ${name}`);
+		taken.add(name);
+		const message = `${MARKLESS_SHARED_CALL_UNCOMPILED}: ${name} — a shared definition can only be called from a compiled module; this call site was not compiled.`;
+		return `export const ${name} = () => { throw new Error(${JSON.stringify(message)}); };`;
+	});
+}
+/**
+* Whether this app's serialized state defines any computed node. Computed
+* definitions are what `createRuntimeGraph` turns into derived graph nodes on
+* resume, so they are exactly the apps derived reconciliation can act on.
+*/
+function payloadHasComputed(payloadState) {
+	const computed = payloadState?.computed;
+	return Array.isArray(computed) && computed.length > 0;
+}
+/**
+* The one line that makes elevation cost nothing until it is used.
+*
+* Writing the `import()` specifier HERE rather than in the runtime is the whole
+* mechanism: a module every app loads cannot name the behaviour without making
+* every app ship its chunk. The handoff is a global rather than a slot module
+* for the same reason - a slot module is bytes every app pays for a capability
+* most of them do not have. Nothing is fetched until the runtime calls it.
+*/
+function emitOverlayLoaderInstall() {
+	return [
+		"globalThis.__marklessOverlay = (root) =>",
+		"	root.querySelector('[overlay]')",
+		"		? import('@markless/web/fns/overlay').then((m) => m.installOverlayBehavior(root))",
+		"		: undefined;"
+	].join("\n");
+}
+/**
+* The same one line for the row mint, and for the same reason.
+*
+* `resume-keyed-repeats` is loaded by EVERY repeat, so it cannot name the
+* building half: doing so makes an app whose rows only reorder emit the mint
+* chunk anyway. Written here, the specifier exists only in a build the compiler
+* recorded a mintable repeat for; the repeat runtime reads the loader off the
+* global and refuses to build without one.
+*/
+function emitRowMintLoaderInstall() {
+	return "globalThis.__marklessRowMint = () => import('@markless/web/fns/row-mint');";
+}
+/**
+* True when the compiler folded the mint into a keyed-repeat record - which it
+* does exactly for a record carrying `rowTemplate` or `emptyArm`, the two fields
+* that make a repeat able to build nodes.
+*/
+function demandsRowMint(runtimeDemandMap) {
+	const records = runtimeDemandMap?.payloadRecords;
+	return Array.isArray(records) && records.some((record) => record.kind === "keyed-repeat" && record.runtimeModuleIds?.includes(ROW_MINT_RUNTIME_MODULE_ID) === true);
+}
+const ROW_MINT_RUNTIME_MODULE_ID = "web/fns/row-mint";
+/** True when the compiler recorded an `overlay` mark for this module. */
+function demandsOverlay(runtimeDemandMap) {
+	const records = runtimeDemandMap?.payloadRecords;
+	return Array.isArray(records) && records.some((record) => record.kind === "overlay");
+}
 function emitResumeModule(input) {
 	const routeSymbols = input.symbolRoutes.length > 0;
 	const resumeSymbolLoader = routeSymbols ? "marklessSsrLoadSymbolRoute" : "loadSymbol";
 	const scalarSpecializations = scalarDispatcherSpecializations(input);
 	const stagedPrerender = (input.prerenderTriggerGroups?.length ?? 0) > 0;
-	const streamedResume = stagedPrerender || (input.payloadView?.asyncBoundaries?.length ?? 0) > 0;
-	const bareResumeContainerEvent = emitResumeContainerEvent(resumeSymbolLoader, input.needsFullResume ?? false, input.payloadState?.version === ASYNC_PROTOCOL_VERSION, input.symbolRoutes.length > 0 ? "none" : leanResumeMode(input.runtimeDemandMap), scalarSpecializations, input.runtimeDemandMap, input.executionLog !== "never", input.prerenderDataId, stagedPrerender);
-	const resumeContainerEvent = streamedResume ? emitQueuedResumeContainerEvent(bareResumeContainerEvent) : bareResumeContainerEvent;
+	const resumeContainerEvent = emitQueuedResumeContainerEvent(emitResumeContainerEvent(resumeSymbolLoader, input.needsFullResume ?? false, input.payloadState?.version === ASYNC_PROTOCOL_VERSION, input.symbolRoutes.length > 0 ? "none" : leanResumeMode(input.runtimeDemandMap), scalarSpecializations, input.runtimeDemandMap, input.executionLog !== "never", input.prerenderDataId, stagedPrerender));
 	return [
 		input.boundSymbolDescriptors ? `export const ${MARKLESS_BOUND_SYMBOLS_EXPORT} = ${emitBoundSymbolDescriptors(input.boundSymbolDescriptors)};` : null,
 		input.prerenderDataId && !stagedPrerender && resumeContainerEvent.includes("marklessPrerenderData") ? `import { marklessPrerenderData } from '${input.prerenderDataId}';` : null,
 		stagedPrerender && input.prerenderDataId ? `async function marklessLoadPrerenderData() { const module = await import('${input.prerenderDataId}'); return module.marklessPrerenderData; }` : null,
 		`import { runtimeDemandMap as payloadRuntimeDemandMap } from '${input.payloadId}';`,
+		payloadHasComputed(input.payloadState) ? ["import { installMarklessDerivedReconcile } from '@markless/web/fns/reconcile-plane';", "installMarklessDerivedReconcile();"].join("\n") : null,
+		demandsOverlay(input.runtimeDemandMap) ? emitOverlayLoaderInstall() : null,
+		demandsRowMint(input.runtimeDemandMap) ? emitRowMintLoaderInstall() : null,
 		scalarSpecializations.length > 0 ? [
 			"import { marklessDecodeScalarCell, marklessReadScalarCell, marklessScalarSpecializedError } from '@markless/web/fns/scalar-specialized';",
 			"import { marklessWriteScalar } from '@markless/web/fns/write-scalar';",
@@ -567,6 +661,7 @@ function emitResumeModule(input) {
 		routeSymbols ? "const marklessLoadLocalSymbol = loadSymbol;" : "",
 		routeSymbols ? emitLazySymbolRouteFunction(input.symbolRoutes, "marklessSsrLoadSymbolRoute", "marklessLoadLocalSymbol") : "",
 		routeSymbols ? "export { marklessSsrLoadSymbolRoute as loadSymbol };" : "",
+		routeSymbols ? emitComposedArmRecordsInstall() : null,
 		stagedPrerender ? emitPrerenderTriggerGroupLoader(input.prerenderTriggerGroups ?? []) : "",
 		resumeContainerEvent,
 		""
@@ -601,13 +696,17 @@ function emitQueuedResumeContainerEvent(source) {
 		"}"
 	].join("\n");
 }
+function emitComposedArmRecordsInstall() {
+	return ["import { installMarklessComposedArmRecords } from '@markless/web/fns/instance-scope';", "installMarklessComposedArmRecords();"].join("\n");
+}
 function emitLazySymbolRouteFunction(routes, functionName, fallbackName = "loadSymbol") {
 	if (routes.length === 0) return "";
+	const ordered = [...routes].sort((left, right) => right.prefix.length - left.prefix.length);
 	return [
 		`function ${functionName}(symbolId) {`,
-		...routes.flatMap((route) => [
+		...ordered.flatMap((route) => [
 			`	if (symbolId.startsWith(${JSON.stringify(route.prefix)})) {`,
-			`		return 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}\`)));`,
+			"importSource" in route ? `		return 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}\`)));` : `		return ${route.prefix.length > 0 ? functionName : fallbackName}(symbolId.slice(${route.prefix.length}));`,
 			"	}"
 		]),
 		`	return ${fallbackName}(symbolId);`,
@@ -618,14 +717,16 @@ function symbolRouteImportSource(importSource) {
 	return importSource.includes("?") ? `${importSource}&markless-symbols` : `${importSource}?markless-symbols`;
 }
 function emitCompiledAppDefault(input) {
-	const renderCsrEntry = input.rootExportName && input.environment !== "server" && !input.prerenderRecords ? [`	renderCsr: ${input.rootExportName},`] : [];
+	const renderCsrEntry = input.csrRootName ? [`	renderCsr: ${input.csrRootName},`] : [];
 	const symbolLoaderEntry = input.environment !== "server" && input.rootExportName === null ? [`\tloadSymbol: ${input.symbolLoaderName},`] : input.prerenderRecords === true ? [`\tloadSymbol: ${input.symbolLoaderName},`] : [];
 	const renderDataEntry = input.canonicalRenderData ? ["	renderData: marklessPrerenderData,"] : [];
-	const renderSsrEntry = input.ssrExportName && (input.environment !== "client" || input.prerenderRecords || input.dev) ? [
+	const servesSsr = !!input.ssrExportName && (input.environment !== "client" || input.prerenderRecords || input.dev);
+	const renderSsrEntry = servesSsr ? [
 		"	renderSsr(props, marklessRenderContext) {",
 		`		return ${input.ssrExportName}(props, marklessRenderContext);`,
 		"	},"
 	] : [];
+	const renderSsrComponentsEntry = servesSsr && input.ssrComponents.length > 0 ? [`	renderSsrComponents: { ${input.ssrComponents.map((component) => `${JSON.stringify(component.exportName)}: { renderSsr: ${component.ssrFunctionName} }`).join(", ")} },`] : [];
 	const resumeModuleEntry = input.resumeModuleUrl && input.environment !== "client" ? [`	resumeModuleUrl: ${JSON.stringify(input.resumeModuleUrl)},`] : [];
 	const prerenderWakeModuleEntry = input.prerenderWakeModuleUrl && input.environment !== "client" ? [`\tprerenderWakeModuleUrl: ${JSON.stringify(input.prerenderWakeModuleUrl)},`] : [];
 	const inlineResumerEntry = input.inlineResumerSources && input.environment !== "client" ? [`\tinlineResumerSources: ${JSON.stringify(input.inlineResumerSources)},`] : [];
@@ -650,11 +751,57 @@ function emitCompiledAppDefault(input) {
 		...renderDataEntry,
 		...symbolLoaderEntry,
 		...renderSsrEntry,
+		...renderSsrComponentsEntry,
 		...metadataEntries,
 		"};",
-		"export default marklessCompiledApp;"
+		"export default marklessCompiledApp;",
+		...emitComponentExports({
+			ssrComponents: input.ssrComponents,
+			rootExportName: input.ssrComponents.find((component) => component.ssrFunctionName === input.ssrExportName)?.exportName,
+			servesSsr: !!servesSsr
+		})
 	].join("\n");
 }
+const RESERVED_MODULE_BINDINGS = new Set([
+	"loadBehaviorSymbol",
+	"loadSymbol",
+	"marklessCompiledApp",
+	"marklessLoadLocalSymbol",
+	"marklessPrerenderData",
+	"marklessRenderData",
+	"marklessRenderSsr",
+	"marklessSsrLoadSymbolRoute",
+	"payloadRuntimeDemandMap",
+	"payloadState",
+	"payloadView",
+	"readMarklessBehaviorSourceSymbol",
+	"resumeContainerEvent"
+]);
+/**
+* One real ES named export per component the module serves, so plain ESM reaches
+* them: a `.ts` barrel writing `export { CheckboxRoot as root } from
+* './checkbox.tsrx'`, and an app writing `import { Gallery } from
+* './Gallery.tsrx'`, are both named reads the bundler resolves at LINK time.
+* Publishing components only on the default export's map answered neither
+* (MISSING_EXPORT at build, "does not provide an export named" in the browser).
+*
+* The root is published merged - the module surface plus its own part's
+* `renderSsr` - because both consumers reach it by that one name: `render(Gallery,
+* { target })` reads the surface (`renderCsr`/`renderData`/`loadSymbol`), while a
+* barrel re-export composed as a member tag reads the part. Every other component
+* is published as exactly the part `marklessSsrComponentPart` hands a composed
+* child, through the same access path, so a named import and a member tag reach
+* one object.
+*/
+function emitComponentExports(input) {
+	return input.ssrComponents.map((component) => {
+		if (RESERVED_MODULE_BINDINGS.has(component.exportName)) throw new Error(`MARKLESS_COMPONENT_EXPORT_NAME_RESERVED: ${component.exportName}`);
+		const part = `marklessCompiledApp.renderSsrComponents[${JSON.stringify(component.exportName)}]`;
+		const isRoot = component.exportName === input.rootExportName;
+		if (input.servesSsr) return `export const ${component.exportName} = ${isRoot ? `{ ...marklessCompiledApp, renderSsr: ${part}.renderSsr }` : part};`;
+		return isRoot ? `export const ${component.exportName} = marklessCompiledApp;` : `export const ${component.exportName} = { marklessCsrOnlyPart: ${JSON.stringify(component.exportName)} };`;
+	});
+}
 function emitResumeContainerEvent(loadSymbolName, needsFullResume, storageFreePayload, leanMode, scalarSpecializations, runtimeDemandMap, executionLogEnabled, prerenderDataId, stagedPrerender = false) {
 	const fullResumeHandoff = stagedPrerender && prerenderDataId ? [
 		"async function marklessFullResumeHandoff(handoff) {",

package/dist/vite.js

@@ -1,22 +1,34 @@
 import { MARKLESS_DEV_ERROR_CLEAR_EVENT, MARKLESS_DEV_ERROR_CLIENT_ID, MARKLESS_DEV_ERROR_EVENT, normalizeMarklessDevError, renderMarklessDevErrorDocument } from "./dev-error.js";
-import { _ as executionLogActivationInjection } from "./source-module-BCEdLQvG.js";
-import { d as outputDefaults, o as preflightTsrxModuleDiagnostics, p as createPreloadGraphAdder, t as createMarklessRolldownPlugin } from "./rolldown-DAsY_7V1.js";
+import { _ as executionLogActivationInjection } from "./source-module-DI20i0ZG.js";
+import { c as createPreloadGraphAdder, l as preflightTsrxModuleDiagnostics, p as outputDefaults, t as createMarklessRolldownPlugin } from "./rolldown-CB2Xpf-E.js";
 import { joinURL, parsePath, withQuery } from "ufo";
 import { ASYNC_PROTOCOL_VERSION, STORAGE_SLOT_SYMBOL_KEY, serializeRuntimeAsyncSnapshots, serializeRuntimeStateCells, storageAttributeName } from "@markless/serializer";
-import { pathToFileURL } from "node:url";
 import { join, resolve } from "pathe";
+import { isAbsolute as isAbsolute$1 } from "node:path";
+import { pathToFileURL } from "node:url";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { PROTOCOL_EVENT_ACTION_KIND as PROTOCOL_EVENT_ACTION_KIND$1, protocolEventDispatchesMarkless } from "@markless/serializer/protocol";
 import "@markless/serializer/resume-record-delta";
 import { deserializeGraphValueForClient } from "@markless/serializer/decode-client";
 import { createServerModuleRunner, isRunnableDevEnvironment } from "vite";
-import { isAbsolute as isAbsolute$1 } from "node:path";
 //#region ../web/src/inline/resumer.ts
 PROTOCOL_EVENT_ACTION_KIND$1.event, PROTOCOL_EVENT_ACTION_KIND$1.externalDelegate;
 function createInlineResumerSelfWakeSource(resumeModuleUrl) {
 	return `;(${runInlineResumerSelfWake.toString()})(${JSON.stringify(resumeModuleUrl)});`;
 }
+/**
+* The Escape primer, appended only to a page whose served HTML carries an
+* `overlay` mark.
+*
+* Appended rather than composed into the resumer body for the same reason the
+* self-wake is: the body is serialized whole, so a flag inside it would put the
+* text on every page in the world to serve the few that elevate anything. A page
+* with no mark ships a byte-identical resumer.
+*/
+function createInlineResumerOverlayPrimerSource(resumeModuleUrl) {
+	return `;(${runInlineResumerOverlayPrimer.toString()})(${JSON.stringify(resumeModuleUrl)},(url) => import(/* @vite-ignore */ url));`;
+}
 const PRERENDER_INLINE_EVENT_NAMES_TOKEN = "__MARKLESS_PRERENDER_EVENT_NAMES__";
 function renderPrerenderInlineResumerSource(compiled, eventNames) {
 	return compiled.replace(PRERENDER_INLINE_EVENT_NAMES_TOKEN, JSON.stringify(eventNames));
@@ -114,9 +126,10 @@ function runPrerenderInlineResumer(eventNames, fallbackResumeModuleUrl, loadModu
 	const root = currentScript?.closest("[data-async-container]");
 	const resumeModuleUrl = currentScript?.getAttribute?.("data-markless-resume-module") ?? fallbackResumeModuleUrl;
 	if (!root || !resumeModuleUrl) return;
+	let loaded;
 	for (const eventName of eventNames) root.addEventListener(eventName, (event) => {
 		root.__marklessDelegatedDispatch = true;
-		return loadModule(resumeModuleUrl).then((module) => module.resumeContainerEvent({
+		return (loaded ||= loadModule(resumeModuleUrl)).then((module) => module.resumeContainerEvent({
 			root,
 			event,
 			element: event.target,
@@ -146,6 +159,45 @@ function runInlineResumerSelfWake(fallbackResumeModuleUrl) {
 	if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", wake, { once: true });
 	else wake();
 }
+/**
+* One window-level listen, from first paint, on a page that elevates something.
+*
+* Two facts make it necessary. A page served with an open overlay is on the
+* stack the moment the behaviour installs, but nothing installs until the
+* runtime wakes; and Escape is the one gesture with no route into the page -
+* every other one reaches an authored handler through the container's own
+* listener, while a dismissal is reported by a document listener that does not
+* exist yet. So the first Escape on such a page would be spent waking and
+* dismiss nothing. This listens above the container, leaves the reason where the
+* behaviour's installer takes it, and lets the wake finish the job.
+*
+* Deliberately one-shot, and deliberately not the waker of first resort. The
+* container's own capture listener runs after this one and wakes the runtime for
+* any event the page has a record for; waking here as well would start a second
+* runtime for one gesture. Deciding a task later is what tells the two apart.
+*/
+function runInlineResumerOverlayPrimer(fallbackResumeModuleUrl, loadModule) {
+	const currentScript = document.currentScript;
+	const root = currentScript?.closest("[data-async-container]");
+	const resumeModuleUrl = currentScript?.getAttribute?.("data-markless-resume-module") ?? fallbackResumeModuleUrl;
+	if (!root || !resumeModuleUrl) return;
+	const prime = (event) => {
+		removeEventListener("keydown", prime, true);
+		removeEventListener("pointerdown", prime, true);
+		if (root.__marklessDelegatedDispatch) return;
+		if (event.key === "Escape") globalThis.__marklessOverlayPrimedDismissal = "escape";
+		setTimeout(() => {
+			if (root.__marklessDelegatedDispatch) return;
+			root.__marklessDelegatedDispatch = true;
+			loadModule(resumeModuleUrl).then((module) => module.resumeContainerEvent({
+				root,
+				event: 0
+			}));
+		});
+	};
+	addEventListener("keydown", prime, true);
+	addEventListener("pointerdown", prime, true);
+}
 //#endregion
 //#region ../web/src/repeat-runtime.ts
 var KeyedRepeatRuntimeError = class extends Error {
@@ -396,8 +448,14 @@ function browserEventNames(view) {
 function renderContainerAttributes(containerId) {
 	return containerId ? ` data-async-container="${escapeAttribute(containerId)}"` : " data-async-container";
 }
-function renderInlineResumerScript(source, nonce, resumeModuleUrl, selfWake, settleModuleUrl, appendSelfWakeSource = true) {
-	return `<script data-async-resumer${nonce ? ` nonce="${escapeAttribute(nonce)}"` : ""}${resumeModuleUrl ? ` data-markless-resume-module="${escapeAttribute(resumeModuleUrl)}"` : ""}${settleModuleUrl ? ` data-markless-settle-module="${escapeAttribute(settleModuleUrl)}"` : ""}${selfWake ? " data-markless-self-wake" : ""}>${escapeInlineScript(source + (selfWake && appendSelfWakeSource ? createInlineResumerSelfWakeSource(resumeModuleUrl) : ""))}<\/script>`;
+function renderInlineResumerScript(source, nonce, resumeModuleUrl, selfWake, settleModuleUrl, appendSelfWakeSource = true, overlayPrimer = false) {
+	const nonceAttribute = nonce ? ` nonce="${escapeAttribute(nonce)}"` : "";
+	const resumeModuleAttribute = resumeModuleUrl ? ` data-markless-resume-module="${escapeAttribute(resumeModuleUrl)}"` : "";
+	const settleModuleAttribute = settleModuleUrl ? ` data-markless-settle-module="${escapeAttribute(settleModuleUrl)}"` : "";
+	const selfWakeAttribute = selfWake ? " data-markless-self-wake" : "";
+	const selfWakeSource = selfWake && appendSelfWakeSource ? createInlineResumerSelfWakeSource(resumeModuleUrl) : "";
+	const overlayPrimerSource = overlayPrimer ? createInlineResumerOverlayPrimerSource(resumeModuleUrl) : "";
+	return `<script data-async-resumer${nonceAttribute}${resumeModuleAttribute}${settleModuleAttribute}${selfWakeAttribute}>${escapeInlineScript(source + selfWakeSource + overlayPrimerSource)}<\/script>`;
 }
 function escapeAttribute(value) {
 	return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@markless/bundler",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Markless build plugins for Rolldown and Vite.",
   "license": "MIT",
   "repository": {
@@ -39,12 +39,12 @@
     "@thi.ng/dgraph": "^2.1.205",
     "pathe": "^2.0.3",
     "ufo": "^1.6.4",
-    "@markless/compiler": "0.3.2",
-    "@markless/web": "0.3.2",
-    "@markless/serializer": "0.3.2"
+    "@markless/compiler": "0.4.0",
+    "@markless/serializer": "0.4.0",
+    "@markless/web": "0.4.0"
   },
   "devDependencies": {
-    "@markless/analyzer": "0.3.2"
+    "@markless/analyzer": "0.4.0"
   },
   "peerDependencies": {
     "rolldown": "1.0.3",