hono-decks 1.0.4 → 1.2.0

package/dist/cli.js

@@ -1,3 +1,5 @@
+import { i as normalizeRelativePath, n as normalizeDeckRoot, r as normalizePath$4, t as publishGeneratedFiles } from "./file-transaction-NjDxX6Gt.js";
+import { createRequire } from "node:module";
 import { existsSync, watch } from "node:fs";
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
@@ -8,28 +10,28 @@ import remarkParse from "remark-parse";
 import { compile } from "@mdx-js/mdx";
 import remarkDirective from "remark-directive";
 import { codeToHtml } from "shiki";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } 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") {
-	const normalizedRoot = normalizePath$4(root).replace(/\/$/, "");
+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$4).sort()) {
+	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,
@@ -63,7 +65,7 @@ function assertInsideRoot(path, root) {
 	if (path.includes("/../") || path.endsWith("/..") || path.startsWith("../")) throw new Error(`Deck path escapes the root: ${path}`);
 	if (path !== root && !path.startsWith(`${root}/`)) throw new Error(`Deck path is outside ${root}: ${path}`);
 }
-function normalizePath$4(path) {
+function normalizePath$3(path) {
 	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
 }
 //#endregion
@@ -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();
@@ -916,7 +923,7 @@ function rewriteAssetUrls(source, assets) {
 }
 function rewriteRelativeMdxImports(source, sourceDir, generatedDir) {
 	return source.replace(/(from\s+|import\s+)(["'])(\.[^"']+)\2/g, (_match, prefix, quote, specifier) => {
-		return `${prefix}${quote}${toRelativeImportPath(generatedDir, normalizePath$3(`${sourceDir}/${specifier}`))}${quote}`;
+		return `${prefix}${quote}${toRelativeImportPath(generatedDir, normalizePath$2(`${sourceDir}/${specifier}`))}${quote}`;
 	});
 }
 function componentImportPath(outDir, sourcePath) {
@@ -924,22 +931,22 @@ function componentImportPath(outDir, sourcePath) {
 	return toRelativeImportPath(outDir, sourcePath.replace(/\/index\.(tsx|ts|jsx|js)$/, ""));
 }
 function dirname$2(path) {
-	const normalized = normalizePath$3(path);
+	const normalized = normalizePath$2(path);
 	const index = normalized.lastIndexOf("/");
 	return index === -1 ? "." : normalized.slice(0, index);
 }
 function localAssetRelativePath(sourcePath) {
 	const marker = "/assets/";
-	const normalized = normalizePath$3(sourcePath);
+	const normalized = normalizePath$2(sourcePath);
 	const markerIndex = normalized.indexOf(marker);
 	return markerIndex === -1 ? normalized.split("/").at(-1) ?? normalized : normalized.slice(markerIndex + 8);
 }
-function normalizePath$3(path) {
+function normalizePath$2(path) {
 	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
 }
 function toRelativeImportPath(fromDir, target) {
-	const fromParts = normalizePath$3(fromDir).split("/").filter(Boolean);
-	const targetParts = normalizePath$3(target).split("/").filter(Boolean);
+	const fromParts = normalizePath$2(fromDir).split("/").filter(Boolean);
+	const targetParts = normalizePath$2(target).split("/").filter(Boolean);
 	while (fromParts.length > 0 && targetParts.length > 0 && fromParts[0] === targetParts[0]) {
 		fromParts.shift();
 		targetParts.shift();
@@ -962,14 +969,14 @@ async function buildAssetRefs(slug, assetPaths, input) {
 	})));
 }
 function assetName(sourcePath, root, slug) {
-	const normalizedPath = normalizePath$2(sourcePath);
-	const prefix = `${normalizePath$2(root).replace(/\/$/, "")}/${slug}/assets/`;
+	const normalizedPath = normalizePath$1(sourcePath);
+	const prefix = `${normalizePath$1(root).replace(/\/$/, "")}/${slug}/assets/`;
 	return (normalizedPath.startsWith(prefix) ? normalizedPath.slice(prefix.length) : normalizedPath.split("/").at(-1) ?? normalizedPath).split("/").map(encodeURIComponent).join("/");
 }
 function normalizeMountPath(value) {
 	return (value.startsWith("/") ? value : `/${value}`).replace(/\/$/, "");
 }
-function normalizePath$2(path) {
+function normalizePath$1(path) {
 	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
 }
 //#endregion
@@ -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 slideImportName(deckIndex, slideIndex) {
+	return `Slide_${deckIndex}_${slideIndex}`;
 }
-function componentImportName(slug) {
-	return `Components_${safeIdentifier$1(slug)}`;
-}
-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$2(entry.sourcePath), dirname$2(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));
@@ -1588,33 +1792,13 @@ function safeIdentifier(value) {
 	return value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/, "_") || "_";
 }
 //#endregion
-//#region src/node/path-utils.ts
-function dirname$1(path) {
-	const normalized = normalizePath$1(path);
-	return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
-}
-function normalizePath$1(path) {
-	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
-}
-function normalizeDeckRoot(root) {
-	const normalized = normalizeRelativePath(root, "Deck root").replace(/\/$/, "");
-	if (normalized === ".") throw new Error("Deck root must be a relative path inside the current working directory");
-	return normalized;
-}
-function normalizeRelativePath(path, label) {
-	const normalized = normalizePath$1(path).replace(/\/$/, "");
-	const segments = normalized.split("/");
-	if (normalized === "" || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || segments.includes("..")) throw new Error(`${label} must be a relative path inside the current working directory`);
-	return normalized;
-}
-//#endregion
 //#region src/node/local-deck-io.ts
 async function listFiles(cwd, dir) {
 	const entries = await readdir(dir, { withFileTypes: true });
 	return (await Promise.all(entries.map(async (entry) => {
 		const fullPath = join(dir, entry.name);
 		if (entry.isDirectory()) return listFiles(cwd, fullPath);
-		if (entry.isFile()) return [normalizePath$1(relative(cwd, fullPath))];
+		if (entry.isFile()) return [normalizePath$4(relative(cwd, fullPath))];
 		return [];
 	}))).flat().sort();
 }
@@ -1805,10 +1989,16 @@ function isHttpUrl(value) {
 //#endregion
 //#region src/node/compile-decks.ts
 async function compileDecks(input) {
+	const compiled = await compileDeckModules(input);
+	await publishGeneratedFiles([...compiled.modules, ...compiled.cacheFile ? [compiled.cacheFile] : []]);
+	return compiled.result;
+}
+/** 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 +2026,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 +2040,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 +2106,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,21 +2140,17 @@ async function readOgpCache(path) {
 function isNodeError(error) {
 	return error instanceof Error && "code" in error;
 }
-async function writeTextFile(path, contents) {
-	await mkdir(dirname$1(path), { recursive: true });
-	await writeFile(path, contents, "utf8");
-}
 function findComponentModule(paths, root, slug) {
-	const base = `${normalizePath$1(root).replace(/\/$/, "")}/${slug}/components/index`;
+	const base = `${normalizePath$4(root).replace(/\/$/, "")}/${slug}/components/index`;
 	return paths.find((path) => {
-		const normalized = normalizePath$1(path);
+		const normalized = normalizePath$4(path);
 		return normalized === `${base}.tsx` || normalized === `${base}.ts` || normalized === `${base}.jsx` || normalized === `${base}.js`;
 	});
 }
 function findClientEntryModule(paths, root, slug) {
-	const base = `${normalizePath$1(root).replace(/\/$/, "")}/${slug}/components/client/index`;
+	const base = `${normalizePath$4(root).replace(/\/$/, "")}/${slug}/components/client/index`;
 	return paths.find((path) => {
-		const normalized = normalizePath$1(path);
+		const normalized = normalizePath$4(path);
 		return normalized === `${base}.tsx` || normalized === `${base}.ts` || normalized === `${base}.jsx` || normalized === `${base}.js`;
 	});
 }
@@ -1941,7 +2168,7 @@ async function discoverDeckThemeStyles(input) {
 	return result;
 }
 function findDeckThemeStyle(paths, root, slug) {
-	const base = `${normalizePath$1(root).replace(/\/$/, "")}/${slug}`;
+	const base = `${normalizePath$4(root).replace(/\/$/, "")}/${slug}`;
 	const themePath = `${base}/theme.css`;
 	const stylesEntryPath = `${base}/styles/index.css`;
 	const hasTheme = paths.includes(themePath);
@@ -1952,7 +2179,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 +2187,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
@@ -1991,6 +2222,10 @@ Commands:
   compile, build   Compile decks using the shared config.
 
 Options:
+  --install                Install missing dependencies for --framework void.
+  --adapter <specifier>    Compatible Hono Markdown adapter version or tarball; requires --install.
+  --framework <name>       Vite integration: hono, honox, or void.
+  --entry <path>           Hono app entry for --framework hono; otherwise auto-detect.
   --config <path>          Config file. Default: hono-decks.config.ts
   --out <path>             Facade output for init. Default: src/decks.ts
   --generated <path>       Generated module import for init. Default: ./generated/decks
@@ -2032,6 +2267,7 @@ async function runHonoDecksCli(input) {
 			out: loaded.outDir,
 			mountPath: loaded.config.mountPath,
 			ogpCacheFile: loaded.ogpCacheFile,
+			markdown: loaded.config.build?.markdown,
 			refreshOgp: parsed.options.refreshOgp
 		});
 		stdout(`Compiled ${manifest.decks.length} decks to ${loaded.outDir}`);
@@ -2112,6 +2348,15 @@ async function runInitCommand(input, args, stdout, stderr) {
 		stderr(USAGE);
 		return { exitCode: 1 };
 	}
+	if (parsed.options.framework) try {
+		const { initializeVite } = await import("./init-vite-EA_L4k2H.js");
+		const sampleSlug = await initializeVite(input.cwd, parsed.options.framework, parsed.options.configFile, parsed.options.entry, parsed.options.install ? { adapter: parsed.options.adapter } : void 0);
+		stdout(`Initialized ${parsed.options.framework} decks at /slides/${sampleSlug}. Run your usual dev or build command; no manual compile is needed.`);
+		return { exitCode: 0 };
+	} catch (error) {
+		stderr(error instanceof Error ? error.message : String(error));
+		return { exitCode: 1 };
+	}
 	const configFile = normalizeOutputFile(parsed.options.configFile ?? "hono-decks.config.ts");
 	const out = normalizeOutputFile(parsed.options.out ?? "src/decks.ts");
 	try {
@@ -2169,13 +2414,26 @@ function parseInitArgs(args) {
 			options,
 			help: true
 		};
-		if (arg === "--config" || arg === "--out" || arg === "--generated") {
+		if (arg === "--install") {
+			options.install = true;
+			continue;
+		}
+		if (arg === "--adapter" || arg === "--config" || arg === "--out" || arg === "--generated" || arg === "--framework" || arg === "--entry") {
 			const value = args[index + 1];
 			if (!value || value.startsWith("--")) return {
 				options,
 				error: `Missing value for ${arg}`
 			};
+			if (arg === "--framework") {
+				if (value !== "void" && value !== "hono" && value !== "honox") return {
+					options,
+					error: `Unsupported framework: ${value}. Expected hono, honox, or void.`
+				};
+				options.framework = value;
+			}
+			if (arg === "--adapter") options.adapter = value;
 			if (arg === "--config") options.configFile = value;
+			if (arg === "--entry") options.entry = value;
 			if (arg === "--out") options.out = value;
 			if (arg === "--generated") options.generated = value;
 			index += 1;
@@ -2186,14 +2444,26 @@ function parseInitArgs(args) {
 			error: `Unknown option: ${arg}`
 		};
 	}
+	if (options.install && options.framework !== "void" || options.adapter && !options.install) return {
+		options,
+		error: "--install requires --framework void; --adapter also requires --install."
+	};
+	if (options.entry && options.framework !== "hono") return {
+		options,
+		error: "--entry requires --framework hono."
+	};
+	if (options.framework && (options.out || options.generated)) return {
+		options,
+		error: "Framework init uses virtual modules; --out and --generated are only supported by generic init."
+	};
 	return { options };
 }
 async function writeInitialFiles(input) {
 	for (const path of [input.configFile, input.out]) if (existsSync(join(input.cwd, path))) throw new Error(`Refusing to overwrite existing file: ${path}`);
 	const configPath = join(input.cwd, input.configFile);
 	const facadePath = join(input.cwd, input.out);
-	await mkdir(dirname(configPath), { recursive: true });
-	await mkdir(dirname(facadePath), { recursive: true });
+	await mkdir(dirname$1(configPath), { recursive: true });
+	await mkdir(dirname$1(facadePath), { recursive: true });
 	await writeFile(configPath, emitDecksConfig(), "utf8");
 	await writeFile(facadePath, emitDecksFacade(input.generated, relativeImport(input.out, input.configFile)), "utf8");
 }
@@ -2218,7 +2488,7 @@ export const decks = createDecks(config);
 `;
 }
 function relativeImport(fromFile, toFile) {
-	const path = normalizePath(relative(dirname(fromFile), toFile)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+	const path = normalizePath(relative(dirname$1(fromFile), toFile)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
 	return path.startsWith(".") ? path : `./${path}`;
 }
 function normalizeOutputFile(path) {
@@ -2230,7 +2500,7 @@ function normalizeOutputFile(path) {
 function normalizePath(path) {
 	return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
 }
-function dirname(path) {
+function dirname$1(path) {
 	const normalized = normalizePath(path);
 	return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
 }