hono-decks 1.0.4 → 1.2.0

package/dist/vite.js

@@ -1,5 +1,8 @@
+import { createRequire } from "node:module";
+import { mkdir, mkdtemp, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
-import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { mergeConfig } from "vite";
+import { build, transform } from "esbuild";
 import { unified } from "unified";
 import remarkGfm from "remark-gfm";
 import remarkMdx from "remark-mdx";
@@ -7,29 +10,28 @@ import remarkParse from "remark-parse";
 import { compile } from "@mdx-js/mdx";
 import remarkDirective from "remark-directive";
 import { codeToHtml } from "shiki";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { build } from "esbuild";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 //#region src/routing/file-routing.ts
-function resolveDeckFiles(paths, root = "decks") {
+function resolveDeckFiles(paths, root = "decks", options = {}) {
 	const normalizedRoot = normalizePath$3(root).replace(/\/$/, "");
 	const decks = /* @__PURE__ */ new Map();
 	const assetsBySlug = /* @__PURE__ */ new Map();
 	for (const inputPath of paths.map(normalizePath$3).sort()) {
 		assertInsideRoot(inputPath, normalizedRoot);
 		const segments = inputPath.slice(normalizedRoot.length + 1).split("/");
-		if (segments.length === 1 && segments[0].endsWith(".mdx")) {
+		if (segments.length === 1 && (segments[0].endsWith(".mdx") || options.markdown && segments[0].endsWith(".md"))) {
 			addDeck(decks, {
-				slug: segments[0].replace(/\.mdx$/, ""),
+				slug: segments[0].replace(/\.mdx?$/, ""),
 				sourcePath: inputPath,
 				kind: "single-file",
 				assetPaths: []
 			});
 			continue;
 		}
-		if (segments.length === 2 && segments[1] === "deck.mdx") {
+		if (segments.length === 2 && (segments[1] === "deck.mdx" || options.markdown && segments[1] === "deck.md")) {
 			addDeck(decks, {
 				slug: segments[0],
 				sourcePath: inputPath,
@@ -47,7 +49,7 @@ function resolveDeckFiles(paths, root = "decks") {
 			if (deck?.kind === "directory") deck.assetPaths = assetPaths;
 			continue;
 		}
-		if (inputPath.endsWith(".mdx")) throw new Error(`Nested deck slugs are not supported in this slice: ${inputPath}`);
+		if (inputPath.endsWith(".mdx") || options.markdown && inputPath.endsWith(".md")) throw new Error(`Nested deck slugs are not supported in this slice: ${inputPath}`);
 	}
 	return [...decks.values()].map((deck) => ({
 		...deck,
@@ -369,6 +371,11 @@ function collectFrontmatterAssetCandidates(value) {
 	if (typeof value === "string") return [value.trim()].filter(Boolean);
 	return [];
 }
+function isLocalRelativeAssetCandidate(value) {
+	if (assetRefType(value)) return false;
+	if (value.startsWith("./") || value.startsWith("../")) return true;
+	return /^[^/:?#]+\.(?:png|jpe?g|gif|svg|webp)(?:[?#].*)?$/i.test(value);
+}
 function contentTypeForPath(path) {
 	const queryIndex = path.indexOf("?");
 	const pathname = (queryIndex === -1 ? path : path.slice(0, queryIndex)).toLowerCase();
@@ -985,8 +992,8 @@ import { configureDecks, defineDecks } from ${JSON.stringify(DECKS_ADVANCED_ENTR
 import type { ConfiguredDecks, DecksConfig } from ${runtimeEntry};
 import type { Env } from "hono";
 import { decksClientEntry } from "./client-entry";
-${input.decks.flatMap((deck) => deck.slideModules.map((slide, index) => `import ${slideImportName(deck.deck.slug, index)} from ${JSON.stringify(slide.importPath)};`)).join("\n")}
-${input.decks.filter((deck) => deck.componentModulePath).map((deck) => `import * as ${componentImportName(deck.deck.slug)} from ${JSON.stringify(deck.componentModulePath)};`).join("\n")}
+${input.decks.flatMap((deck, deckIndex) => deck.slideModules.map((slide, index) => `import ${slideImportName(deckIndex, index)} from ${JSON.stringify(slide.importPath)};`)).join("\n")}
+${input.decks.flatMap((deck, deckIndex) => deck.componentModulePath ? [`import * as ${componentImportName(deckIndex)} from ${JSON.stringify(deck.componentModulePath)};`] : []).join("\n")}
 
 function withClientComponentIds(module, clientIds) {
   const registry = {};
@@ -1006,7 +1013,7 @@ function withClientComponentIds(module, clientIds) {
 const generatedDecks = defineDecks({
   clientEntryAsset: decksClientEntry,
   decks: [
-${input.decks.map(emitDeckObject).join(",\n")}
+${input.decks.map((deck, deckIndex) => emitDeckObject(deck, deckIndex)).join(",\n")}
   ]
 });
 
@@ -1019,15 +1026,16 @@ function definedDecksFor<E extends Env>() {
 }
 `;
 }
-function emitDeckObject(deck) {
+function emitDeckObject(deck, deckIndex) {
 	return `    {
       slug: ${JSON.stringify(deck.deck.slug)},
       sourcePath: ${JSON.stringify(deck.deck.sourcePath)},
       kind: ${JSON.stringify(deck.deck.kind)},
       meta: ${serializeValue(deck.deck.meta, 3)},
+${typeof deck.deck.clientEntryRequired === "boolean" ? `      clientEntryRequired: ${deck.deck.clientEntryRequired},\n` : ""}
 ${deck.deck.themeStyle ? `      "themeStyle": ${serializeValue(deck.deck.themeStyle, 3)},\n` : ""}${deck.deck.themeSourcePath ? `      "themeSourcePath": ${JSON.stringify(deck.deck.themeSourcePath)},\n` : ""}
       assets: ${serializeValue(deck.deck.assets, 3)},
-      componentRegistry: ${deck.componentModulePath ? `withClientComponentIds(${componentImportName(deck.deck.slug)}, ${serializeValue(deck.clientComponentIds ?? {}, 3)})` : "{}"},
+      componentRegistry: ${deck.componentModulePath ? `withClientComponentIds(${componentImportName(deckIndex)}, ${serializeValue(deck.clientComponentIds ?? {}, 3)})` : "{}"},
       warnings: ${serializeValue(deck.deck.warnings, 3)},
       slides: [
 ${deck.deck.slides.map((slide) => `        {
@@ -1036,19 +1044,16 @@ ${deck.deck.slides.map((slide) => `        {
           html: "",
           components: [],
           notes: ${serializeValue(slide.notes, 5)},
-          render: ${slideImportName(deck.deck.slug, slide.index)}
+          render: ${slideImportName(deckIndex, slide.index)}
         }`).join(",\n")}
       ]
     }`;
 }
-function slideImportName(slug, index) {
-	return `Slide_${safeIdentifier$1(slug)}_${index}`;
-}
-function componentImportName(slug) {
-	return `Components_${safeIdentifier$1(slug)}`;
+function slideImportName(deckIndex, slideIndex) {
+	return `Slide_${deckIndex}_${slideIndex}`;
 }
-function safeIdentifier$1(value) {
-	return value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/, "_") || "_";
+function componentImportName(deckIndex) {
+	return `Components_${deckIndex}`;
 }
 function serializeValue(value, depth) {
 	const indent = "  ".repeat(depth);
@@ -1500,6 +1505,191 @@ function extractDeckPrelude(source) {
 	};
 }
 //#endregion
+//#region src/node/markdown-decks.ts
+async function compileMarkdownDecks(input, adapter) {
+	const markdownEntries = input.decks.filter((entry) => entry.sourcePath.endsWith(".md"));
+	const mdx = await compileMdxModuleDecks({
+		...input,
+		decks: input.decks.filter((entry) => !entry.sourcePath.endsWith(".md"))
+	});
+	if (!markdownEntries.length) return mdx;
+	const decks = [...mdx.decks];
+	const clients = /* @__PURE__ */ new Set();
+	const markdownIslands = /* @__PURE__ */ new Map();
+	for (const entry of markdownEntries) try {
+		const source = await input.readText(entry.sourcePath);
+		const parsed = adapter.read(source);
+		if (input.clientComponentIds?.[entry.slug] && Object.keys(input.clientComponentIds[entry.slug]).length) throw new Error("Void Markdown slides support static components only; use MDX for hono-decks client components.");
+		const warnings = [];
+		const meta = toDeckFrontmatter(parsed.frontmatter, warnings);
+		addUnknownFrontmatterWarnings(warnings, meta.meta, "deck");
+		const assets = [...await buildAssetRefs(entry.slug, entry.assetPaths, input), ...buildExternalAssetRefs([
+			...collectMarkdownAssetCandidates(parsed.content),
+			...collectFrontmatterAssetCandidates(meta.assets),
+			...collectFrontmatterAssetCandidates(parsed.frontmatter.background)
+		])];
+		const candidates = [
+			...collectMarkdownAssetCandidates(parsed.content),
+			...collectFrontmatterAssetCandidates(parsed.frontmatter.assets),
+			...collectFrontmatterAssetCandidates(parsed.frontmatter.background)
+		];
+		if (entry.kind === "single-file" && candidates.some(isLocalRelativeAssetCandidate)) throw new Error("Single-file Markdown decks cannot reference local relative assets; use a directory deck.");
+		let clientEntryRequired = false;
+		const slideModules = [];
+		const slides = [];
+		for (const [index, slideSource] of splitMarkdownSlides(parsed.content).entries()) {
+			const prelude = parsed.script ? `<script>\n${parsed.script}\n<\/script>\n` : "";
+			const slide = adapter.read(prelude + slideSource);
+			const path = `${input.outDir}/decks/${entry.slug}/slide-${index}.ts`;
+			const rewritten = rewriteAssetUrls(`${prelude}---\n${JSON.stringify({
+				...parsed.frontmatter,
+				...slide.frontmatter
+			})}\n---\n${slide.content}`, assets);
+			const result = await adapter.compile(rewritten, { sourcePath: resolve(input.cwd ?? process.cwd(), entry.sourcePath) });
+			clientEntryRequired ||= Boolean(result.clientCode || result.islands?.length);
+			if (result.clientCode) clients.add(result.clientCode);
+			for (const island of result.islands ?? []) markdownIslands.set(island.id, island);
+			const slideMeta = toSlideFrontmatter(slide.frontmatter, warnings, {
+				slideIndex: index,
+				fallbackTitle: result.headings[0]?.text,
+				fallbackTransition: meta.transition,
+				fallbackTransitionDuration: meta.transitionDuration,
+				fallbackTransitionEasing: meta.transitionEasing
+			});
+			addUnknownFrontmatterWarnings(warnings, slideMeta.meta, "slide", index);
+			slideModules.push({
+				path,
+				importPath: `./decks/${entry.slug}/slide-${index}`,
+				code: `// @ts-nocheck\n${rewriteRelativeMdxImports(result.code, dirname$1(entry.sourcePath), dirname$1(path))}`
+			});
+			slides.push({
+				index,
+				meta: slideMeta,
+				html: "",
+				components: [],
+				notes: slideMeta.notes
+			});
+		}
+		addExternalAssetWarnings(warnings, assets);
+		const themeStyle = input.themeStyles?.[entry.slug];
+		decks.push({
+			deck: {
+				slug: entry.slug,
+				sourcePath: entry.sourcePath,
+				kind: entry.kind,
+				clientEntryRequired,
+				meta,
+				slides,
+				assets,
+				warnings,
+				themeStyle: themeStyle?.style,
+				themeSourcePath: themeStyle?.sourcePath
+			},
+			slideModules
+		});
+	} catch (error) {
+		throw new CompileError(`Void Markdown compile failed in ${entry.sourcePath}: ${error instanceof Error ? error.message : String(error)}`, "void-markdown-compile-error");
+	}
+	decks.sort((a, b) => a.deck.slug.localeCompare(b.deck.slug));
+	return {
+		decks,
+		routerModule: emitModuleDecksRouter({ decks }),
+		clientCode: [...clients].join("\n"),
+		clientModules: [adapter.client([...markdownIslands.values()])].filter(Boolean),
+		markdownIslands: [...markdownIslands.values()]
+	};
+}
+/** Protect fenced code from the deck separator parser. */
+function splitMarkdownSlides(source) {
+	const fences = [];
+	let prefix = "HONO_DECKS_FENCE_";
+	while (source.includes(prefix)) prefix += "_";
+	const lines = source.replace(/\r\n/g, "\n").split("\n");
+	const protectedLines = [];
+	for (let index = 0; index < lines.length; index++) {
+		const open = /^ {0,3}(`{3,}|~{3,})/.exec(lines[index]);
+		if (/^[ \t]+---[ \t]*$/.test(lines[index])) {
+			protectedLines.push(`${prefix}${fences.push(lines[index]) - 1}_END`);
+			continue;
+		}
+		if (!open) {
+			protectedLines.push(lines[index]);
+			continue;
+		}
+		const block = [lines[index]];
+		const close = new RegExp(`^ {0,3}${open[1][0]}{${open[1].length},}[ \\t]*$`);
+		let closed = false;
+		while (++index < lines.length) {
+			block.push(lines[index]);
+			if (close.test(lines[index])) {
+				closed = true;
+				break;
+			}
+		}
+		if (!closed) throw new Error("Markdown code fence is not closed.");
+		protectedLines.push(`${prefix}${fences.push(block.join("\n")) - 1}_END`);
+	}
+	return splitSlideSources(protectedLines.join("\n")).map((slide) => slide.replace(new RegExp(`${prefix}(\\d+)_END`, "g"), (_, id) => fences[Number(id)]));
+}
+//#endregion
+//#region src/adapters/hono-markdown.ts
+/** Node-only bridge. Existing Void configs retain their original compiler/runtime pair. */
+async function createHonoMarkdownAdapter(cwd, legacy = false, options) {
+	const require = createRequire(resolve(cwd, "package.json"));
+	const entry = legacy ? "void-plugin-hono-jsx/markdown/compiler" : "@ts-76/hono-markdown/compiler";
+	let compiler;
+	try {
+		compiler = await import(pathToFileURL(require.resolve(entry)).href);
+	} catch (cause) {
+		throw new Error(`Hono Markdown requires ${legacy ? "its public /markdown/compiler API" : "@ts-76/hono-markdown/compiler"} and Markdown peers installed in the app.`, { cause });
+	}
+	const read = compiler.readMarkdownModule ?? compiler.readStaticMarkdown;
+	const compile = compiler.compileMarkdownModule ?? compiler.compileStaticMarkdown;
+	if (typeof read !== "function" || typeof compile !== "function") throw new Error("Missing standalone compiler API");
+	const runtime = entry.startsWith("void-plugin") ? "void-plugin-hono-jsx/markdown/client" : "@ts-76/hono-markdown/client";
+	return {
+		read,
+		compile: (source, input) => compile(source, {
+			...input,
+			options
+		}),
+		client: (islands) => emitMarkdownClient(islands, runtime)
+	};
+}
+function emitMarkdownClient(islands, runtime) {
+	if (!islands.length) return "";
+	const literal = (value) => JSON.stringify(value).replace(/</g, "\\u003c");
+	return `import { hydrateMarkdownIslands } from ${literal(runtime)};
+hydrateMarkdownIslands({ ${islands.map((island) => `${literal(island.id)}: () => import(${literal(island.modulePath)})`).join(",")} }, {
+  ready(element, start) {
+    const slide = element.closest('section[data-slide-state]');
+    if (!slide || slide.dataset.slideState === 'active') { start(); return; }
+    const observer = new MutationObserver(() => {
+      if (slide.dataset.slideState === 'active') { observer.disconnect(); start(); }
+    });
+    observer.observe(slide, { attributes: true, attributeFilter: ['data-slide-state'] });
+  }
+});`;
+}
+//#endregion
+//#region src/node/markdown-adapter.ts
+async function loadMarkdownAdapter(selection, cwd) {
+	if (selection === "void") return createHonoMarkdownAdapter(cwd, true);
+	if (selection.adapter === "hono-decks/adapters/hono-markdown") return createHonoMarkdownAdapter(cwd, false, selection.options);
+	const module = await import(pathToFileURL(createRequire(resolve(cwd, "package.json")).resolve(selection.adapter)).href);
+	if (typeof module.createMarkdownAdapter !== "function") throw new Error("Markdown adapter must export createMarkdownAdapter.");
+	const adapter = await module.createMarkdownAdapter({
+		cwd,
+		options: selection.options
+	});
+	if (![
+		adapter?.read,
+		adapter?.compile,
+		adapter?.client
+	].every((value) => typeof value === "function")) throw new Error("Markdown adapter must provide read, compile and client functions.");
+	return adapter;
+}
+//#endregion
 //#region src/node/client-entry.ts
 async function discoverClientComponentIds(input) {
 	const result = {};
@@ -1520,10 +1710,12 @@ async function emitClientEntryModule(input) {
 			registrations.push(`${JSON.stringify(clientId)}: ${localName}`);
 		}
 	}
-	if (registrations.length === 0) return "export const decksClientEntry = \"\";\n";
-	const output = (await build({
+	const clientModules = input.clientModules ?? [];
+	if (registrations.length === 0 && clientModules.length === 0) return `export const decksClientEntry = ${JSON.stringify(input.extraCode ?? "")};\n`;
+	const result = await build({
 		stdin: {
-			contents: `import { hydrateSlideIslands } from "hono-decks/client";
+			contents: `${clientModules.join("\n")}
+import { hydrateSlideIslands } from "hono-decks/client";
 ${imports.join("\n")}
 
 hydrateSlideIslands({
@@ -1538,6 +1730,15 @@ hydrateSlideIslands({
 		},
 		bundle: true,
 		write: false,
+		outdir: join(input.cwd, ".hono-decks-client"),
+		loader: {
+			".svg": "dataurl",
+			".png": "dataurl",
+			".jpg": "dataurl",
+			".webp": "dataurl",
+			".woff2": "dataurl",
+			".woff": "dataurl"
+		},
 		format: "esm",
 		platform: "browser",
 		target: "es2022",
@@ -1547,9 +1748,12 @@ hydrateSlideIslands({
 		alias: { "hono-decks/client": resolveClientRuntimeEntry() },
 		sourcemap: false,
 		minify: false
-	})).outputFiles[0];
+	});
+	const output = result.outputFiles.find((file) => file.path.endsWith(".js"));
+	const css = result.outputFiles.filter((file) => file.path.endsWith(".css")).map((file) => file.text).join("\n");
+	input.onCss?.(css);
 	if (!output) throw new Error("Client entry did not produce output.");
-	return `export const decksClientEntry = ${JSON.stringify(output.text)};\n`;
+	return `export const decksClientEntry = ${JSON.stringify(output.text + (input.extraCode ? "\n" + input.extraCode : ""))};\n`;
 }
 function resolveClientRuntimeEntry() {
 	const built = fileURLToPath(new URL("./client.js", import.meta.url));
@@ -1619,6 +1823,63 @@ async function listFiles(cwd, dir) {
 	}))).flat().sort();
 }
 //#endregion
+//#region src/node/file-transaction.ts
+/** Stage every file before publishing; restore the previous files on an I/O error.
+* Individual renames are atomic. This is rollback on failure, not a cross-process
+* or crash-atomic filesystem transaction. Failed rollback retains recovery files.
+*/
+async function publishGeneratedFiles(files, renameFile = rename) {
+	const staged = [];
+	const published = [];
+	let keepRecovery = false;
+	try {
+		if (new Set(files.map((file) => file.path)).size !== files.length) throw new Error("Generated output paths must be unique.");
+		for (const file of files) {
+			const parent = dirname(file.path);
+			await mkdir(parent, { recursive: true });
+			const dir = await mkdtemp(join(parent, ".hono-decks-"));
+			const entry = {
+				path: file.path,
+				dir,
+				next: join(dir, "next")
+			};
+			staged.push(entry);
+			await writeFile(entry.next, file.content, "utf8");
+			let previous;
+			try {
+				previous = await readFile(file.path);
+			} catch (error) {
+				if (error.code === "ENOENT") continue;
+				throw error;
+			}
+			entry.backup = join(dir, "previous");
+			await writeFile(entry.backup, previous);
+		}
+		for (const entry of staged) {
+			await renameFile(entry.next, entry.path);
+			published.push(entry);
+		}
+	} catch (error) {
+		const failures = [];
+		for (const entry of published.reverse()) try {
+			if (entry.backup) await renameFile(entry.backup, entry.path);
+			else await rm(entry.path, { force: true });
+		} catch (failure) {
+			failures.push(failure);
+		}
+		if (failures.length) {
+			keepRecovery = true;
+			throw new AggregateError([error, ...failures], `Generated output rollback failed. Recovery files remain in: ${staged.map((entry) => entry.dir).join(", ")}`);
+		}
+		throw error;
+	} finally {
+		if (!keepRecovery) await Promise.allSettled(staged.map((entry) => rm(entry.dir, {
+			recursive: true,
+			force: true
+		})));
+	}
+}
+//#endregion
 //#region src/node/ogp.ts
 const MAX_OGP_BYTES = 256 * 1024;
 const MAX_OGP_REDIRECTS = 3;
@@ -1804,11 +2065,12 @@ function isHttpUrl(value) {
 }
 //#endregion
 //#region src/node/compile-decks.ts
-async function compileDecks(input) {
+/** Shared by file output and Vite's in-memory module graph. Does not write files. */
+async function compileDeckModules(input) {
 	const out = normalizeRelativePath(input.out, "Output directory");
 	const root = normalizeDeckRoot(input.root);
 	const paths = await listFiles(input.cwd, join(input.cwd, root));
-	const resolved = resolveDeckFiles(paths, root);
+	const resolved = resolveDeckFiles(paths, root, { markdown: Boolean(input.markdown) });
 	const componentModulePaths = Object.fromEntries(resolved.flatMap((deck) => {
 		const path = deck.kind === "directory" ? findComponentModule(paths, root, deck.slug) : void 0;
 		return path ? [[deck.slug, path]] : [];
@@ -1836,7 +2098,9 @@ async function compileDecks(input) {
 		refresh: input.refreshOgp,
 		resolveOgp: input.resolveOgp ?? resolveOgpMetadata
 	});
-	const generated = await compileMdxModuleDecks({
+	const adapter = input.markdown && resolved.some((entry) => entry.sourcePath.endsWith(".md")) ? await loadMarkdownAdapter(input.markdown, input.cwd) : void 0;
+	const generated = await (adapter ? (value) => compileMarkdownDecks(value, adapter) : compileMdxModuleDecks)({
+		cwd: input.cwd,
 		root,
 		outDir: out,
 		mountPath: input.mountPath,
@@ -1848,20 +2112,57 @@ async function compileDecks(input) {
 		readText: (path) => readFile(join(input.cwd, path), "utf8"),
 		readBinary: (path) => readFile(join(input.cwd, path))
 	});
-	for (const deck of generated.decks) for (const slide of deck.slideModules) await writeTextFile(join(input.cwd, slide.path), slide.code);
-	await writeTextFile(join(input.cwd, out, "decks.ts"), generated.routerModule);
-	await writeTextFile(join(input.cwd, out, "client-entry.ts"), await emitClientEntryModule({
+	let clientCss = "";
+	const clientEntry = await emitClientEntryModule({
 		cwd: input.cwd,
 		clientEntries: clientEntryPaths,
-		clientComponentIds
-	}));
-	await ogpCache.write();
-	return { decks: generated.decks.map((deck) => deck.deck) };
+		clientComponentIds,
+		extraCode: generated.clientCode,
+		clientModules: generated.clientModules,
+		onCss: (css) => {
+			clientCss = css;
+		}
+	});
+	if (clientCss) {
+		for (const deck of generated.decks) if (deck.deck.clientEntryRequired || Object.keys(deck.clientComponentIds ?? {}).length) deck.deck.themeStyle = [deck.deck.themeStyle, clientCss].filter(Boolean).join("\n");
+		generated.routerModule = emitModuleDecksRouter({ decks: generated.decks });
+	}
+	const files = generated.decks.flatMap((deck) => deck.slideModules.map((slide) => ({
+		path: join(input.cwd, slide.path),
+		content: slide.code
+	})));
+	files.push({
+		path: join(input.cwd, out, "decks.ts"),
+		content: generated.routerModule
+	}, {
+		path: join(input.cwd, out, "client-entry.ts"),
+		content: clientEntry
+	});
+	return {
+		modules: files,
+		cacheFile: ogpCache.output(),
+		result: {
+			outDir: out,
+			routerModulePath: `${out}/decks.ts`,
+			decks: generated.decks.map(({ deck, slideModules }) => {
+				const { slides, componentRegistry: _componentRegistry, ...metadata } = deck;
+				return {
+					...metadata,
+					slides: slides.map((slide, index) => ({
+						index: slide.index,
+						meta: slide.meta,
+						notes: slide.notes,
+						modulePath: slideModules[index].path
+					}))
+				};
+			})
+		}
+	};
 }
 async function createOgpCacheResolver(input) {
 	if (!input.cacheFile) return {
 		resolveOgp: input.resolveOgp,
-		write: async () => void 0
+		output: () => void 0
 	};
 	const cachePath = join(input.cwd, normalizeRelativePath(input.cacheFile, "OGP cache file"));
 	const cache = await readOgpCache(cachePath);
@@ -1877,9 +2178,11 @@ async function createOgpCacheResolver(input) {
 			}
 			return metadata;
 		},
-		async write() {
-			if (!dirty) return;
-			await writeTextFile(cachePath, `${JSON.stringify(cache, null, 2)}\n`);
+		output() {
+			return dirty ? {
+				path: cachePath,
+				content: `${JSON.stringify(cache, null, 2)}\n`
+			} : void 0;
 		}
 	};
 }
@@ -1909,10 +2212,6 @@ async function readOgpCache(path) {
 function isNodeError(error) {
 	return error instanceof Error && "code" in error;
 }
-async function writeTextFile(path, contents) {
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, contents, "utf8");
-}
 function findComponentModule(paths, root, slug) {
 	const base = `${normalizePath(root).replace(/\/$/, "")}/${slug}/components/index`;
 	return paths.find((path) => {
@@ -1952,7 +2251,7 @@ function findDeckThemeStyle(paths, root, slug) {
 async function loadDecksConfig(input) {
 	const path = resolve(input.cwd, input.configFile ?? "hono-decks.config.ts");
 	if (!existsSync(path)) throw new Error(`Config file not found: ${input.configFile ?? "hono-decks.config.ts"}. Run \`hono-decks init\` first.`);
-	const source = (await build({
+	const result = await build({
 		absWorkingDir: input.cwd,
 		entryPoints: [path],
 		bundle: true,
@@ -1960,16 +2259,20 @@ async function loadDecksConfig(input) {
 		platform: "node",
 		target: "node20",
 		write: false,
+		metafile: true,
 		logLevel: "silent",
 		alias: { "hono-decks": resolveRuntimeEntry() }
-	})).outputFiles[0]?.text;
+	});
+	const source = result.outputFiles[0]?.text;
 	if (!source) throw new Error(`Could not load config file: ${path}`);
 	const config = (await import(`data:text/javascript;charset=utf-8,${encodeURIComponent(source)}#${Date.now()}`)).default;
 	if (!config || typeof config !== "object") throw new Error(`Config must have a default export: ${path}`);
 	if (typeof config.mountPath !== "string") throw new Error(`Config mountPath must be a string: ${path}`);
+	if (config.build?.markdown !== void 0 && config.build.markdown !== "void" && (typeof config.build.markdown !== "object" || !config.build.markdown || typeof config.build.markdown.adapter !== "string" || !config.build.markdown.adapter.trim())) throw new Error("Config build.markdown must be \"void\" or an adapter reference.");
 	return {
 		path,
 		config,
+		dependencies: Object.keys(result.metafile.inputs).map((inputPath) => resolve(input.cwd, inputPath)),
 		root: config.build?.root ?? "decks",
 		outDir: config.build?.outDir ?? "src/generated",
 		ogpCacheFile: config.build?.ogpCacheFile
@@ -1992,6 +2295,7 @@ function resolveRuntimeEntry() {
 function honoDecks(options = {}) {
 	let projectRoot = process.cwd();
 	let configPath = resolve(projectRoot, options.configFile ?? "hono-decks.config.ts");
+	let configDependencies = /* @__PURE__ */ new Set();
 	let deckRoot = resolve(projectRoot, "decks");
 	let resolvedConfig;
 	let server;
@@ -1999,9 +2303,17 @@ function honoDecks(options = {}) {
 	let timer;
 	let compiling = false;
 	let queued = false;
+	let compiledMountPath;
+	let mountChanged = false;
+	let modules = /* @__PURE__ */ new Map();
+	let routerModulePath = "";
 	const syncWatchedPaths = async () => {
 		if (!server) return;
-		const next = /* @__PURE__ */ new Set([deckRoot, configPath]);
+		const next = /* @__PURE__ */ new Set([
+			deckRoot,
+			configPath,
+			...configDependencies
+		]);
 		const removed = [...watchedPaths].filter((path) => !next.has(path));
 		if (removed.length > 0) server.watcher.unwatch(removed);
 		server.watcher.add([...next]);
@@ -2012,18 +2324,26 @@ function honoDecks(options = {}) {
 			cwd: projectRoot,
 			configFile: options.configFile
 		});
-		const manifest = await compileDecks({
+		configDependencies = new Set(loaded.dependencies);
+		await syncWatchedPaths();
+		const compiled = await compileDeckModules({
 			cwd: projectRoot,
 			root: loaded.root,
 			out: loaded.outDir,
 			mountPath: loaded.config.mountPath,
 			ogpCacheFile: loaded.ogpCacheFile,
+			markdown: loaded.config.build?.markdown,
 			refreshOgp: options.refreshOgp
 		});
+		if (compiled.cacheFile) await publishGeneratedFiles([compiled.cacheFile]);
+		modules = new Map(compiled.modules.map((file) => [resolve(file.path), file.content]));
+		routerModulePath = resolve(projectRoot, compiled.result.routerModulePath);
+		mountChanged ||= compiledMountPath !== void 0 && compiledMountPath !== loaded.config.mountPath;
+		compiledMountPath = loaded.config.mountPath;
 		configPath = loaded.path;
 		deckRoot = resolve(projectRoot, loaded.root);
 		await syncWatchedPaths();
-		resolvedConfig?.logger.info(`[hono-decks] Compiled ${manifest.decks.length} decks to ${loaded.outDir}`);
+		resolvedConfig?.logger.info(`[hono-decks] Compiled ${compiled.result.decks.length} decks as virtual modules`);
 	};
 	const compile = async (fatal) => {
 		if (compiling) {
@@ -2044,7 +2364,18 @@ function honoDecks(options = {}) {
 					resolvedConfig?.logger.error(`[hono-decks] ${error instanceof Error ? error.message : String(error)}`);
 				}
 			} while (queued);
-			if (latestCompileSucceeded && server) server.ws.send({ type: "full-reload" });
+			if (latestCompileSucceeded && server) {
+				if (mountChanged) {
+					mountChanged = false;
+					await server.restart();
+					return;
+				}
+				for (const environment of Object.values(server.environments)) {
+					environment.moduleGraph.invalidateAll();
+					if (environment.name !== "client") environment.hot.send({ type: "full-reload" });
+				}
+				server.ws.send({ type: "full-reload" });
+			}
 		} finally {
 			compiling = false;
 		}
@@ -2056,14 +2387,56 @@ function honoDecks(options = {}) {
 	const onWatcherEvent = (event, path) => {
 		if (event !== "add" && event !== "change" && event !== "unlink") return;
 		const absolutePath = resolve(projectRoot, path);
-		if (absolutePath === configPath || isWithin(deckRoot, absolutePath)) scheduleCompile();
+		if (absolutePath === configPath || configDependencies.has(absolutePath) || isWithin(deckRoot, absolutePath)) scheduleCompile();
 	};
 	return {
 		name: "hono-decks",
 		enforce: "pre",
+		async resolveId(id, importer) {
+			if (id === "virtual:hono-decks") return VIRTUAL_ENTRY;
+			if (id.startsWith(PUBLIC_MODULE_PREFIX)) {
+				const path = decodeURIComponent(id.slice(PUBLIC_MODULE_PREFIX.length));
+				return modules.has(path) ? MODULE_PREFIX + path : null;
+			}
+			if (importer?.startsWith(MODULE_PREFIX)) {
+				const parent = importer.slice(MODULE_PREFIX.length);
+				if (id.startsWith(".")) {
+					const path = resolve(dirname(parent), id);
+					const generated = findModule(modules, path);
+					if (generated) return MODULE_PREFIX + generated;
+					return this.resolve(path, void 0, { skipSelf: true });
+				}
+				return this.resolve(id, resolve(projectRoot, "package.json"), { skipSelf: true });
+			}
+			if (id.startsWith(".") || id.startsWith("/")) {
+				const path = id.startsWith(".") ? resolve(importer ? dirname(importer.split("?")[0]) : projectRoot, id) : id;
+				const generated = findModule(modules, path);
+				if (generated) return MODULE_PREFIX + generated;
+			}
+			return null;
+		},
+		async load(id) {
+			if (id === VIRTUAL_ENTRY) return `import config from ${JSON.stringify(configPath)};
+import { createDecks } from ${JSON.stringify(PUBLIC_MODULE_PREFIX + encodeURIComponent(routerModulePath))};
+export { createDecks };
+export const decks = createDecks(config);`;
+			if (!id.startsWith(MODULE_PREFIX)) return null;
+			const path = id.slice(MODULE_PREFIX.length);
+			const code = modules.get(path);
+			if (code === void 0) return null;
+			return (await transform(code, {
+				loader: "ts",
+				format: "esm",
+				sourcefile: path,
+				sourcemap: "inline"
+			})).code;
+		},
+		config() {
+			return { server: { watch: { ignored: [/(?:^|[/\\])\.hono-decks-[^/\\]+(?:[/\\]|$)/] } } };
+		},
 		async configResolved(config) {
 			resolvedConfig = config;
-			projectRoot = config.root;
+			projectRoot = config.resolve?.preserveSymlinks ? config.root : await realpath(config.root);
 			configPath = resolve(projectRoot, options.configFile ?? "hono-decks.config.ts");
 			await compile(true);
 		},
@@ -2081,9 +2454,24 @@ function honoDecks(options = {}) {
 		}
 	};
 }
+const VIRTUAL_ENTRY = "\0hono-decks:entry";
+const PUBLIC_MODULE_PREFIX = "virtual:hono-decks/module/";
+const MODULE_PREFIX = "\0hono-decks:module:";
+function findModule(modules, path) {
+	return [
+		path,
+		path.replace(/\.js$/, ".ts"),
+		path + ".ts",
+		path + "/index.ts"
+	].find((candidate) => modules.has(candidate));
+}
 function isWithin(root, path) {
 	const child = relative(root, path);
 	return child === "" || child !== ".." && !child.startsWith("../") && !child.startsWith("..\\");
 }
+/** Add deck compilation to an existing object, promise, or config function. */
+function withHonoDecks(config, options = {}) {
+	return async (env) => mergeConfig(await (typeof config === "function" ? config(env) : config), { plugins: [honoDecks(options)] });
+}
 //#endregion
-export { honoDecks };
+export { honoDecks, withHonoDecks };