hono-decks 1.0.4 → 1.2.0

package/dist/file-transaction-NjDxX6Gt.js

@@ -0,0 +1,80 @@
+import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+//#region src/node/path-utils.ts
+function dirname$1(path) {
+	const normalized = normalizePath(path);
+	return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
+}
+function normalizePath(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(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/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$1(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
+export { normalizeRelativePath as i, normalizeDeckRoot as n, normalizePath as r, publishGeneratedFiles as t };

package/dist/honox.d.ts

@@ -0,0 +1,21 @@
+import { Hono } from "hono";
+//#region src/honox.d.ts
+/** Keep route discovery in the host's Vite graph; route composition lives here. */
+interface HonoXDecksIntegration<R extends object> {
+  routes: Record<string, R>;
+  mountPath: string;
+  router: Hono<any>;
+}
+/** Preserve HonoX options and mount decks through its normal routing pipeline.
+ * Uses structural types so Hono-only consumers do not need to install HonoX.
+ */
+declare function withHonoXDecks<T extends {
+  root?: string;
+  ROUTES?: Record<string, object>;
+}, R extends object>(options: T, input: HonoXDecksIntegration<R>): T & {
+  ROUTES: Record<string, R | NonNullable<T["ROUTES"]>[string] | {
+    default: Hono<any>;
+  }>;
+};
+//#endregion
+export { HonoXDecksIntegration, withHonoXDecks };

package/dist/honox.js

@@ -0,0 +1,47 @@
+//#region src/server/paths.ts
+/** Normalizes a configured mount path to one leading slash and no trailing slash. */
+function normalizeMountPath(value) {
+	const trimmed = value.trim();
+	if (!trimmed || trimmed === "/") return "/";
+	let start = 0;
+	let end = trimmed.length;
+	while (trimmed[start] === "/") start += 1;
+	while (end > start && trimmed[end - 1] === "/") end -= 1;
+	return `/${trimmed.slice(start, end)}`;
+}
+//#endregion
+//#region src/honox.ts
+/** Preserve HonoX options and mount decks through its normal routing pipeline.
+* Uses structural types so Hono-only consumers do not need to install HonoX.
+*/
+function withHonoXDecks(options, input) {
+	const root = options.root ?? "/app/routes";
+	if (root !== "/app/routes") throw new Error("hono-decks: custom HonoX roots require a custom route integration.");
+	const routes = options.ROUTES ?? input.routes;
+	const mountPath = normalizeMountPath(input.mountPath);
+	const mount = mountPath === "/" ? "" : mountPath;
+	for (const [file, route] of Object.entries(routes)) {
+		const path = file.slice(root.length).replace(/\.[^.]+$/, "").replace(/\([^/]+\)/g, "").replace(/\/index$/, "").replace(/\/+/g, "/");
+		const value = route.default;
+		if (routesOverlap(path, mount, Boolean(value && typeof value === "object" && "fetch" in value))) throw new Error(`hono-decks: mountPath ${mountPath} conflicts with HonoX route ${file}`);
+	}
+	return {
+		...options,
+		ROUTES: {
+			...routes,
+			[root + mount + "/index.ts"]: { default: input.router }
+		}
+	};
+}
+function routesOverlap(path, mount, isApp) {
+	const route = path.split("/").filter(Boolean);
+	const target = mount.split("/").filter(Boolean);
+	for (let index = 0; index < Math.min(route.length, target.length); index++) {
+		const part = route[index];
+		if (part.startsWith("[...")) return true;
+		if (!/^\[[^\]]+\]$/.test(part) && part !== target[index]) return false;
+	}
+	return route.length >= target.length || isApp || route.some((part) => part.startsWith("[..."));
+}
+//#endregion
+export { withHonoXDecks };

package/dist/init-vite-EA_L4k2H.js

@@ -0,0 +1,441 @@
+import { t as publishGeneratedFiles } from "./file-transaction-NjDxX6Gt.js";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "@babel/parser";
+import { execFile } from "node:child_process";
+//#region src/adapters/void.ts
+/** Dependency policy of the Void preset, outside the deck compiler. */
+const voidDependencies = [
+	["void", "void@>=1.1.11 <1.2.0"],
+	["vite", "vite@^8.0.16"],
+	["hono", "hono@^4.13.13"],
+	["markdown-exit", "markdown-exit@^1.3.0"],
+	["yaml", "yaml@^2.9.1"],
+	["markdown-it-container", "markdown-it-container@^4.0.0"],
+	["shiki", "shiki@^4.5.0"],
+	["@shikijs/transformers", "@shikijs/transformers@^4.5.0"]
+];
+//#endregion
+//#region src/node/install-void.ts
+async function installVoidDependencies(cwd, options = {}) {
+	if (options.adapter?.startsWith("-")) throw new Error("--adapter must be a package specifier or tarball path.");
+	if (existsSync(join(cwd, ".pnp.cjs"))) throw new Error("--install requires the node_modules linker; install dependencies manually for Yarn PnP.");
+	const pkg = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
+	const declared = pkg.packageManager?.match(/^(npm|pnpm|yarn|bun)@(\d+)/);
+	if (pkg.packageManager && !declared) throw new Error("Unsupported packageManager; use npm, pnpm, yarn, or bun.");
+	const locks = [
+		["npm", "package-lock.json"],
+		["npm", "npm-shrinkwrap.json"],
+		["pnpm", "pnpm-lock.yaml"],
+		["yarn", "yarn.lock"],
+		["bun", "bun.lock"],
+		["bun", "bun.lockb"]
+	].filter(([, file]) => existsSync(join(cwd, file))).map(([manager]) => manager);
+	if (!declared && new Set(locks).size > 1) throw new Error("Multiple package-manager lockfiles found; set packageManager before --install.");
+	const manager = declared?.[1] ?? locks[0] ?? "npm";
+	const modernYarn = manager === "yarn" && (declared ? Number(declared[2]) >= 2 : (await readFile(join(cwd, "yarn.lock"), "utf8").catch(() => "")).includes("__metadata:"));
+	const require = createRequire(join(cwd, "package.json"));
+	const missing = (id) => {
+		try {
+			require.resolve(id);
+			return false;
+		} catch {
+			return true;
+		}
+	};
+	const required = voidDependencies;
+	for (const [id, spec] of required) {
+		if (missing(id)) continue;
+		const version = await installedVersion(require.resolve(id), id);
+		const minimum = spec.match(/(?:\^|>=)(\d+)\.(\d+)\.(\d+)/);
+		if (version) {
+			const value = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+			const min = minimum.slice(1).map(Number);
+			const current = value?.slice(1).map(Number);
+			if (!current || current[0] !== min[0] || id === "void" && current[1] !== 1 || compare(current, min) < 0) throw new Error(`Installed ${id}@${version} is incompatible with ${spec}. Update it explicitly before --install.`);
+		}
+	}
+	const specs = required.filter(([id]) => missing(id)).map(([, spec]) => spec);
+	let packageDirectory = cwd;
+	let hasLocalDecks = false;
+	while (true) {
+		if (existsSync(join(packageDirectory, "node_modules/hono-decks/package.json"))) {
+			hasLocalDecks = true;
+			break;
+		}
+		const parent = dirname(packageDirectory);
+		if (parent === packageDirectory) break;
+		packageDirectory = parent;
+	}
+	if (!hasLocalDecks) {
+		let ownPackage;
+		try {
+			ownPackage = await readFile(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8");
+		} catch {
+			ownPackage = await readFile(fileURLToPath(new URL("../../package.json", import.meta.url)), "utf8");
+		}
+		const requested = pkg.dependencies?.["hono-decks"] ?? pkg.devDependencies?.["hono-decks"] ?? JSON.parse(ownPackage).version;
+		specs.push(`hono-decks@${requested}`);
+	}
+	if (options.adapter || missing("void-plugin-hono-jsx/markdown/compiler")) {
+		let adapter = options.adapter ?? "void-plugin-hono-jsx@^0.5.0";
+		if (/^\d+\./.test(adapter)) adapter = "void-plugin-hono-jsx@" + adapter;
+		else if (modernYarn && (adapter.endsWith(".tgz") || adapter.startsWith("file:"))) adapter = "void-plugin-hono-jsx@file:" + resolve(cwd, adapter.replace(/^file:/, ""));
+		specs.push(adapter);
+	}
+	if (specs.length) {
+		const args = manager === "npm" ? [
+			"install",
+			"--ignore-scripts",
+			"--no-audit",
+			"--no-fund"
+		] : manager === "yarn" ? ["add", ...modernYarn ? ["--mode=skip-build"] : ["--ignore-scripts"]] : ["add", "--ignore-scripts"];
+		await (options.run ?? ((command, args, cwd) => new Promise((resolve, reject) => {
+			execFile(command, args, { cwd }, (error, _stdout, stderr) => error ? reject(/* @__PURE__ */ new Error(`Dependency installation failed: ${stderr || error.message}`)) : resolve());
+		})))(manager, [...args, ...specs], cwd);
+	}
+	const check = `import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+const require = createRequire(process.cwd() + "/package.json");
+for (const id of ${JSON.stringify(required.map(([id]) => id))}) require.resolve(id);
+const compiler = await import(pathToFileURL(require.resolve("void-plugin-hono-jsx/markdown/compiler")).href);
+if (typeof compiler.compileMarkdownModule !== "function" || typeof compiler.readMarkdownModule !== "function") throw new Error("Missing module compiler API");`;
+	await new Promise((resolve, reject) => {
+		execFile(process.execPath, [
+			"--input-type=module",
+			"--eval",
+			check
+		], { cwd }, (error, _stdout, stderr) => {
+			if (error) reject(/* @__PURE__ */ new Error("The installed Hono Markdown adapter lacks the required module compiler API or peers. Use --adapter with a compatible version or tarball. Dependencies may have changed; app integration files were not written. " + stderr));
+			else resolve();
+		});
+	});
+}
+async function installedVersion(entry, name) {
+	let directory = dirname(entry);
+	while (true) {
+		try {
+			const pkg = JSON.parse(await readFile(join(directory, "package.json"), "utf8"));
+			if (pkg.name === name) return pkg.version;
+		} catch {}
+		const parent = dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
+}
+function compare(a, b) {
+	for (let index = 0; index < 3; index++) if (a[index] !== b[index]) return a[index] - b[index];
+	return 0;
+}
+//#endregion
+//#region src/adapters/vite-presets.ts
+/** Initialization policies belong to the host integration, not the compiler. */
+const vitePresets = {
+	void: { dependencies: [...voidDependencies.map(([id]) => id), "void-plugin-hono-jsx/markdown/compiler"] },
+	hono: {
+		dependencies: ["vite", "hono"],
+		clientEntryAssetPath: "/_assets/client"
+	},
+	honox: {
+		dependencies: [
+			"vite",
+			"hono",
+			"honox"
+		],
+		clientEntryAssetPath: "/_assets/client"
+	}
+};
+//#endregion
+//#region src/node/init-vite.ts
+/** Configure an existing Vite app without changing its package scripts. */
+async function initializeVite(cwd, framework, configFile = "hono-decks.config.ts", entry, installation) {
+	if (!configFile || configFile.startsWith("/") || configFile.includes("\\") || /^[A-Za-z]:/.test(configFile) || configFile.split("/").includes("..") || !/\.[cm]?[jt]s$/.test(configFile)) throw new Error("--config must be a JS/TS file inside the current working directory.");
+	const require = createRequire(join(cwd, "package.json"));
+	const dependencies = vitePresets[framework].dependencies;
+	for (const dependency of installation ? [] : dependencies) try {
+		require.resolve(dependency);
+	} catch {
+		throw new Error(`${framework} init requires ${dependency}. Install the compatible dependencies first; no files were changed.`);
+	}
+	const candidates = [
+		"ts",
+		"mts",
+		"js",
+		"mjs",
+		"cts",
+		"cjs"
+	].map((ext) => `vite.config.${ext}`).filter((file) => existsSync(join(cwd, file)));
+	if (candidates.length !== 1) throw new Error("Expected one existing vite.config.{ts,mts,js,mjs,cts,cjs} in the app root. No files were changed.");
+	const viteFile = candidates[0];
+	const patched = connectViteConfig(await readFile(join(cwd, viteFile), "utf8"), configFile);
+	let sampleSlug = "welcome";
+	let suffix = 2;
+	while ([
+		sampleSlug,
+		`${sampleSlug}.md`,
+		`${sampleSlug}.mdx`
+	].some((path) => existsSync(join(cwd, "decks", path)))) sampleSlug = `welcome-${suffix++}`;
+	const files = [
+		{
+			path: configFile,
+			content: `import { defineDecksConfig } from "hono-decks";
+
+export default defineDecksConfig({
+  mountPath: "/slides",
+  build: { root: "decks"${framework === "void" ? ", markdown: \"void\"" : ""} },${vitePresets[framework].clientEntryAssetPath ? `\n  router: { clientEntryAssetPath: ${JSON.stringify(vitePresets[framework].clientEntryAssetPath)} },` : ""}
+});
+`
+		},
+		{
+			path: "src/decks.ts",
+			content: `/// <reference types="hono-decks/vite-env" />
+/// <reference types="vite/client" />
+import { decks } from "virtual:hono-decks";
+
+export { decks };
+`
+		},
+		{
+			path: "middleware/hono-decks.ts",
+			content: `import { Hono } from "hono";
+import { raw } from "hono/html";
+import { defineMiddleware } from "void";
+import markdownStyle from "void-plugin-hono-jsx/theme-content.css?inline";
+import { decks } from "../src/decks";
+
+const app = new Hono();
+const devClient = import.meta.env.DEV ? '<script type="module" src="' + import.meta.env.BASE_URL + '@vite/client"><\/script>' : "";
+app.route(decks.mountPath, decks.router({
+  document: { head: raw(\`<style>\${markdownStyle}</style>\${devClient}\`) },
+}));
+
+export default defineMiddleware(async (c, next) => {
+  const mount = decks.mountPath.replace(/\\/$/, "");
+  if (c.req.path === mount || c.req.path.startsWith(mount + "/")) {
+    return app.fetch(c.req.raw, c.env, c.executionCtx);
+  }
+  await next();
+});
+`
+		},
+		{
+			path: `decks/${sampleSlug}/deck.${framework === "void" ? "md" : "mdx"}`,
+			content: `${framework === "void" ? "<script>\nimport Counter from \"./Counter.tsx\" with { island: \"load\" };\n<\/script>\n" : ""}---
+title: Welcome
+---
+# Welcome
+
+Edit decks/${sampleSlug}/deck.${framework === "void" ? "md" : "mdx"} to write your slides.
+
+---
+
+# Next slide
+
+Existing .mdx decks work alongside Hono Markdown.
+${framework === "void" ? "\n<Counter />\n" : ""}
+`
+		}
+	];
+	if (framework === "void") files.push({
+		path: `decks/${sampleSlug}/Counter.tsx`,
+		content: `import { useState } from "hono/jsx";
+
+export default function Counter() {
+  const [count, setCount] = useState(0);
+  return <button type="button" onClick={() => setCount(count + 1)}>Count: {count}</button>;
+}
+`
+	});
+	const edits = [];
+	if (framework !== "void") {
+		files.splice(2, 1);
+		files[1].content = files[1].content + `
+import { raw } from "hono/html";
+
+export const deckRouter = decks.router({
+  document: { head: raw(import.meta.env.DEV ? '<script type="module" src="' + import.meta.env.BASE_URL + '@vite/client"><\/script>' : "") },
+});
+`;
+		if (framework === "hono") {
+			const entryFile = selectHonoEntry(cwd, entry);
+			const appSource = await readFile(join(cwd, entryFile), "utf8");
+			edits.push({
+				path: entryFile,
+				content: connectHonoApp(appSource, relativeModule(entryFile, "src/decks.ts"))
+			});
+		} else {
+			if (!existsSync(join(cwd, "app/routes"))) throw new Error("HonoX init expects app/routes. Custom app directories require manual integration. No files were changed.");
+			for (const path of [
+				"app/routes/slides",
+				"app/routes/slides.ts",
+				"app/routes/slides.tsx",
+				"app/routes/slides.jsx",
+				"app/routes/slides.js"
+			]) if (existsSync(join(cwd, path))) throw new Error(`Refusing to replace existing HonoX route: ${path}`);
+			const serverFile = "app/server.ts";
+			const appSource = await readFile(join(cwd, serverFile), "utf8");
+			edits.push({
+				path: serverFile,
+				content: connectHonoXApp(appSource)
+			});
+			files.push({
+				path: "src/honox-decks.ts",
+				content: emitHonoXIntegration()
+			});
+		}
+	}
+	for (const file of files) if (existsSync(join(cwd, file.path))) throw new Error(`Refusing to overwrite existing file: ${file.path}`);
+	if (new Set(files.map((file) => file.path)).size !== files.length || files.some((file) => file.path === viteFile)) throw new Error("--config conflicts with an integration file. No files were changed.");
+	if (installation) {
+		if (framework !== "void") throw new Error("--install is supported for Void only.");
+		await installVoidDependencies(cwd, installation);
+	}
+	await publishGeneratedFiles([...[...files, ...edits].map((file) => ({
+		...file,
+		path: join(cwd, file.path)
+	})), {
+		path: join(cwd, viteFile),
+		content: patched
+	}]);
+	return sampleSlug;
+}
+function emitHonoXIntegration() {
+	return `/// <reference types="vite/client" />
+import type { Env } from "hono";
+import type { ServerOptions } from "honox/server";
+import { withHonoXDecks as connectHonoXDecks } from "hono-decks/honox";
+import { decks, deckRouter } from "./decks";
+
+// Same route discovery convention as HonoX. Keep this outside app/routes to
+// avoid importing the integration itself through the route glob.
+const fileRoutes = import.meta.glob([
+  "/app/routes/**/*.{ts,tsx,md,mdx}",
+  "/app/routes/.well-known/**/*.{ts,tsx,md,mdx}",
+  "!/app/routes/**/_*.{ts,tsx,md,mdx}",
+  "!/app/routes/**/-*.{ts,tsx,md,mdx}",
+  "!/app/routes/**/$*.{ts,tsx,md,mdx}",
+  "!/app/routes/**/*.test.{ts,tsx}",
+  "!/app/routes/**/*.spec.{ts,tsx}",
+  "!/app/routes/**/-*/**/*",
+], { eager: true }) as NonNullable<ServerOptions["ROUTES"]>;
+
+export function withHonoXDecks<E extends Env>(options: ServerOptions<E> = {}): ServerOptions<E> {
+  return connectHonoXDecks(options, { routes: fileRoutes, mountPath: decks.mountPath, router: deckRouter });
+}
+`;
+}
+/** Preserve createApp options while adding a config-driven route to HonoX. */
+function connectHonoXApp(source) {
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const unsupported = () => /* @__PURE__ */ new Error("Cannot safely connect this HonoX server. Wrap createApp options with withHonoXDecks from src/honox-decks. No files were changed.");
+	if (ast.program.interpreter) throw unsupported();
+	const constructors = ast.program.body.flatMap((node) => node.type === "ImportDeclaration" && node.source.value === "honox/server" ? node.specifiers.flatMap((item) => item.type === "ImportSpecifier" && item.imported.type === "Identifier" && item.imported.name === "createApp" ? [item.local.name] : []) : []);
+	const exported = ast.program.body.find((node) => node.type === "ExportDefaultDeclaration");
+	if (!exported || exported.type !== "ExportDefaultDeclaration" || exported.declaration.type !== "CallExpression" || exported.declaration.callee.type !== "Identifier" || !constructors.includes(exported.declaration.callee.name) || exported.declaration.arguments.length > 1) throw unsupported();
+	const call = exported.declaration;
+	const arg = call.arguments[0];
+	if (arg?.type === "SpreadElement" || call.end == null || call.callee.end == null) throw unsupported();
+	let alias = "withHonoXDecks";
+	while (source.includes(alias)) alias = "_" + alias;
+	const start = arg?.start ?? call.end - 1;
+	const end = arg?.end ?? start;
+	if (start == null || end == null) throw unsupported();
+	return `import { withHonoXDecks as ${alias} } from "../src/honox-decks";\n` + source.slice(0, start) + alias + "(" + source.slice(start, end) + ")" + source.slice(end);
+}
+/** Wrap only the default export expression, preserving app settings and comments. */
+function connectViteConfig(source, configFile) {
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	if (ast.program.interpreter) throw new Error("Vite config with a shebang requires manual integration. No files were changed.");
+	if (ast.program.body.some((node) => node.type === "ImportDeclaration" && node.source.value === "hono-decks/vite")) throw new Error("Vite config already imports hono-decks/vite. Keep one honoDecks() registration; no files were changed.");
+	const exported = ast.program.body.find((node) => node.type === "ExportDefaultDeclaration");
+	if (!exported || exported.type !== "ExportDefaultDeclaration" || exported.declaration.start == null || exported.declaration.end == null || exported.declaration.type === "FunctionDeclaration" || exported.declaration.type === "ClassDeclaration") throw new Error("Cannot safely wrap this Vite config. Add honoDecks() from hono-decks/vite to its plugins. No files were changed.");
+	let alias = "withHonoDecks";
+	while (source.includes(alias)) alias = "_" + alias;
+	const options = configFile === "hono-decks.config.ts" ? "" : `, { configFile: ${JSON.stringify(configFile)} }`;
+	const { start, end } = exported.declaration;
+	return `import { withHonoDecks as ${alias} } from "hono-decks/vite";\n` + source.slice(0, start) + `${alias}(` + source.slice(start, end) + options + ")" + source.slice(end);
+}
+function selectHonoEntry(cwd, entry) {
+	if (entry) {
+		if (entry.startsWith("/") || entry.includes("\\") || /^[A-Za-z]:/.test(entry) || entry.split("/").includes("..") || !/\.[cm]?[jt]sx?$/.test(entry)) throw new Error("--entry must be a JS/TS file inside the current working directory.");
+		return entry;
+	}
+	const candidates = [
+		"src/index.ts",
+		"src/index.tsx",
+		"src/index.js",
+		"src/index.mts",
+		"src/index.mjs",
+		"src/app.ts",
+		"src/app.tsx",
+		"src/app.js"
+	].filter((path) => existsSync(join(cwd, path)));
+	if (candidates.length !== 1) throw new Error("Cannot identify one Hono entry. Use --framework hono --entry path/to/app.ts. No files were changed.");
+	return candidates[0];
+}
+function relativeModule(from, to) {
+	const path = relative(from.includes("/") ? from.slice(0, from.lastIndexOf("/")) : ".", to).replaceAll("\\", "/").replace(/\.[cm]?[jt]sx?$/, "");
+	return path.startsWith(".") ? path : "./" + path;
+}
+/** Append after app middleware; refuse earlier routes that could consume /slides. */
+function connectHonoApp(source, facadeImport) {
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const unsupported = () => /* @__PURE__ */ new Error("Cannot safely connect this Hono entry. Export a const app = new Hono(), or mount decks.router() manually before conflicting routes. No files were changed.");
+	if (ast.program.interpreter) throw unsupported();
+	const exported = ast.program.body.find((node) => node.type === "ExportDefaultDeclaration");
+	if (!exported || exported.type !== "ExportDefaultDeclaration" || exported.declaration.type !== "Identifier" || exported.start == null) throw unsupported();
+	if (ast.program.body.slice(ast.program.body.indexOf(exported) + 1).some((node) => node.type !== "TSInterfaceDeclaration" && node.type !== "TSTypeAliasDeclaration" && !(node.type === "ExportNamedDeclaration" && node.exportKind === "type"))) throw unsupported();
+	const appName = exported.declaration.name;
+	const constructors = ast.program.body.flatMap((node) => node.type === "ImportDeclaration" && node.source.value === "hono" ? node.specifiers.flatMap((item) => item.type === "ImportSpecifier" && item.imported.type === "Identifier" && item.imported.name === "Hono" ? [item.local.name] : []) : []);
+	const declaration = ast.program.body.find((node) => node.type === "VariableDeclaration" && node.kind === "const" && node.declarations.some((item) => item.id.type === "Identifier" && item.id.name === appName && item.init?.type === "NewExpression" && item.init.callee.type === "Identifier" && constructors.includes(item.init.callee.name)));
+	if (!declaration || declaration.end == null || declaration.end > exported.start) throw unsupported();
+	function checkRoutes(value) {
+		if (!value || typeof value !== "object") return;
+		const node = value;
+		if (node.type === "CallExpression") {
+			const call = value;
+			if (call.callee.type === "MemberExpression") {
+				let receiver = call.callee.object;
+				while (receiver?.type === "CallExpression") receiver = receiver.callee.object;
+				const property = call.callee.property;
+				const method = property?.name ?? (typeof property?.value === "string" ? property.value : void 0);
+				if (receiver?.type === "Identifier" && receiver.name === appName && method && [
+					"get",
+					"post",
+					"put",
+					"patch",
+					"delete",
+					"options",
+					"head",
+					"all",
+					"on",
+					"route"
+				].includes(method)) {
+					const path = call.arguments[method === "on" ? 1 : 0];
+					if (!path || path.type !== "StringLiteral" || !path.value || path.value.includes(":") || path.value.includes("{") || path.value === "*" || path.value === "/*" || method === "route" && path.value === "/" || path.value.startsWith("/slides") || path.value.includes("*") && "/slides/".startsWith(path.value.split("*")[0])) throw unsupported();
+				}
+			}
+		}
+		for (const child of Object.values(node)) if (Array.isArray(child)) child.forEach(checkRoutes);
+		else if (child && typeof child === "object") checkRoutes(child);
+	}
+	checkRoutes(ast.program);
+	let alias = "_honoDecks";
+	while (source.includes(alias)) alias = "_" + alias;
+	const routerAlias = alias + "Router";
+	return `import { decks as ${alias}, deckRouter as ${routerAlias} } from ${JSON.stringify(facadeImport)};\n` + source.slice(0, exported.start) + `${appName}.route(${alias}.mountPath, ${routerAlias});\n\n` + source.slice(exported.start);
+}
+//#endregion
+export { initializeVite };

package/dist/mod.d.ts

@@ -130,6 +130,8 @@ interface CompiledDeck {
   meta: DeckFrontmatter;
   themeStyle?: string;
   themeSourcePath?: string;
+  /** Omit generated client code for explicitly static compiled decks. */
+  clientEntryRequired?: boolean;
   slides: CompiledSlide[];
   assets: AssetRef[];
   componentRegistry?: Record<string, SlideComponentInput>;
@@ -461,9 +463,14 @@ type DecksRouterOverrides<E extends Env = any> = Partial<Omit<DecksRouterOptions
 type DecksRouterConfig<E extends Env = any> = Omit<DecksRouterOverrides<E>, "source">;
 /** File-system settings consumed by the CLI. */
 interface DecksBuildConfig {
+  /** Build-only Markdown adapter reference. "void" retains the compatible preset. */
+  markdown?: "void" | {
+    adapter: string;
+    options?: Record<string, unknown>;
+  };
   /** Deck source directory. @default "decks" */
   root?: string;
-  /** Generated module directory. @default "src/generated" */
+  /** CLI output directory. Vite keeps modules in memory. @default "src/generated" */
   outDir?: string;
   /** Optional deterministic Open Graph metadata cache. */
   ogpCacheFile?: string;

package/dist/mod.js

@@ -567,6 +567,7 @@ function renderViewerScript(nonce) {
     }
 
     function handleKeydown(event) {
+      if (event.defaultPrevented) return;
       if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === "p" && printPath) {
         event.preventDefault();
         const printUrl = new URL(printPath, window.location.href);
@@ -574,6 +575,10 @@ function renderViewerScript(nonce) {
         window.location.assign(printUrl);
         return;
       }
+      if (event.metaKey || event.ctrlKey || event.altKey) return;
+      const target = event.target;
+      if (target instanceof HTMLElement && (target.isContentEditable || target.closest("input,textarea,select,button,a[href],[role=textbox],[role=button],[role=slider]"))) return;
+      if (["ArrowRight", "ArrowLeft", " "].includes(event.key)) event.preventDefault();
       if (event.key === "ArrowRight" || event.key === " ") sendCommand("next");
       if (event.key === "ArrowLeft") sendCommand("previous");
       if (event.key === "f") void toggleViewerFullscreen();
@@ -629,7 +634,7 @@ const VIEWER_ASPECT_RATIO = "16/9";
 function embeddedViewerStyle() {
 	const root = "[data-hono-decks-viewer][data-hono-decks-embed]";
 	return `${root}{color-scheme:dark;background:#050816;color:#eef2ff;font-family:Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;display:grid;gap:12px;width:100%;min-width:0;box-sizing:border-box}
-${root} *:focus-visible{outline:none}
+${root} *:focus-visible{outline:2px solid currentColor;outline-offset:2px}
 ${root} .hono-decks-viewer-shell{position:relative;display:grid;grid-template-rows:minmax(0,1fr);place-items:center;width:100%;min-width:0;min-height:0;box-sizing:border-box}
 ${root} .hono-decks-viewer-stage{display:grid;place-items:center;width:100%;min-width:0;min-height:0;container-type:inline-size}
 ${root} .hono-decks-viewport{width:100%;aspect-ratio:${VIEWER_ASPECT_RATIO};position:relative;overflow:hidden;touch-action:pan-y}
@@ -642,7 +647,7 @@ ${root} .hono-decks-mobile-navigation-next{right:.25rem}
 ${root} .hono-decks-mobile-navigation:focus-visible{outline:2px solid currentColor;outline-offset:-4px}
 ${root} .hono-decks-mobile-navigation:active{background:rgba(15,23,42,.28);color:#eef2ff;opacity:1}
 ${root} .hono-decks-mobile-navigation .hono-decks-control-icon{width:22px;height:22px}
-${root} .hono-decks-viewport>[data-hono-decks-position]{position:absolute;left:50%;bottom:8px;z-index:3;transform:translateX(-50%);border:0;background:transparent;color:inherit;padding:0;font:inherit;font-size:12px;line-height:1;opacity:.5;pointer-events:none;white-space:nowrap}
+${root} .hono-decks-viewport>[data-hono-decks-position]{position:absolute;left:50%;bottom:8px;z-index:3;transform:translateX(-50%);border:0;border-radius:4px;background:rgba(15,23,42,.9);color:#eef2ff;padding:4px 6px;font:inherit;font-size:12px;line-height:1;opacity:1;pointer-events:none;white-space:nowrap}
 ${root} .hono-decks-viewer-controls{position:absolute;left:50%;bottom:max(.25rem,env(safe-area-inset-bottom,0));display:flex;gap:8px;align-items:center;justify-content:center;max-width:calc(100% - 1rem);min-width:0;z-index:4;transform:translateX(-50%)}
 ${root} .hono-decks-viewer-controls [data-hono-decks-navigation-control="previous"],${root} .hono-decks-viewer-controls [data-hono-decks-navigation-control="next"],${root} .hono-decks-viewer-controls [data-hono-decks-position]{position:absolute;visibility:hidden;pointer-events:none}
 ${root} .hono-decks-viewer-controls button,${root} .hono-decks-viewer-controls a,${root} .hono-decks-viewer-controls span{border:1px solid rgba(148,163,184,.32);border-radius:8px;background:rgba(15,23,42,.78);color:inherit;padding:8px 10px;font:inherit;font-size:14px}