hono-decks 0.1.0

package/dist/vite.js

@@ -0,0 +1,2175 @@
+// src/vite.ts
+import { relative as relative3, resolve as resolve2 } from "path";
+
+// src/node/compile-decks.ts
+import { mkdir, readFile as readFile3, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/routing/file-routing.ts
+function resolveDeckFiles(paths, root = "decks") {
+  const normalizedRoot = normalizePath(root).replace(/\/$/, "");
+  const decks = /* @__PURE__ */ new Map();
+  const assetsBySlug = /* @__PURE__ */ new Map();
+  for (const inputPath of paths.map(normalizePath).sort()) {
+    assertInsideRoot(inputPath, normalizedRoot);
+    const relative4 = inputPath.slice(normalizedRoot.length + 1);
+    const segments = relative4.split("/");
+    if (segments.length === 1 && segments[0].endsWith(".mdx")) {
+      const slug = segments[0].replace(/\.mdx$/, "");
+      addDeck(decks, {
+        slug,
+        sourcePath: inputPath,
+        kind: "single-file",
+        assetPaths: []
+      });
+      continue;
+    }
+    if (segments.length === 2 && segments[1] === "deck.mdx") {
+      addDeck(decks, {
+        slug: segments[0],
+        sourcePath: inputPath,
+        kind: "directory",
+        assetPaths: assetsBySlug.get(segments[0]) ?? []
+      });
+      continue;
+    }
+    if (segments.length >= 3 && segments[1] === "assets") {
+      const slug = segments[0];
+      const assetPaths = assetsBySlug.get(slug) ?? [];
+      assetPaths.push(inputPath);
+      assetsBySlug.set(slug, assetPaths);
+      const deck = decks.get(slug);
+      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}`);
+    }
+  }
+  return [...decks.values()].map((deck) => ({
+    ...deck,
+    assetPaths: [...deck.assetPaths].sort()
+  }));
+}
+function addDeck(decks, next) {
+  const current = decks.get(next.slug);
+  if (current) {
+    throw new Error(`Deck slug conflict for "${next.slug}": ${current.sourcePath} and ${next.sourcePath}`);
+  }
+  decks.set(next.slug, next);
+}
+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(path) {
+  return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+}
+
+// src/deck/model.ts
+var SLIDE_TRANSITIONS = [
+  "none",
+  "fade",
+  "fade-out",
+  "slide-left",
+  "slide-right",
+  "slide-up",
+  "slide-down",
+  "view-transition"
+];
+var CompileError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "CompileError";
+  }
+};
+
+// src/deck/frontmatter.ts
+function readFrontmatter(source) {
+  const normalized = source.replace(/\r\n/g, "\n").trimStart();
+  if (!normalized.startsWith("---\n")) return { attrs: {}, body: source.trim() };
+  const end = normalized.indexOf("\n---", 4);
+  if (end === -1) throw new CompileError("Frontmatter block is not closed.", "frontmatter-unclosed");
+  const rawAttrs = normalized.slice(4, end).trim();
+  const body = normalized.slice(end + 4).replace(/^\n/, "").trim();
+  return { attrs: parseFrontmatterAttrs(rawAttrs), body };
+}
+function toDeckFrontmatter(attrs, warnings) {
+  const meta = { ...attrs };
+  const deck = { meta };
+  deck.title = takeString(meta, "title");
+  deck.description = takeString(meta, "description");
+  deck.author = takeString(meta, "author");
+  deck.date = takeString(meta, "date");
+  deck.theme = takeString(meta, "theme");
+  deck.transition = takeKnownStringWithWarning(meta, "transition", SLIDE_TRANSITIONS, "none", warnings, "unknown-transition");
+  deck.transitionDuration = takeTransitionDuration(meta, warnings);
+  deck.transitionEasing = takeTransitionEasing(meta, warnings);
+  deck.assets = takeStringOrStringArray(meta, "assets");
+  deck.draft = takeBoolean(meta, "draft");
+  deck.presenter = takeBoolean(meta, "presenter");
+  const tags = meta.tags;
+  if (Array.isArray(tags)) {
+    deck.tags = tags.map(String);
+    delete meta.tags;
+  }
+  return deck;
+}
+function toSlideFrontmatter(attrs, warnings, input) {
+  const meta = { ...attrs };
+  const slide = {
+    title: takeString(meta, "title") ?? input.fallbackTitle,
+    layout: takeString(meta, "layout") ?? input.fallbackLayout,
+    className: takeString(meta, "class") ?? input.fallbackClassName,
+    notes: takeString(meta, "notes"),
+    background: takeString(meta, "background"),
+    transition: takeKnownStringWithWarning(
+      meta,
+      "transition",
+      SLIDE_TRANSITIONS,
+      "none",
+      warnings,
+      "unknown-transition",
+      input.slideIndex
+    ) ?? input.fallbackTransition,
+    transitionDuration: takeTransitionDuration(meta, warnings, input.slideIndex) ?? input.fallbackTransitionDuration,
+    transitionEasing: takeTransitionEasing(meta, warnings, input.slideIndex) ?? input.fallbackTransitionEasing,
+    meta
+  };
+  return slide;
+}
+function addUnknownFrontmatterWarnings(warnings, meta, scope, slideIndex) {
+  for (const key of Object.keys(meta)) {
+    warnings.push({
+      code: "unknown-frontmatter-key",
+      message: `Unknown ${scope} frontmatter key "${key}" is preserved in meta.`,
+      ...slideIndex !== void 0 ? { slideIndex } : {}
+    });
+  }
+}
+function splitSlideSources(source) {
+  const lines = source.replace(/\r\n/g, "\n").trim().split("\n");
+  const slides = [];
+  let current = [];
+  let cursor = 0;
+  while (cursor < lines.length) {
+    if (isFence(lines[cursor])) {
+      if (looksLikeFrontmatterFence(lines, cursor) && findFrontmatterEnd(lines, cursor) === -1) {
+        throw new CompileError("Frontmatter block is not closed.", "frontmatter-unclosed");
+      }
+      if (isFrontmatterStart(lines, cursor)) {
+        if (hasMeaningfulLines(current)) {
+          slides.push(current.join("\n").trim());
+        }
+        current = [];
+        const frontmatterEnd = findFrontmatterEnd(lines, cursor);
+        current.push(...lines.slice(cursor, frontmatterEnd + 1));
+        cursor = frontmatterEnd + 1;
+        continue;
+      }
+      if (hasMeaningfulLines(current)) {
+        slides.push(current.join("\n").trim());
+        current = [];
+      }
+      cursor += 1;
+      continue;
+    }
+    current.push(lines[cursor]);
+    cursor += 1;
+  }
+  if (hasMeaningfulLines(current)) {
+    slides.push(current.join("\n").trim());
+  }
+  return slides;
+}
+function parseFrontmatterAttrs(source) {
+  const attrs = {};
+  const lines = source.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const match = /^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!match) {
+      if (line.trim()) {
+        throw new CompileError(`Invalid frontmatter line ${index + 1}: "${line.trim()}"`, "frontmatter-invalid-line");
+      }
+      continue;
+    }
+    const key = match[1];
+    const value = match[2];
+    if (value === "|") {
+      const block = [];
+      index += 1;
+      while (index < lines.length && /^\s+/.test(lines[index])) {
+        block.push(lines[index].trim());
+        index += 1;
+      }
+      index -= 1;
+      attrs[key] = block.join("\n").trim();
+      continue;
+    }
+    if (value.trim() === "") {
+      const nested = [];
+      index += 1;
+      while (index < lines.length && /^\s+/.test(lines[index])) {
+        nested.push(lines[index]);
+        index += 1;
+      }
+      index -= 1;
+      attrs[key] = parseNestedFrontmatterValue(nested);
+      continue;
+    }
+    attrs[key] = parseScalar(value);
+  }
+  return attrs;
+}
+function isFrontmatterStart(lines, index) {
+  return looksLikeFrontmatterFence(lines, index) && findFrontmatterEnd(lines, index) > index;
+}
+function looksLikeFrontmatterFence(lines, index) {
+  if (!isFence(lines[index])) return false;
+  const next = lines[index + 1];
+  return next != null && /^([A-Za-z_][A-Za-z0-9_-]*):\s*/.test(next);
+}
+function findFrontmatterEnd(lines, start) {
+  for (let index = start + 1; index < lines.length; index += 1) {
+    if (isFence(lines[index])) return index;
+  }
+  return -1;
+}
+function isFence(line) {
+  return /^---\s*$/.test(line);
+}
+function hasMeaningfulLines(lines) {
+  return lines.some((line) => line.trim() !== "");
+}
+function parseNestedFrontmatterValue(lines) {
+  const meaningful = lines.map((line) => line.trim()).filter(Boolean);
+  if (meaningful.every((line) => line.startsWith("- "))) {
+    return meaningful.map((line) => parseScalar(line.slice(2)));
+  }
+  const object = {};
+  for (const line of meaningful) {
+    const match = /^([A-Za-z_][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!match) {
+      throw new CompileError(`Invalid nested frontmatter line: "${line}"`, "frontmatter-invalid-line");
+    }
+    object[match[1]] = parseScalar(match[2]);
+  }
+  return object;
+}
+function parseScalar(value) {
+  const trimmed = value.trim().replace(/^['"]|['"]$/g, "");
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (/^\[.*\]$/.test(trimmed)) {
+    return trimmed.slice(1, -1).split(",").map((item) => item.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+  }
+  return trimmed;
+}
+function takeString(attrs, key) {
+  const value = attrs[key];
+  if (typeof value !== "string") return void 0;
+  delete attrs[key];
+  return value;
+}
+function takeKnownStringWithWarning(attrs, key, values, fallback, warnings, code, slideIndex) {
+  const value = attrs[key];
+  delete attrs[key];
+  if (value === void 0) return void 0;
+  if (typeof value === "string" && values.includes(value)) return value;
+  warnings.push({
+    code,
+    message: `Unknown ${key} value "${String(value)}"; using ${fallback}.`,
+    ...slideIndex !== void 0 ? { slideIndex } : {}
+  });
+  return fallback;
+}
+function takeTransitionDuration(attrs, warnings, slideIndex) {
+  const value = attrs.transitionDuration;
+  delete attrs.transitionDuration;
+  if (value === void 0) return void 0;
+  if (typeof value === "string" && isValidTransitionDuration(value)) return value;
+  warnings.push({
+    code: "invalid-transition-duration",
+    message: `Invalid transitionDuration value "${String(value)}"; ignoring it.`,
+    ...slideIndex !== void 0 ? { slideIndex } : {}
+  });
+  return void 0;
+}
+function takeTransitionEasing(attrs, warnings, slideIndex) {
+  const value = attrs.transitionEasing;
+  delete attrs.transitionEasing;
+  if (value === void 0) return void 0;
+  if (typeof value === "string" && isValidTransitionEasing(value)) return value;
+  warnings.push({
+    code: "invalid-transition-easing",
+    message: `Invalid transitionEasing value "${String(value)}"; ignoring it.`,
+    ...slideIndex !== void 0 ? { slideIndex } : {}
+  });
+  return void 0;
+}
+function isValidTransitionDuration(value) {
+  return value.split(",").map((item) => item.trim()).every((item) => /^(?:\d+|\d*\.\d+)(?:ms|s)$/.test(item));
+}
+function isValidTransitionEasing(value) {
+  const easing = value.trim();
+  return ["linear", "ease", "ease-in", "ease-out", "ease-in-out", "step-start", "step-end"].includes(easing) || /^cubic-bezier\(\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*,\s*-?(?:\d+|\d*\.\d+)\s*\)$/.test(
+    easing
+  ) || /^steps\(\s*\d+\s*(?:,\s*(?:jump-start|jump-end|jump-none|jump-both|start|end))?\s*\)$/.test(easing) || /^linear\([^)]+\)$/.test(easing);
+}
+function takeStringOrStringArray(attrs, key) {
+  const value = attrs[key];
+  if (typeof value === "string") {
+    delete attrs[key];
+    return value;
+  }
+  if (Array.isArray(value)) {
+    delete attrs[key];
+    return value.map(String);
+  }
+  return void 0;
+}
+function takeBoolean(attrs, key) {
+  const value = attrs[key];
+  if (typeof value !== "boolean") return void 0;
+  delete attrs[key];
+  return value;
+}
+
+// src/deck/assets.ts
+function buildExternalAssetRefs(candidates) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const type = assetRefType(candidate);
+    if (!type || refs.has(candidate)) continue;
+    const contentType = contentTypeForPath(candidate);
+    refs.set(candidate, {
+      sourcePath: candidate,
+      publicPath: candidate,
+      type,
+      ...contentType ? { contentType } : {}
+    });
+  }
+  return [...refs.values()];
+}
+function addExternalAssetWarnings(warnings, assets) {
+  for (const asset of assets) {
+    if (asset.type !== "remote" && asset.type !== "r2") continue;
+    const label = asset.type === "r2" ? "R2" : "Remote";
+    warnings.push({
+      code: "external-asset-unverified",
+      message: `${label} asset existence cannot be verified at compile time: ${asset.sourcePath}`
+    });
+  }
+}
+function collectMarkdownAssetCandidates(markdown) {
+  const candidates = [];
+  for (const match of markdown.matchAll(/^\s*(?:background|image|src|asset):\s*['"]?([^'"\n]+)['"]?\s*$/gim)) {
+    candidates.push(match[1].trim());
+  }
+  for (const match of markdown.matchAll(/!\[[^\]]*\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g)) {
+    candidates.push(match[1].trim());
+  }
+  for (const match of markdown.matchAll(/\b(?:src|href|image|background)=["']([^"']+)["']/g)) {
+    candidates.push(match[1].trim());
+  }
+  return candidates;
+}
+function collectFrontmatterAssetCandidates(value) {
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+  if (typeof value === "string") return [value.trim()].filter(Boolean);
+  return [];
+}
+function contentTypeForPath(path) {
+  const pathname = path.replace(/\?.*$/, "").toLowerCase();
+  if (/\.png(?:#.*)?$/.test(pathname)) return "image/png";
+  if (/\.jpe?g(?:#.*)?$/.test(pathname)) return "image/jpeg";
+  if (/\.gif(?:#.*)?$/.test(pathname)) return "image/gif";
+  if (/\.svg(?:#.*)?$/.test(pathname)) return "image/svg+xml";
+  if (/\.webp(?:#.*)?$/.test(pathname)) return "image/webp";
+  return void 0;
+}
+function assetRefType(value) {
+  if (/^https?:\/\//i.test(value)) return "remote";
+  if (/^r2:\/\//i.test(value)) return "r2";
+  if (value.startsWith("/")) return "public";
+  return void 0;
+}
+
+// src/deck/speaker-notes.ts
+function extractMdxCommentSpeakerNotes(source) {
+  const notes = [];
+  const body = source.replace(/\{\/\*([\s\S]*?)\*\/\}/g, (_match, rawNote) => {
+    const note = normalizeSpeakerNote(rawNote);
+    if (note) notes.push(note);
+    return "";
+  });
+  return {
+    body,
+    ...notes.length ? { notes: notes.join("\n\n") } : {}
+  };
+}
+function combineSpeakerNotes(...notes) {
+  const combined = notes.map((note) => note?.trim()).filter((note) => Boolean(note));
+  return combined.length ? combined.join("\n\n") : void 0;
+}
+function normalizeSpeakerNote(value) {
+  return value.replace(/\r\n/g, "\n").split("\n").map((line) => line.trim()).join("\n").trim();
+}
+
+// src/parser/parser.ts
+import { unified } from "unified";
+import remarkGfm from "remark-gfm";
+import remarkMdx from "remark-mdx";
+import remarkParse from "remark-parse";
+var slideSeparator = /^---\s*$/m;
+function parseDeckWithWarnings(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n").trim();
+  const chunks = normalized.length > 0 ? normalized.split(slideSeparator) : [""];
+  const parsedSlides = chunks.map((chunk, index) => parseSlide(chunk.trim(), index)).filter(({ slide }) => slide.raw.length > 0 || slide.blocks.length > 0 || slide.nodes.length > 0);
+  return {
+    slides: parsedSlides.map(({ slide }) => slide),
+    warnings: parsedSlides.flatMap(({ warnings }) => warnings)
+  };
+}
+function parseSlide(source, index) {
+  const { attrs, body } = readSlideAttributes(source);
+  const parsed = parseContent(body, index);
+  const firstHeading = parsed.blocks.find((block) => block.type === "heading");
+  return {
+    slide: {
+      index,
+      title: stringAttr(attrs.title) ?? firstHeading?.text,
+      layout: stringAttr(attrs.layout) ?? (index === 0 ? "cover" : "default"),
+      className: stringAttr(attrs.class),
+      blocks: parsed.blocks,
+      nodes: parsed.nodes,
+      raw: source
+    },
+    warnings: parsed.warnings
+  };
+}
+function readSlideAttributes(source) {
+  const lines = source.split("\n");
+  const attrs = {};
+  let cursor = 0;
+  while (cursor < lines.length) {
+    const line = lines[cursor];
+    const match = /^(title|layout|class):\s*(.+)$/.exec(line);
+    if (!match) break;
+    attrs[match[1]] = match[2].trim().replace(/^['"]|['"]$/g, "");
+    cursor += 1;
+  }
+  return { attrs, body: lines.slice(cursor).join("\n").trim() };
+}
+function parseContent(body, slideIndex) {
+  const { root, warnings: parseWarnings } = parseMarkdownTree(body, slideIndex);
+  const blockResults = (root.children ?? []).map((child) => toBlocks(child, slideIndex, body));
+  const nodeResults = (root.children ?? []).map((child) => toNodes(child, slideIndex, body));
+  return {
+    blocks: blockResults.flatMap(({ blocks }) => blocks),
+    nodes: nodeResults.flatMap(({ nodes }) => nodes),
+    warnings: [
+      ...fenceWarningsFor(body, slideIndex),
+      ...parseWarnings,
+      ...blockResults.flatMap(({ warnings }) => warnings),
+      ...nodeResults.flatMap(({ warnings }) => warnings)
+    ]
+  };
+}
+function parseMarkdownTree(body, slideIndex) {
+  try {
+    return {
+      root: unified().use(remarkParse).use(remarkGfm).use(remarkMdx).parse(body),
+      warnings: []
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown MDX parse error";
+    return {
+      root: unified().use(remarkParse).use(remarkGfm).parse(body),
+      warnings: [parserWarning("mdx-parse-error", `Slide ${slideIndex + 1}: ${message}`, slideIndex)]
+    };
+  }
+}
+function fenceWarningsFor(body, slideIndex) {
+  let openFence;
+  for (const line of body.split("\n")) {
+    const match = /^(```|~~~)/.exec(line);
+    if (!match) continue;
+    if (!openFence) {
+      openFence = match[1];
+      continue;
+    }
+    if (line.startsWith(openFence)) openFence = void 0;
+  }
+  if (!openFence) return [];
+  return [parserWarning("code-fence-unclosed", `Slide ${slideIndex + 1}: code fence is not closed.`, slideIndex)];
+}
+function toBlocks(node, slideIndex, source) {
+  switch (node.type) {
+    case "heading":
+      return blockResult([{ type: "heading", depth: headingDepth(node.depth), text: textContent(node) }]);
+    case "paragraph": {
+      const image = soleImage(node);
+      if (image) {
+        return blockResult([
+          {
+            type: "image",
+            alt: image.alt ?? "",
+            src: image.url ?? "",
+            ...image.title ? { title: image.title } : {}
+          }
+        ]);
+      }
+      return blockResult([{ type: "paragraph", text: textContent(node).replace(/\s+/g, " ").trim() }]);
+    }
+    case "list":
+      return blockResult([
+        {
+          type: "list",
+          ordered: node.ordered === true,
+          items: (node.children ?? []).map((item) => taskListItemText(item)).filter(Boolean)
+        }
+      ]);
+    case "code":
+      return blockResult([{ type: "code", lang: node.lang ?? void 0, code: node.value ?? "" }]);
+    case "blockquote":
+      return blockResult([{ type: "blockquote", text: textContent(node).trim() }]);
+    case "table":
+      return blockResult([tableBlock(node)]);
+    case "mdxJsxFlowElement":
+    case "mdxJsxTextElement":
+      return jsxElementBlock(node, slideIndex, source);
+    case "mdxjsEsm":
+    case "mdxFlowExpression":
+    case "mdxTextExpression":
+    case "thematicBreak":
+      return blockResult([]);
+    default:
+      return blockResult(textContent(node).trim() ? [{ type: "paragraph", text: textContent(node).trim() }] : []);
+  }
+}
+function jsxElementBlock(node, slideIndex, source) {
+  const name = node.name ?? "";
+  if (!name) return blockResult([]);
+  if (isComponentName(name)) {
+    const parsedProps = parseProps(node.attributes ?? [], slideIndex, name);
+    return blockResult(
+      [
+        {
+          type: "component",
+          name,
+          props: parsedProps.props,
+          raw: sourceForNode(node, source) ?? `<${name} />`
+        }
+      ],
+      parsedProps.warnings
+    );
+  }
+  return blockResult([{ type: "paragraph", text: textContent(node).trim() }]);
+}
+function toNodes(node, slideIndex, source) {
+  switch (node.type) {
+    case "text":
+      return nodeResult(node.value ? [{ type: "text", value: node.value }] : []);
+    case "emphasis":
+      return elementNodeResult(node, "em", slideIndex, source);
+    case "strong":
+      return elementNodeResult(node, "strong", slideIndex, source);
+    case "delete":
+      return elementNodeResult(node, "del", slideIndex, source);
+    case "inlineCode":
+      return nodeResult([{ type: "element", tag: "code", props: {}, children: [{ type: "text", value: node.value ?? "" }] }]);
+    case "break":
+      return nodeResult([{ type: "element", tag: "br", props: {}, children: [] }]);
+    case "heading":
+      return elementNodeResult(node, `h${headingDepth(node.depth)}`, slideIndex, source);
+    case "paragraph": {
+      if (soleImage(node)) return childrenToNodes(node, slideIndex, source);
+      if (isJsxOnlyParagraph(node)) return childrenToNodes(node, slideIndex, source);
+      return elementNodeResult(node, "p", slideIndex, source);
+    }
+    case "list": {
+      const tag = node.ordered === true ? "ol" : "ul";
+      const items = node.children ?? [];
+      const childResults = items.map((child) => childrenToNodes(child, slideIndex, source));
+      return nodeResult(
+        [
+          {
+            type: "element",
+            tag,
+            props: {},
+            children: childResults.map(({ nodes }, itemIndex) => listItemNode(nodes, items[itemIndex]?.checked))
+          }
+        ],
+        childResults.flatMap(({ warnings }) => warnings)
+      );
+    }
+    case "listItem":
+      return childrenToNodes(node, slideIndex, source);
+    case "code":
+      return nodeResult([{ type: "code", lang: node.lang ?? void 0, value: node.value ?? "" }]);
+    case "blockquote":
+      return elementNodeResult(node, "blockquote", slideIndex, source);
+    case "image":
+      return nodeResult([
+        {
+          type: "element",
+          tag: "img",
+          props: { src: node.url ?? "", alt: node.alt ?? "", ...node.title ? { title: node.title } : {} },
+          children: []
+        }
+      ]);
+    case "link":
+      return elementNodeResult(node, "a", slideIndex, source, { href: node.url ?? "" });
+    case "table":
+      return tableNodes(node, slideIndex, source);
+    case "mdxJsxFlowElement":
+    case "mdxJsxTextElement":
+      return jsxElementNodes(node, slideIndex, source);
+    case "mdxjsEsm":
+      return nodeResult(
+        [],
+        [
+          parserWarning(
+            "mdx-import-export-ignored",
+            `Slide ${slideIndex + 1}: MDX import/export syntax is ignored.`,
+            slideIndex
+          )
+        ]
+      );
+    case "mdxFlowExpression":
+    case "mdxTextExpression":
+      return nodeResult(
+        [],
+        [
+          parserWarning(
+            "mdx-expression-ignored",
+            `Slide ${slideIndex + 1}: MDX JavaScript expressions are ignored.`,
+            slideIndex
+          )
+        ]
+      );
+    case "thematicBreak":
+      return nodeResult([{ type: "element", tag: "hr", props: {}, children: [] }]);
+    default:
+      return childrenToNodes(node, slideIndex, source);
+  }
+}
+function elementNodeResult(node, tag, slideIndex, source, props = {}) {
+  const children = childrenToNodes(node, slideIndex, source);
+  return nodeResult(
+    [
+      {
+        type: "element",
+        tag,
+        props,
+        children: children.nodes
+      }
+    ],
+    children.warnings
+  );
+}
+function listItemNode(children, checked) {
+  if (typeof checked !== "boolean") return { type: "element", tag: "li", props: {}, children };
+  return {
+    type: "element",
+    tag: "li",
+    props: { class: "task-list-item" },
+    children: [
+      {
+        type: "element",
+        tag: "input",
+        props: { type: "checkbox", disabled: true, ...checked ? { checked: true } : {} },
+        children: []
+      },
+      { type: "text", value: " " },
+      ...children
+    ]
+  };
+}
+function tableNodes(node, slideIndex, source) {
+  const align = node.align ?? [];
+  const [headerRow, ...bodyRows] = node.children ?? [];
+  const headerResult = headerRow ? tableRowCells(headerRow, "th", align, slideIndex, source) : cellsResult([]);
+  const bodyResults = bodyRows.map((row) => tableRowCells(row, "td", align, slideIndex, source));
+  return nodeResult(
+    [
+      {
+        type: "element",
+        tag: "table",
+        props: {},
+        children: [
+          {
+            type: "element",
+            tag: "thead",
+            props: {},
+            children: [{ type: "element", tag: "tr", props: {}, children: headerResult.cells }]
+          },
+          {
+            type: "element",
+            tag: "tbody",
+            props: {},
+            children: bodyResults.map(({ cells }) => ({ type: "element", tag: "tr", props: {}, children: cells }))
+          }
+        ]
+      }
+    ],
+    [...headerResult.warnings, ...bodyResults.flatMap(({ warnings }) => warnings)]
+  );
+}
+function cellsResult(cells, emittedWarnings = []) {
+  return { cells, warnings: emittedWarnings };
+}
+function tableRowCells(row, tag, align, slideIndex, source) {
+  const results = (row.children ?? []).map((cell, cellIndex) => {
+    const children = childrenToNodes(cell, slideIndex, source);
+    const cellAlign = toTableAlign(align[cellIndex]);
+    return {
+      cell: {
+        type: "element",
+        tag,
+        props: cellAlign ? { style: `text-align:${cellAlign}` } : {},
+        children: children.nodes
+      },
+      warnings: children.warnings
+    };
+  });
+  return cellsResult(
+    results.map(({ cell }) => cell),
+    results.flatMap(({ warnings }) => warnings)
+  );
+}
+function jsxElementNodes(node, slideIndex, source) {
+  const name = node.name ?? "";
+  if (!name) return childrenToNodes(node, slideIndex, source);
+  if (isUnsafeHtmlElement(name)) {
+    return nodeResult([{ type: "text", value: sourceForNode(node, source) ?? textContent(node) }]);
+  }
+  const parsedProps = parseProps(node.attributes ?? [], slideIndex, name);
+  const parsedChildren = childrenToNodes(node, slideIndex, source);
+  const children = parsedChildren.nodes.filter((child) => child.type !== "text" || child.value.trim() !== "");
+  const warnings = [...parsedProps.warnings, ...parsedChildren.warnings];
+  if (isComponentName(name)) return nodeResult([{ type: "component", name, props: parsedProps.props, children }], warnings);
+  return nodeResult([{ type: "element", tag: name, props: parsedProps.props, children }], warnings);
+}
+function childrenToNodes(node, slideIndex, source) {
+  const results = (node.children ?? []).map((child) => toNodes(child, slideIndex, source));
+  return nodeResult(
+    results.flatMap(({ nodes }) => nodes),
+    results.flatMap(({ warnings }) => warnings)
+  );
+}
+function parseProps(attributes, slideIndex, componentName) {
+  const props = {};
+  const warnings = attributes.flatMap((attr) => {
+    if (attr.type !== "mdxJsxAttribute" || !attr.name) return [];
+    if (attr.value === null || attr.value === void 0) {
+      props[attr.name] = true;
+      return [];
+    }
+    if (typeof attr.value === "string" || typeof attr.value === "number" || typeof attr.value === "boolean") {
+      props[attr.name] = attr.value;
+      return [];
+    }
+    return [
+      parserWarning(
+        "mdx-expression-prop-ignored",
+        `Slide ${slideIndex + 1}: MDX JavaScript expression props are ignored on ${ignoredPropTarget(componentName, attr.name)}.`,
+        slideIndex
+      )
+    ];
+  });
+  return { props, warnings };
+}
+function blockResult(blocks, emittedWarnings = []) {
+  return { blocks, warnings: emittedWarnings };
+}
+function nodeResult(nodes, emittedWarnings = []) {
+  return { nodes, warnings: emittedWarnings };
+}
+function parserWarning(code, message, slideIndex) {
+  return { code, message, slideIndex };
+}
+function ignoredPropTarget(componentName, propName) {
+  if (propName.startsWith("$")) return `${componentName} dynamic prop`;
+  return `${componentName}.${propName}`;
+}
+function textContent(node) {
+  if (typeof node.value === "string") return node.value;
+  if (node.type === "strong") return `**${(node.children ?? []).map(textContent).join("")}**`;
+  if (node.type === "emphasis") return `*${(node.children ?? []).map(textContent).join("")}*`;
+  if (node.type === "delete") return `~~${(node.children ?? []).map(textContent).join("")}~~`;
+  if (node.type === "inlineCode") return `\`${node.value ?? ""}\``;
+  if ((node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement") && node.name && !isComponentName(node.name)) {
+    return `<${node.name}>${(node.children ?? []).map(textContent).join("")}</${node.name}>`;
+  }
+  return (node.children ?? []).map(textContent).join("");
+}
+function taskListItemText(item) {
+  const text = textContent(item).replace(/\s+/g, " ").trim();
+  if (typeof item.checked === "boolean") return `${item.checked ? "[x]" : "[ ]"} ${text}`.trim();
+  return text;
+}
+function tableBlock(node) {
+  const rows = (node.children ?? []).map(
+    (row) => (row.children ?? []).map((cell) => textContent(cell).replace(/\s+/g, " ").trim())
+  );
+  const [header = [], ...bodyRows] = rows;
+  return {
+    type: "table",
+    align: (node.align ?? []).map(toTableAlign),
+    header,
+    rows: bodyRows
+  };
+}
+function toTableAlign(value) {
+  return value === "left" || value === "center" || value === "right" ? value : void 0;
+}
+function soleImage(node) {
+  const meaningful = (node.children ?? []).filter((child) => child.type !== "text" || child.value?.trim());
+  return meaningful.length === 1 && meaningful[0].type === "image" ? meaningful[0] : void 0;
+}
+function isJsxOnlyParagraph(node) {
+  const children = node.children ?? [];
+  return children.length > 0 && children.every(
+    (child) => child.type === "mdxJsxTextElement" || child.type === "mdxJsxFlowElement" || child.type === "text" && child.value?.trim() === ""
+  );
+}
+function sourceForNode(node, source) {
+  const start = node.position?.start?.offset;
+  const end = node.position?.end?.offset;
+  return typeof start === "number" && typeof end === "number" ? source.slice(start, end) : void 0;
+}
+function isComponentName(name) {
+  return /^[A-Z]/.test(name);
+}
+function isUnsafeHtmlElement(name) {
+  return /^(script|style|iframe|object|embed)$/i.test(name);
+}
+function headingDepth(value) {
+  if (value === 1 || value === 2 || value === 3) return value;
+  return 3;
+}
+function stringAttr(value) {
+  return value && value.length > 0 ? value : void 0;
+}
+
+// src/generator/mdx/assets.ts
+function rewriteAssetUrls(source, assets) {
+  let result = source;
+  for (const asset of assets) {
+    const assetPath = localAssetRelativePath(asset.sourcePath);
+    result = result.replaceAll(`./assets/${assetPath}`, asset.publicPath);
+    result = result.replace(new RegExp(`(?<!/)assets/${escapeRegExp(assetPath)}`, "g"), asset.publicPath);
+  }
+  return result;
+}
+function rewriteRelativeMdxImports(source, sourceDir, generatedDir) {
+  return source.replace(/(from\s+|import\s+)(["'])(\.[^"']+)\2/g, (_match, prefix, quote, specifier) => {
+    const target = normalizePath2(`${sourceDir}/${specifier}`);
+    return `${prefix}${quote}${toRelativeImportPath(generatedDir, target)}${quote}`;
+  });
+}
+function componentImportPath(outDir, sourcePath) {
+  if (!sourcePath) return void 0;
+  const source = sourcePath.replace(/\/index\.(tsx|ts|jsx|js)$/, "");
+  return toRelativeImportPath(outDir, source);
+}
+function dirname(path) {
+  const normalized = normalizePath2(path);
+  const index = normalized.lastIndexOf("/");
+  return index === -1 ? "." : normalized.slice(0, index);
+}
+function localAssetRelativePath(sourcePath) {
+  const marker = "/assets/";
+  const normalized = normalizePath2(sourcePath);
+  const markerIndex = normalized.indexOf(marker);
+  return markerIndex === -1 ? normalized.split("/").at(-1) ?? normalized : normalized.slice(markerIndex + marker.length);
+}
+function normalizePath2(path) {
+  return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+}
+function toRelativeImportPath(fromDir, target) {
+  const fromParts = normalizePath2(fromDir).split("/").filter(Boolean);
+  const targetParts = normalizePath2(target).split("/").filter(Boolean);
+  while (fromParts.length > 0 && targetParts.length > 0 && fromParts[0] === targetParts[0]) {
+    fromParts.shift();
+    targetParts.shift();
+  }
+  const relative4 = [...fromParts.map(() => ".."), ...targetParts].join("/");
+  return relative4.startsWith(".") ? relative4 : `./${relative4 || "."}`;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/generator/assets.ts
+async function buildAssetRefs(slug, assetPaths, input) {
+  return Promise.all(
+    assetPaths.map(async (sourcePath) => ({
+      sourcePath,
+      publicPath: `${normalizeMountPath(input.mountPath ?? `/${input.root}`)}/${encodeURIComponent(slug)}/assets/${assetName(
+        sourcePath,
+        input.root,
+        slug
+      )}`,
+      type: "local",
+      contentType: contentTypeForPath(sourcePath),
+      body: input.readBinary ? await input.readBinary(sourcePath) : void 0
+    }))
+  );
+}
+function assetName(sourcePath, root, slug) {
+  const normalizedPath = normalizePath3(sourcePath);
+  const prefix = `${normalizePath3(root).replace(/\/$/, "")}/${slug}/assets/`;
+  const relative4 = normalizedPath.startsWith(prefix) ? normalizedPath.slice(prefix.length) : normalizedPath.split("/").at(-1) ?? normalizedPath;
+  return relative4.split("/").map(encodeURIComponent).join("/");
+}
+function normalizeMountPath(value) {
+  const withLeadingSlash = value.startsWith("/") ? value : `/${value}`;
+  return withLeadingSlash.replace(/\/$/, "");
+}
+function normalizePath3(path) {
+  return path.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+/g, "/");
+}
+
+// src/generator/package-entry.ts
+var DECKS_RUNTIME_ENTRY = "hono-decks";
+var DECKS_ADVANCED_ENTRY = "hono-decks/advanced";
+
+// src/generator/mdx-module-generator.ts
+import { compile } from "@mdx-js/mdx";
+import remarkDirective from "remark-directive";
+import remarkGfm2 from "remark-gfm";
+
+// src/generator/mdx/emit.ts
+function emitModuleDecksRouter(input) {
+  const runtimeEntry = JSON.stringify(DECKS_RUNTIME_ENTRY);
+  const advancedEntry = JSON.stringify(DECKS_ADVANCED_ENTRY);
+  const slideImports = input.decks.flatMap(
+    (deck) => deck.slideModules.map(
+      (slide, index) => `import ${slideImportName(deck.deck.slug, index)} from ${JSON.stringify(slide.importPath)};`
+    )
+  ).join("\n");
+  const componentImports = input.decks.filter((deck) => deck.componentModulePath).map((deck) => `import * as ${componentImportName(deck.deck.slug)} from ${JSON.stringify(deck.componentModulePath)};`).join("\n");
+  return `// @ts-nocheck
+import { configureDecks, defineDecks } from ${advancedEntry};
+import type { ConfiguredDecks, DecksConfig } from ${runtimeEntry};
+import type { Env } from "hono";
+import { decksClientEntry } from "./client-entry";
+${slideImports}
+${componentImports}
+
+function withClientComponentIds(module, clientIds) {
+  const registry = {};
+  for (const [name, value] of Object.entries(module)) {
+    const clientId = clientIds[name];
+    if (typeof value === "function") {
+      registry[name] = clientId ? { component: value, clientId } : value;
+      continue;
+    }
+    if (value && typeof value === "object" && "component" in value) {
+      registry[name] = clientId ? { ...value, clientId } : value;
+    }
+  }
+  return registry;
+}
+
+const generatedDecks = defineDecks({
+  clientEntryAsset: decksClientEntry,
+  decks: [
+${input.decks.map(emitDeckObject).join(",\n")}
+  ]
+});
+
+export function createDecks<E extends Env = any>(config: DecksConfig<E>): ConfiguredDecks<E> {
+  return configureDecks(definedDecksFor<E>(), config);
+}
+
+function definedDecksFor<E extends Env>() {
+  return generatedDecks;
+}
+`;
+}
+function emitDeckObject(deck) {
+  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)},
+${deck.deck.themeStyle ? `      "themeStyle": ${serializeValue(deck.deck.themeStyle, 3)},
+` : ""}${deck.deck.themeSourcePath ? `      "themeSourcePath": ${JSON.stringify(deck.deck.themeSourcePath)},
+` : ""}
+      assets: ${serializeValue(deck.deck.assets, 3)},
+      componentRegistry: ${deck.componentModulePath ? `withClientComponentIds(${componentImportName(deck.deck.slug)}, ${serializeValue(deck.clientComponentIds ?? {}, 3)})` : "{}"},
+      warnings: ${serializeValue(deck.deck.warnings, 3)},
+      slides: [
+${deck.deck.slides.map(
+    (slide) => `        {
+          index: ${slide.index},
+          meta: ${serializeValue(slide.meta, 5)},
+          html: "",
+          components: [],
+          notes: ${serializeValue(slide.notes, 5)},
+          render: ${slideImportName(deck.deck.slug, slide.index)}
+        }`
+  ).join(",\n")}
+      ]
+    }`;
+}
+function slideImportName(slug, index) {
+  return `Slide_${safeIdentifier(slug)}_${index}`;
+}
+function componentImportName(slug) {
+  return `Components_${safeIdentifier(slug)}`;
+}
+function safeIdentifier(value) {
+  return value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/, "_") || "_";
+}
+function serializeValue(value, depth) {
+  const indent = "  ".repeat(depth);
+  const nextIndent = "  ".repeat(depth + 1);
+  if (value === void 0) return "undefined";
+  if (value instanceof Uint8Array) return `new Uint8Array([${[...value].join(", ")}])`;
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    return `[
+${value.map((item) => `${nextIndent}${serializeValue(item, depth + 1)}`).join(",\n")}
+${indent}]`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value).filter(([, item]) => item !== void 0);
+    if (entries.length === 0) return "{}";
+    return `{
+${entries.map(([key, item]) => `${nextIndent}${JSON.stringify(key)}: ${serializeValue(item, depth + 1)}`).join(",\n")}
+${indent}}`;
+  }
+  return JSON.stringify(value);
+}
+
+// src/generator/mdx/ogp.ts
+async function resolveLinkCardMetadataByUrl(source, resolveOgp) {
+  const result = /* @__PURE__ */ new Map();
+  if (!resolveOgp) return result;
+  for (const url of collectLinkCardUrls(source)) {
+    try {
+      const metadata = await resolveOgp(url);
+      if (metadata) result.set(url, metadata);
+    } catch {
+    }
+  }
+  return result;
+}
+function collectLinkCardUrls(source) {
+  const urls = /* @__PURE__ */ new Set();
+  const pattern = /@\[card\]\(([^)\s]+)\)/g;
+  for (const match of source.matchAll(pattern)) {
+    urls.add(match[1]);
+  }
+  return [...urls];
+}
+
+// src/generator/mdx/syntax.ts
+import { codeToHtml } from "shiki";
+function remarkDeckSyntax(input = {}) {
+  return () => (tree) => {
+    transformDeckSyntaxChildren(tree, input);
+  };
+}
+function remarkCodeHighlight() {
+  return async (tree) => {
+    await highlightMarkdownNode(tree);
+  };
+}
+function transformDeckSyntaxChildren(node, input) {
+  if (!Array.isArray(node.children)) return;
+  const children = [];
+  for (const child of node.children) {
+    transformDeckSyntaxChildren(child, input);
+    rejectRemovedFireAuthoring(child);
+    children.push(
+      fireAttributeNode(child) ?? zennEmbedNode(child, input) ?? plainUrlLinkNode(child) ?? fireDirectiveNode(child) ?? unknownDirectiveFallback(child) ?? child
+    );
+  }
+  node.children = children;
+}
+function rejectRemovedFireAuthoring(node) {
+  if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement") return;
+  if (!Array.isArray(node.attributes)) return;
+  if (node.attributes.some((attribute) => attribute.name === "$fire")) {
+    throw new Error('The "$fire" prop is not supported. Use fire or fire="effect" on a block-level custom component.');
+  }
+  if (node.name === "Fire" && node.attributes.some((attribute) => attribute.name === "order")) {
+    throw new Error('The Fire "order" prop is not supported. Fires reveal in source order.');
+  }
+  if (node.name === "Fire") {
+    const atAttribute = node.attributes.find((attribute) => attribute.name === "at");
+    if (atAttribute) fireAtAttributeValue(atAttribute.value);
+  }
+}
+function fireAttributeNode(node) {
+  if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement") return void 0;
+  if (!Array.isArray(node.attributes)) return void 0;
+  const fireAttribute = node.attributes.find(
+    (attribute) => attribute.type === "mdxJsxAttribute" && attribute.name === "fire"
+  );
+  if (!fireAttribute) return void 0;
+  const atAttribute = node.attributes.find(
+    (attribute) => attribute.type === "mdxJsxAttribute" && attribute.name === "at"
+  );
+  if (node.name === "Fire") {
+    throw new Error('The "fire" attribute is not supported on <Fire>. Use the effect prop instead.');
+  }
+  if (!node.name || !/^[A-Z]/.test(node.name)) {
+    throw new Error('The "fire" attribute is only supported on custom components. Use :::fire for Markdown content.');
+  }
+  if (node.type !== "mdxJsxFlowElement") {
+    throw new Error('The "fire" attribute is only supported on block-level custom components. Move the component to its own line.');
+  }
+  if (fireAttribute.value !== null && fireAttribute.value !== void 0 && typeof fireAttribute.value !== "string") {
+    throw new Error('The "fire" attribute accepts no value or a static effect name such as fire="fade-up".');
+  }
+  const effect = typeof fireAttribute.value === "string" ? fireAttribute.value.trim() : "";
+  const at = atAttribute ? fireAtAttributeValue(atAttribute.value) : void 0;
+  node.attributes = node.attributes.filter((attribute) => attribute !== fireAttribute && attribute !== atAttribute);
+  return mdxElement(
+    "Fire",
+    [
+      ...effect ? [mdxAttribute("effect", effect)] : [],
+      ...at ? [mdxAttribute("at", at)] : []
+    ],
+    [node]
+  );
+}
+function fireAtAttributeValue(value) {
+  if (typeof value === "string") {
+    const at = value.trim();
+    if (/^(?:\d+|[+-]\d+)$/.test(at)) return at;
+  }
+  throw new Error('The fire "at" attribute accepts a non-negative integer or a relative value such as "+1".');
+}
+function zennEmbedNode(node, input) {
+  if (node.type !== "paragraph" || !Array.isArray(node.children) || node.children.length !== 2) return void 0;
+  const [prefix, link] = node.children;
+  if (prefix?.type !== "text" || String(prefix.value ?? "").trim() !== "@") return void 0;
+  if (link?.type !== "link" || typeof link.url !== "string") return void 0;
+  const name = collectMarkdownText(link).trim().toLowerCase();
+  if (name === "youtube") {
+    return mdxElement(
+      "EmbedFrame",
+      [
+        mdxAttribute("provider", "youtube"),
+        mdxAttribute("src", toYoutubeEmbedUrl(link.url)),
+        mdxAttribute("fallbackHref", link.url),
+        mdxAttribute("title", "YouTube embed example")
+      ],
+      [{ type: "text", value: "Open YouTube embed" }]
+    );
+  }
+  if (name === "x") {
+    return mdxElement("TweetEmbed", [mdxAttribute("href", link.url), mdxAttribute("label", "Open post on X")], []);
+  }
+  if (name === "card") {
+    const metadata = input.linkCardMetadata?.get(link.url);
+    return mdxElement(
+      "LinkCard",
+      [
+        mdxAttribute("href", link.url),
+        ...metadataAttributes(metadata)
+      ],
+      []
+    );
+  }
+  if (name === "embed" || name === "iframe") {
+    return mdxElement(
+      "EmbedFrame",
+      [mdxAttribute("src", link.url), mdxAttribute("title", "Embedded content")],
+      [{ type: "text", value: "Open embed" }]
+    );
+  }
+  return void 0;
+}
+function metadataAttributes(metadata) {
+  if (!metadata) return [];
+  return [
+    ...metadata.title ? [mdxAttribute("title", metadata.title)] : [],
+    ...metadata.description ? [mdxAttribute("description", metadata.description)] : [],
+    ...metadata.image ? [mdxAttribute("image", metadata.image)] : [],
+    ...metadata.siteName ? [mdxAttribute("siteName", metadata.siteName)] : []
+  ];
+}
+function plainUrlLinkNode(node) {
+  if (node.type !== "paragraph" || !Array.isArray(node.children) || node.children.length !== 1) return void 0;
+  const [child] = node.children;
+  if (child?.type !== "text" || typeof child.value !== "string") return void 0;
+  const value = child.value.trim();
+  if (!isHttpUrl(value)) return void 0;
+  return {
+    type: "paragraph",
+    children: [
+      {
+        type: "link",
+        url: value,
+        children: [{ type: "text", value }]
+      }
+    ]
+  };
+}
+function isHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.protocol === "http:";
+  } catch {
+    return false;
+  }
+}
+function fireDirectiveNode(node) {
+  if (node.type !== "containerDirective" || node.name !== "fire") return void 0;
+  const attributes = directiveAttributes(node);
+  if (attributes.order !== void 0) {
+    throw new Error('The fire "order" attribute is not supported. Fires reveal in source order.');
+  }
+  if (attributes.each === void 0 && (attributes.depth !== void 0 || attributes.every !== void 0)) {
+    throw new Error('The fire "depth" and "every" attributes require each="item".');
+  }
+  if (attributes.each !== void 0) return fireEachItemNode(node, attributes);
+  const at = attributes.at !== void 0 ? fireAtAttributeValue(attributes.at) : void 0;
+  const fireAttributes = [
+    ...typeof attributes.effect === "string" ? [mdxAttribute("effect", attributes.effect)] : [],
+    ...at ? [mdxAttribute("at", at)] : []
+  ];
+  return mdxElement("Fire", fireAttributes, node.children ?? []);
+}
+function fireEachItemNode(node, attributes) {
+  if (attributes.each !== "item") {
+    throw new Error('The fire "each" attribute only accepts "item".');
+  }
+  const children = node.children ?? [];
+  const list = children.length === 1 && children[0]?.type === "list" ? children[0] : void 0;
+  if (!list) {
+    throw new Error('fire each="item" must contain exactly one Markdown list.');
+  }
+  const depth = positiveFireInteger(attributes.depth, "depth", 1);
+  const every = positiveFireInteger(attributes.every, "every", 1);
+  const at = attributes.at !== void 0 ? fireAtAttributeValue(attributes.at) : void 0;
+  const effect = attributes.effect ? fireEffectToken(attributes.effect) : void 0;
+  const items = fireListItems(list, depth);
+  for (const [itemIndex, item] of items.entries()) {
+    const itemAt = fireListItemAt(at, every, itemIndex);
+    item.data = {
+      ...item.data,
+      hProperties: {
+        ...item.data?.hProperties,
+        "data-hono-decks-fire": "true",
+        ...itemAt ? { "data-fire-at": itemAt } : {},
+        ...effect ? { "data-fire-effect": effect } : {}
+      }
+    };
+  }
+  return list;
+}
+function positiveFireInteger(value, name, fallback) {
+  if (value === void 0) return fallback;
+  const parsed = Number(value);
+  if (Number.isInteger(parsed) && parsed > 0) return parsed;
+  throw new Error(`The fire "${name}" attribute accepts a positive integer.`);
+}
+function fireListItems(list, maxDepth, depth = 1) {
+  const items = [];
+  for (const item of list.children ?? []) {
+    if (item.type !== "listItem") continue;
+    items.push(item);
+    if (depth >= maxDepth) continue;
+    for (const child of item.children ?? []) {
+      if (child.type === "list") items.push(...fireListItems(child, maxDepth, depth + 1));
+    }
+  }
+  return items;
+}
+function fireListItemAt(at, every, itemIndex) {
+  if (at && /^\d+$/.test(at)) return String(Number(at) + Math.floor(itemIndex / every));
+  if (!at && every === 1) return void 0;
+  if (itemIndex === 0) return at;
+  return itemIndex % every === 0 ? "+1" : "+0";
+}
+function fireEffectToken(value) {
+  return value.trim().replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "fade";
+}
+function unknownDirectiveFallback(node) {
+  if (node.type === "textDirective") return { type: "text", value: `:${node.name ?? ""}` };
+  if (node.type === "leafDirective") return { type: "text", value: `::${node.name ?? ""}` };
+  if (node.type === "containerDirective") {
+    return {
+      type: "paragraph",
+      children: [{ type: "text", value: `:::${node.name ?? ""}` }, ...node.children ?? []]
+    };
+  }
+  return void 0;
+}
+function directiveAttributes(node) {
+  if (!node.attributes || Array.isArray(node.attributes)) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(node.attributes)) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      result[key] = String(value);
+    }
+  }
+  return result;
+}
+function mdxElement(name, attributes, children) {
+  return {
+    type: "mdxJsxFlowElement",
+    name,
+    attributes,
+    children
+  };
+}
+function toYoutubeEmbedUrl(value) {
+  try {
+    const url = new URL(value);
+    const host = url.hostname.replace(/^www\./, "");
+    if (host === "youtu.be") {
+      const id = url.pathname.split("/").filter(Boolean)[0];
+      return id ? `https://www.youtube.com/embed/${id}` : value;
+    }
+    if (host === "youtube.com" || host === "m.youtube.com") {
+      if (url.pathname.startsWith("/embed/")) return value;
+      const id = url.searchParams.get("v");
+      return id ? `https://www.youtube.com/embed/${id}` : value;
+    }
+    return value;
+  } catch {
+    return value;
+  }
+}
+async function highlightMarkdownNode(node) {
+  if (node.type === "code") {
+    const code = typeof node.value === "string" ? node.value : "";
+    const lang = typeof node.lang === "string" && node.lang ? node.lang : void 0;
+    const highlightedHtml = await highlightCodeBlock(code, lang);
+    node.type = "mdxJsxFlowElement";
+    node.name = "CodeBlock";
+    node.attributes = [
+      ...lang ? [mdxAttribute("lang", lang)] : [],
+      mdxAttribute("highlightedHtml", highlightedHtml)
+    ];
+    node.children = [{ type: "text", value: code }];
+    delete node.value;
+    delete node.lang;
+    delete node.meta;
+    return;
+  }
+  if (node.type === "mdxJsxFlowElement" && node.name === "CodeBlock") {
+    const code = collectMarkdownText(node);
+    if (code.trim()) {
+      const lang = getMdxStringAttribute(node, "lang");
+      const highlightedHtml = await highlightCodeBlock(code, lang);
+      node.attributes = upsertMdxStringAttribute(node.attributes, "highlightedHtml", highlightedHtml);
+    }
+    return;
+  }
+  if (!Array.isArray(node.children)) return;
+  await Promise.all(node.children.map((child) => highlightMarkdownNode(child)));
+}
+async function highlightCodeBlock(code, lang) {
+  const language = lang && /^[A-Za-z0-9_#+.-]+$/.test(lang) ? lang : "text";
+  try {
+    return await codeToHtml(code, { lang: language, theme: "github-dark" });
+  } catch (error) {
+    if (language === "text") throw error;
+    return codeToHtml(code, { lang: "text", theme: "github-dark" });
+  }
+}
+function mdxAttribute(name, value) {
+  return { type: "mdxJsxAttribute", name, value };
+}
+function getMdxStringAttribute(node, name) {
+  const attributes = Array.isArray(node.attributes) ? node.attributes : [];
+  const attribute = attributes.find((item) => item.type === "mdxJsxAttribute" && item.name === name);
+  return typeof attribute?.value === "string" ? attribute.value : void 0;
+}
+function upsertMdxStringAttribute(attributes, name, value) {
+  const next = Array.isArray(attributes) ? [...attributes] : [];
+  const index = next.findIndex((item) => item.type === "mdxJsxAttribute" && item.name === name);
+  const attribute = mdxAttribute(name, value);
+  if (index === -1) return [...next, attribute];
+  next[index] = attribute;
+  return next;
+}
+function collectMarkdownText(node) {
+  if (typeof node.value === "string") return node.value;
+  if (!Array.isArray(node.children)) return "";
+  return node.children.map((child) => collectMarkdownText(child)).join(node.type === "paragraph" ? "\n" : "");
+}
+
+// src/generator/mdx-module-generator.ts
+async function compileMdxModuleDecks(input) {
+  const decks = await Promise.all(input.decks.map((entry) => compileMdxModuleDeck(input, entry)));
+  return {
+    decks,
+    routerModule: emitModuleDecksRouter({ decks })
+  };
+}
+async function compileMdxModuleDeck(input, entry) {
+  const source = await input.readText(entry.sourcePath);
+  const { attrs, body } = readFrontmatter(source);
+  const { prelude, body: contentBody } = extractDeckPrelude(body);
+  const slideSources = splitSlideSources(contentBody);
+  let warnings = [];
+  const deckMeta = toDeckFrontmatter(attrs, warnings);
+  addUnknownFrontmatterWarnings(warnings, deckMeta.meta, "deck");
+  const assets = [
+    ...await buildAssetRefs(entry.slug, entry.assetPaths, input),
+    ...collectGeneratedExternalAssetRefs(contentBody, deckMeta)
+  ];
+  const componentModulePath = componentImportPath(input.outDir, input.componentModulePaths?.[entry.slug]);
+  const themeStyle = entry.kind === "directory" ? input.themeStyles?.[entry.slug] : void 0;
+  const slideModules = [];
+  const slides = [];
+  for (let index = 0; index < slideSources.length; index += 1) {
+    const { attrs: slideAttrs, body: slideBody } = readFrontmatter(slideSources[index]);
+    const speakerNotes = extractMdxCommentSpeakerNotes(slideBody);
+    const parsed = parseDeckWithWarnings(speakerNotes.body);
+    warnings = warnings.concat(toGeneratedParserCompileWarnings(parsed.warnings, index));
+    const firstParsedSlide = parsed.slides[0];
+    const slideModulePath = `${input.outDir}/decks/${entry.slug}/slide-${index}.ts`;
+    const slideMeta = toSlideFrontmatter(slideAttrs, warnings, {
+      slideIndex: index,
+      fallbackTransition: deckMeta.transition,
+      fallbackTransitionDuration: deckMeta.transitionDuration,
+      fallbackTransitionEasing: deckMeta.transitionEasing,
+      fallbackTitle: firstParsedSlide?.title,
+      fallbackLayout: firstParsedSlide?.layout,
+      fallbackClassName: firstParsedSlide?.className
+    });
+    addUnknownFrontmatterWarnings(warnings, slideMeta.meta, "slide", index);
+    const moduleSource = [prelude, rewriteAssetUrls(speakerNotes.body, assets)].filter(Boolean).join("\n\n");
+    const rewrittenSource = rewriteRelativeMdxImports(moduleSource, dirname(entry.sourcePath), dirname(slideModulePath));
+    const code = await compileMdxModule(rewrittenSource, entry.sourcePath, index, input.resolveOgp);
+    slideModules.push({
+      path: slideModulePath,
+      importPath: `./decks/${entry.slug}/slide-${index}`,
+      code
+    });
+    slides.push({
+      index,
+      meta: slideMeta,
+      html: "",
+      components: [],
+      notes: combineSpeakerNotes(slideMeta.notes, speakerNotes.notes)
+    });
+  }
+  addExternalAssetWarnings(warnings, assets);
+  return {
+    componentModulePath,
+    clientComponentIds: input.clientComponentIds?.[entry.slug],
+    deck: {
+      slug: entry.slug,
+      sourcePath: entry.sourcePath,
+      kind: entry.kind,
+      meta: deckMeta,
+      themeStyle: themeStyle?.style,
+      themeSourcePath: themeStyle?.sourcePath,
+      slides,
+      assets,
+      warnings
+    },
+    slideModules
+  };
+}
+function collectGeneratedExternalAssetRefs(contentBody, deckMeta) {
+  return buildExternalAssetRefs([
+    ...collectMarkdownAssetCandidates(contentBody),
+    ...collectFrontmatterAssetCandidates(deckMeta.assets)
+  ]);
+}
+function generatedMdxParserWarnings(warnings) {
+  return warnings.filter((warning) => warning.code === "code-fence-unclosed");
+}
+function toGeneratedParserCompileWarnings(warnings, slideIndex) {
+  return generatedMdxParserWarnings(warnings).map((warning) => ({
+    code: "parse-warning",
+    message: warning.message,
+    slideIndex
+  }));
+}
+async function compileMdxModule(source, sourcePath, slideIndex, resolveOgp) {
+  try {
+    const linkCardMetadata = await resolveLinkCardMetadataByUrl(source, resolveOgp);
+    const compiled = String(
+      await compile(
+        { path: `${sourcePath}#slide-${slideIndex + 1}`, value: source },
+        {
+          jsxRuntime: "automatic",
+          jsxImportSource: "hono/jsx",
+          format: "mdx",
+          elementAttributeNameCase: "html",
+          remarkPlugins: [
+            remarkGfm2,
+            remarkDirective,
+            remarkDeckSyntax({ linkCardMetadata }),
+            remarkCodeHighlight
+          ]
+        }
+      )
+    );
+    return `// @ts-nocheck
+${compiled}`;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CompileError(
+      `MDX compile failed in ${sourcePath} slide ${slideIndex + 1}: ${message}`,
+      "mdx-compile-error"
+    );
+  }
+}
+function extractDeckPrelude(source) {
+  const lines = source.replace(/\r\n/g, "\n").split("\n");
+  const prelude = [];
+  let cursor = 0;
+  while (cursor < lines.length) {
+    const line = lines[cursor];
+    if (line.trim() === "") {
+      prelude.push(line);
+      cursor += 1;
+      continue;
+    }
+    if (/^\s*(import|export)\s/.test(line)) {
+      prelude.push(line);
+      cursor += 1;
+      continue;
+    }
+    break;
+  }
+  return {
+    prelude: prelude.join("\n").trim(),
+    body: lines.slice(cursor).join("\n").trim()
+  };
+}
+
+// src/node/client-entry.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { build as buildBrowserBundle } from "esbuild";
+async function discoverClientComponentIds(input) {
+  const result = {};
+  for (const entry of input.clientEntries) {
+    const source = await readFile(join(input.cwd, entry.sourcePath), "utf8");
+    const exports = extractComponentExportNames(source);
+    result[entry.slug] = Object.fromEntries(exports.map((name) => [name, clientComponentId(entry.slug, name)]));
+  }
+  return result;
+}
+async function emitClientEntryModule(input) {
+  const imports = [];
+  const registrations = [];
+  for (const entry of input.clientEntries) {
+    const ids = input.clientComponentIds[entry.slug] ?? {};
+    for (const [exportName, clientId] of Object.entries(ids)) {
+      const localName = clientImportName(entry.slug, exportName);
+      imports.push(`import { ${exportName} as ${localName} } from ${JSON.stringify(join(input.cwd, entry.sourcePath))};`);
+      registrations.push(`${JSON.stringify(clientId)}: ${localName}`);
+    }
+  }
+  if (registrations.length === 0) return 'export const decksClientEntry = "";\n';
+  const entryContents = `import { hydrateSlideIslands } from "hono-decks/client";
+${imports.join("\n")}
+
+hydrateSlideIslands({
+  components: {
+    ${registrations.join(",\n    ")}
+  }
+});
+`;
+  const result = await buildBrowserBundle({
+    stdin: {
+      contents: entryContents,
+      resolveDir: input.cwd,
+      sourcefile: "hono-decks-client-entry.tsx",
+      loader: "tsx"
+    },
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "browser",
+    target: "es2022",
+    jsx: "automatic",
+    jsxImportSource: "hono/jsx/dom",
+    nodePaths: nodeModuleFallbackPaths(input.cwd),
+    alias: { "hono-decks/client": resolveClientRuntimeEntry() },
+    sourcemap: false,
+    minify: false
+  });
+  const output = result.outputFiles[0];
+  if (!output) throw new Error("Client entry did not produce output.");
+  return `export const decksClientEntry = ${JSON.stringify(output.text)};
+`;
+}
+function resolveClientRuntimeEntry() {
+  const built = fileURLToPath(new URL("./client.js", import.meta.url));
+  if (existsSync(built)) return built;
+  return fileURLToPath(new URL("../client.ts", import.meta.url));
+}
+function extractComponentExportNames(source) {
+  const names = /* @__PURE__ */ new Set();
+  for (const match of source.matchAll(/\bexport\s+function\s+([A-Z][A-Za-z0-9_]*)\b/g)) {
+    names.add(match[1]);
+  }
+  for (const match of source.matchAll(/\bexport\s+const\s+([A-Z][A-Za-z0-9_]*)\b/g)) {
+    names.add(match[1]);
+  }
+  return [...names].sort();
+}
+function nodeModuleFallbackPaths(cwd) {
+  const current = process.cwd();
+  return [
+    join(cwd, "node_modules"),
+    join(cwd, "..", "node_modules"),
+    join(cwd, "..", "..", "node_modules"),
+    join(current, "node_modules"),
+    join(current, "..", "node_modules"),
+    join(current, "..", "..", "node_modules")
+  ];
+}
+function clientComponentId(slug, exportName) {
+  const base = `${exportName}__${safeIdentifier2(slug)}`;
+  return `${base}_${hashString(`${slug}:${exportName}`).slice(0, 8)}`;
+}
+function clientImportName(slug, exportName) {
+  return `${safeIdentifier2(exportName)}__${safeIdentifier2(slug)}_${hashString(`${slug}:${exportName}`).slice(0, 8)}`;
+}
+function hashString(value) {
+  let hash = 5381;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = hash * 33 ^ value.charCodeAt(index);
+  }
+  return (hash >>> 0).toString(36);
+}
+function safeIdentifier2(value) {
+  return value.replace(/[^A-Za-z0-9_$]+/g, "_").replace(/^[^A-Za-z_$]+/, "_") || "_";
+}
+
+// src/node/local-deck-io.ts
+import { existsSync as existsSync2, watch } from "fs";
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { join as join2, relative as relative2 } from "path";
+
+// src/node/path-utils.ts
+import { relative } from "path";
+function dirname2(path) {
+  const normalized = normalizePath4(path);
+  return normalized.includes("/") ? normalized.slice(0, normalized.lastIndexOf("/")) : ".";
+}
+function normalizePath4(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 = normalizePath4(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;
+}
+
+// src/node/local-deck-io.ts
+async function listFiles(cwd, dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const paths = await Promise.all(
+    entries.map(async (entry) => {
+      const fullPath = join2(dir, entry.name);
+      if (entry.isDirectory()) return listFiles(cwd, fullPath);
+      if (entry.isFile()) return [normalizePath4(relative2(cwd, fullPath))];
+      return [];
+    })
+  );
+  return paths.flat().sort();
+}
+
+// src/node/ogp.ts
+import { lookup } from "dns/promises";
+import { isIP } from "net";
+var MAX_OGP_BYTES = 256 * 1024;
+var MAX_OGP_REDIRECTS = 3;
+async function resolveOgpMetadata(url) {
+  if (!isHttpUrl2(url) || typeof fetch === "undefined") return void 0;
+  try {
+    const response = await fetchPublicHttpUrl(url);
+    if (!response) return void 0;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!response.ok || !contentType.toLowerCase().includes("text/html") || isTooLarge(response)) return void 0;
+    const html = await readTextWithLimit(response, MAX_OGP_BYTES);
+    if (!html) return void 0;
+    return parseOgpHtml(html, response.url || url);
+  } catch {
+    return void 0;
+  }
+}
+async function fetchPublicHttpUrl(url) {
+  let current = url;
+  for (let redirect = 0; redirect <= MAX_OGP_REDIRECTS; redirect += 1) {
+    if (!await isPublicHttpUrl(current)) return void 0;
+    const response = await fetch(current, {
+      headers: { accept: "text/html,application/xhtml+xml" },
+      redirect: "manual",
+      signal: AbortSignal.timeout(1500)
+    });
+    if (!isRedirect(response.status)) return response;
+    await response.body?.cancel();
+    const location = response.headers.get("location");
+    if (!location) return void 0;
+    current = new URL(location, current).toString();
+  }
+  return void 0;
+}
+async function isPublicHttpUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  if (isLocalHostname(url.hostname)) return false;
+  if (isPrivateIpAddress(url.hostname)) return false;
+  const addresses = await lookup(url.hostname, { all: true, verbatim: true });
+  return addresses.length > 0 && addresses.every(({ address }) => !isPrivateIpAddress(address));
+}
+function isLocalHostname(hostname) {
+  const normalized = hostname.toLowerCase().replace(/\.$/, "");
+  return normalized === "localhost" || normalized.endsWith(".localhost");
+}
+function isPrivateIpAddress(value) {
+  const normalized = value.startsWith("[") && value.endsWith("]") ? value.slice(1, -1) : value;
+  const version = isIP(normalized);
+  if (version === 4) return isPrivateIpv4(normalized);
+  if (version === 6) return isPrivateIpv6(normalized);
+  return false;
+}
+function isPrivateIpv4(address) {
+  const parts = address.split(".").map((part) => Number.parseInt(part, 10));
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return true;
+  const [a, b] = parts;
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
+}
+function isPrivateIpv6(address) {
+  const normalized = address.toLowerCase();
+  if (normalized === "::" || normalized === "::1" || normalized.startsWith("fe80:") || normalized.startsWith("fec0:") || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("ff")) {
+    return true;
+  }
+  if (normalized.startsWith("::ffff:")) {
+    const tail = normalized.slice("::ffff:".length);
+    const dotted = tail.match(/^(?:0:)?(\d+\.\d+\.\d+\.\d+)$/);
+    if (dotted) return isPrivateIpv4(dotted[1]);
+    const hex = tail.match(/^(?:0:)?([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+    if (hex) {
+      const hi = Number.parseInt(hex[1], 16);
+      const lo = Number.parseInt(hex[2], 16);
+      const value32 = hi << 16 | lo;
+      const ipv4 = [value32 >>> 24 & 255, value32 >>> 16 & 255, value32 >>> 8 & 255, value32 & 255].join(".");
+      return isPrivateIpv4(ipv4);
+    }
+  }
+  return false;
+}
+function isRedirect(status) {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function isTooLarge(response) {
+  const contentLength = response.headers.get("content-length");
+  return contentLength != null && Number(contentLength) > MAX_OGP_BYTES;
+}
+async function readTextWithLimit(response, maxBytes) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    const text = await response.text();
+    return new TextEncoder().encode(text).byteLength > maxBytes ? void 0 : text;
+  }
+  const chunks = [];
+  let bytes = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    bytes += value.byteLength;
+    if (bytes > maxBytes) {
+      await reader.cancel();
+      return void 0;
+    }
+    chunks.push(value);
+  }
+  const buffer = new Uint8Array(bytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    buffer.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(buffer);
+}
+function parseOgpHtml(html, pageUrl) {
+  const meta = collectHtmlMeta(html);
+  const title = firstValue(meta, ["og:title", "twitter:title"]) ?? htmlTitle(html);
+  const description = firstValue(meta, ["og:description", "twitter:description", "description"]);
+  const image = absoluteUrl(firstValue(meta, ["og:image", "og:image:url", "twitter:image"]), pageUrl);
+  const siteName = firstValue(meta, ["og:site_name", "application-name"]);
+  const result = { title, description, image, siteName };
+  return Object.values(result).some(Boolean) ? result : void 0;
+}
+function collectHtmlMeta(html) {
+  const meta = /* @__PURE__ */ new Map();
+  const tagPattern = /<meta\b[^>]*>/gi;
+  for (const match of html.matchAll(tagPattern)) {
+    const attributes = parseHtmlAttributes(match[0]);
+    const key = attributes.property ?? attributes.name;
+    const content = attributes.content;
+    if (key && content && !meta.has(key.toLowerCase())) {
+      meta.set(key.toLowerCase(), decodeHtmlEntities(content.trim()));
+    }
+  }
+  return meta;
+}
+function parseHtmlAttributes(tag) {
+  const attributes = {};
+  const attributePattern = /([^\s"'<>/=]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/g;
+  for (const match of tag.matchAll(attributePattern)) {
+    attributes[match[1].toLowerCase()] = match[2] ?? match[3] ?? match[4] ?? "";
+  }
+  return attributes;
+}
+function firstValue(meta, keys) {
+  for (const key of keys) {
+    const value = meta.get(key);
+    if (value) return value;
+  }
+  return void 0;
+}
+function htmlTitle(html) {
+  const match = html.match(/<title\b[^>]*>([\s\S]*?)<\/title>/i);
+  return match ? decodeHtmlEntities(match[1].replace(/\s+/g, " ").trim()) : void 0;
+}
+function absoluteUrl(value, base) {
+  if (!value) return void 0;
+  try {
+    return new URL(value, base).toString();
+  } catch {
+    return value;
+  }
+}
+function decodeHtmlEntities(value) {
+  return value.replaceAll("&amp;", "&").replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">");
+}
+function isHttpUrl2(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+// src/node/compile-decks.ts
+async function compileDecks(input) {
+  const out = normalizeRelativePath(input.out, "Output directory");
+  const root = normalizeDeckRoot(input.root);
+  const paths = await listFiles(input.cwd, join3(input.cwd, root));
+  const resolved = resolveDeckFiles(paths, root);
+  const componentModulePaths = Object.fromEntries(
+    resolved.flatMap((deck) => {
+      const path = deck.kind === "directory" ? findComponentModule(paths, root, deck.slug) : void 0;
+      return path ? [[deck.slug, path]] : [];
+    })
+  );
+  const clientEntryPaths = resolved.flatMap((deck) => {
+    const path = deck.kind === "directory" ? findClientEntryModule(paths, root, deck.slug) : void 0;
+    return path ? [{ slug: deck.slug, sourcePath: path }] : [];
+  });
+  const themeStyles = await discoverDeckThemeStyles({ cwd: input.cwd, root, paths, decks: resolved });
+  const clientComponentIds = await discoverClientComponentIds({
+    cwd: input.cwd,
+    clientEntries: clientEntryPaths
+  });
+  const ogpCache = await createOgpCacheResolver({
+    cwd: input.cwd,
+    cacheFile: input.ogpCacheFile,
+    refresh: input.refreshOgp,
+    resolveOgp: input.resolveOgp ?? resolveOgpMetadata
+  });
+  const generated = await compileMdxModuleDecks({
+    root,
+    outDir: out,
+    mountPath: input.mountPath,
+    decks: resolved,
+    componentModulePaths,
+    clientComponentIds,
+    themeStyles,
+    resolveOgp: ogpCache.resolveOgp,
+    readText: (path) => readFile3(join3(input.cwd, path), "utf8"),
+    readBinary: (path) => readFile3(join3(input.cwd, path))
+  });
+  for (const deck of generated.decks) {
+    for (const slide of deck.slideModules) {
+      await writeTextFile(join3(input.cwd, slide.path), slide.code);
+    }
+  }
+  await writeTextFile(join3(input.cwd, out, "decks.ts"), generated.routerModule);
+  await writeTextFile(
+    join3(input.cwd, out, "client-entry.ts"),
+    await emitClientEntryModule({ cwd: input.cwd, clientEntries: clientEntryPaths, clientComponentIds })
+  );
+  await ogpCache.write();
+  return { decks: generated.decks.map((deck) => deck.deck) };
+}
+async function createOgpCacheResolver(input) {
+  if (!input.cacheFile) {
+    return {
+      resolveOgp: input.resolveOgp,
+      write: async () => void 0
+    };
+  }
+  const cachePath = join3(input.cwd, normalizeRelativePath(input.cacheFile, "OGP cache file"));
+  const cache = await readOgpCache(cachePath);
+  let dirty = false;
+  return {
+    async resolveOgp(url) {
+      if (!input.refresh && cache[url]) return cache[url];
+      if (!input.refresh) return void 0;
+      const metadata = await input.resolveOgp(url);
+      if (metadata) {
+        cache[url] = metadata;
+        dirty = true;
+      }
+      return metadata;
+    },
+    async write() {
+      if (!dirty) return;
+      await writeTextFile(cachePath, `${JSON.stringify(cache, null, 2)}
+`);
+    }
+  };
+}
+async function readOgpCache(path) {
+  let raw;
+  try {
+    raw = await readFile3(path, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return {};
+    throw error;
+  }
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("OGP cache file must contain a JSON object");
+  }
+  const cache = {};
+  for (const [url, value] of Object.entries(parsed)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const metadata = value;
+    cache[url] = {
+      ...typeof metadata.title === "string" ? { title: metadata.title } : {},
+      ...typeof metadata.description === "string" ? { description: metadata.description } : {},
+      ...typeof metadata.image === "string" ? { image: metadata.image } : {},
+      ...typeof metadata.siteName === "string" ? { siteName: metadata.siteName } : {}
+    };
+  }
+  return cache;
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+async function writeTextFile(path, contents) {
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile(path, contents, "utf8");
+}
+function findComponentModule(paths, root, slug) {
+  const base = `${normalizePath4(root).replace(/\/$/, "")}/${slug}/components/index`;
+  return paths.find((path) => {
+    const normalized = normalizePath4(path);
+    return normalized === `${base}.tsx` || normalized === `${base}.ts` || normalized === `${base}.jsx` || normalized === `${base}.js`;
+  });
+}
+function findClientEntryModule(paths, root, slug) {
+  const base = `${normalizePath4(root).replace(/\/$/, "")}/${slug}/components/client/index`;
+  return paths.find((path) => {
+    const normalized = normalizePath4(path);
+    return normalized === `${base}.tsx` || normalized === `${base}.ts` || normalized === `${base}.jsx` || normalized === `${base}.js`;
+  });
+}
+async function discoverDeckThemeStyles(input) {
+  const result = {};
+  for (const deck of input.decks) {
+    if (deck.kind !== "directory") continue;
+    const sourcePath = findDeckThemeStyle(input.paths, input.root, deck.slug);
+    if (!sourcePath) continue;
+    result[deck.slug] = {
+      sourcePath,
+      style: await readFile3(join3(input.cwd, sourcePath), "utf8")
+    };
+  }
+  return result;
+}
+function findDeckThemeStyle(paths, root, slug) {
+  const base = `${normalizePath4(root).replace(/\/$/, "")}/${slug}`;
+  const themePath = `${base}/theme.css`;
+  const stylesEntryPath = `${base}/styles/index.css`;
+  const hasTheme = paths.includes(themePath);
+  const hasStylesEntry = paths.includes(stylesEntryPath);
+  if (hasTheme && hasStylesEntry) {
+    throw new Error(`Deck ${slug} has both ${themePath} and ${stylesEntryPath}. Use only one theme CSS entry.`);
+  }
+  return hasTheme ? themePath : hasStylesEntry ? stylesEntryPath : void 0;
+}
+
+// src/node/config.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { build } from "esbuild";
+var DEFAULT_DECKS_CONFIG_FILE = "hono-decks.config.ts";
+async function loadDecksConfig(input) {
+  const path = resolve(input.cwd, input.configFile ?? DEFAULT_DECKS_CONFIG_FILE);
+  if (!existsSync3(path)) {
+    throw new Error(`Config file not found: ${input.configFile ?? DEFAULT_DECKS_CONFIG_FILE}. Run \`hono-decks init\` first.`);
+  }
+  const result = await build({
+    absWorkingDir: input.cwd,
+    entryPoints: [path],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    write: false,
+    logLevel: "silent",
+    alias: {
+      "hono-decks": resolveRuntimeEntry()
+    }
+  });
+  const source = result.outputFiles[0]?.text;
+  if (!source) throw new Error(`Could not load config file: ${path}`);
+  const module = await import(`data:text/javascript;charset=utf-8,${encodeURIComponent(source)}#${Date.now()}`);
+  const config = module.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}`);
+  return {
+    path,
+    config,
+    root: config.build?.root ?? "decks",
+    outDir: config.build?.outDir ?? "src/generated",
+    ogpCacheFile: config.build?.ogpCacheFile
+  };
+}
+function resolveRuntimeEntry() {
+  const built = fileURLToPath2(new URL("./mod.js", import.meta.url));
+  if (existsSync3(built)) return built;
+  return fileURLToPath2(new URL("../mod.ts", import.meta.url));
+}
+
+// src/vite.ts
+function honoDecks(options = {}) {
+  let projectRoot = process.cwd();
+  let configPath = resolve2(projectRoot, options.configFile ?? DEFAULT_DECKS_CONFIG_FILE);
+  let deckRoot = resolve2(projectRoot, "decks");
+  let resolvedConfig;
+  let server;
+  let watchedPaths = /* @__PURE__ */ new Set();
+  let timer;
+  let compiling = false;
+  let queued = false;
+  const syncWatchedPaths = async () => {
+    if (!server) return;
+    const next = /* @__PURE__ */ new Set([deckRoot, configPath]);
+    const removed = [...watchedPaths].filter((path) => !next.has(path));
+    if (removed.length > 0) await server.watcher.unwatch(removed);
+    server.watcher.add([...next]);
+    watchedPaths = next;
+  };
+  const compileOnce = async () => {
+    const loaded = await loadDecksConfig({ cwd: projectRoot, configFile: options.configFile });
+    const manifest = await compileDecks({
+      cwd: projectRoot,
+      root: loaded.root,
+      out: loaded.outDir,
+      mountPath: loaded.config.mountPath,
+      ogpCacheFile: loaded.ogpCacheFile,
+      refreshOgp: options.refreshOgp
+    });
+    configPath = loaded.path;
+    deckRoot = resolve2(projectRoot, loaded.root);
+    await syncWatchedPaths();
+    resolvedConfig?.logger.info(`[hono-decks] Compiled ${manifest.decks.length} decks to ${loaded.outDir}`);
+  };
+  const compile2 = async (fatal) => {
+    if (compiling) {
+      queued = true;
+      return;
+    }
+    compiling = true;
+    let latestCompileSucceeded = false;
+    try {
+      do {
+        queued = false;
+        try {
+          await compileOnce();
+          latestCompileSucceeded = true;
+        } catch (error) {
+          latestCompileSucceeded = false;
+          if (fatal) throw error;
+          resolvedConfig?.logger.error(`[hono-decks] ${error instanceof Error ? error.message : String(error)}`);
+        }
+      } while (queued);
+      if (latestCompileSucceeded && server) server.ws.send({ type: "full-reload" });
+    } finally {
+      compiling = false;
+    }
+  };
+  const scheduleCompile = () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => void compile2(false), 75);
+  };
+  const onWatcherEvent = (event, path) => {
+    if (event !== "add" && event !== "change" && event !== "unlink") return;
+    const absolutePath = resolve2(projectRoot, path);
+    if (absolutePath === configPath || isWithin(deckRoot, absolutePath)) scheduleCompile();
+  };
+  return {
+    name: "hono-decks",
+    enforce: "pre",
+    async configResolved(config) {
+      resolvedConfig = config;
+      projectRoot = config.root;
+      configPath = resolve2(projectRoot, options.configFile ?? DEFAULT_DECKS_CONFIG_FILE);
+      await compile2(true);
+    },
+    configureServer(devServer) {
+      server = devServer;
+      void syncWatchedPaths();
+      devServer.watcher.on("all", onWatcherEvent);
+      const cleanup = () => {
+        if (timer) clearTimeout(timer);
+        devServer.watcher.off("all", onWatcherEvent);
+        server = void 0;
+        watchedPaths.clear();
+      };
+      devServer.httpServer?.once("close", cleanup);
+    }
+  };
+}
+function isWithin(root, path) {
+  const child = relative3(root, path);
+  return child === "" || child !== ".." && !child.startsWith("../") && !child.startsWith("..\\");
+}
+export {
+  honoDecks
+};