hono-decks 0.2.0 → 0.2.2

package/dist/node.d.ts

@@ -1,181 +1,740 @@
-import { F as DeckKind, D as DeckManifest, az as LocalDeckIO, ab as DecksConfig, aA as SlideDeck, aB as Slide, aC as CompileDeckInput, C as CompiledDeck, b as DeckSource, aD as DeckFileChange, aE as DeckCompiler } from './define-decks-U4NxIs66.js';
-export { A as AssetRef, aF as CompileError, c as CompileWarning, a as CompiledSlide, d as ComponentPlaceholder, r as DeckEntry, aG as DeckFileEntry, y as DeckFrontmatter, L as DeckRequestContext, aH as RenderError, aI as SlideBlock, al as SlideFrontmatter, aJ as SlideNode, aK as SlidePropValue } from './define-decks-U4NxIs66.js';
-import { Hono, Env, Context, MiddlewareHandler } from 'hono';
-import './jsx-renderer-BO-N4tMZ.js';
-import 'hono/jsx';
-import 'hono/utils/html';
-
+import { Context, Env, Hono, MiddlewareHandler } from "hono";
+import { HtmlEscapedString } from "hono/utils/html";
+import { Child } from "hono/jsx";
+//#region src/shared/types.d.ts
+interface SlideDeck {
+  slides: Slide[];
+  warnings: string[];
+}
+interface Slide {
+  index: number;
+  title?: string;
+  layout: string;
+  className?: string;
+  blocks: SlideBlock[];
+  nodes: SlideNode[];
+  raw: string;
+}
+type SlideNode = {
+  type: "text";
+  value: string;
+} | {
+  type: "element";
+  tag: string;
+  props: Record<string, unknown>;
+  children: SlideNode[];
+} | {
+  type: "code";
+  lang?: string;
+  value: string;
+} | {
+  type: "component";
+  name: string;
+  props: Record<string, unknown>;
+  children: SlideNode[];
+  source?: string;
+};
+type SlidePropValue = string | number | boolean;
+type TableAlign = "left" | "center" | "right" | undefined;
+type SlideBlock = {
+  type: "heading";
+  depth: 1 | 2 | 3;
+  text: string;
+} | {
+  type: "paragraph";
+  text: string;
+} | {
+  type: "list";
+  ordered: boolean;
+  items: string[];
+} | {
+  type: "code";
+  lang?: string;
+  code: string;
+} | {
+  type: "blockquote";
+  text: string;
+} | {
+  type: "image";
+  alt: string;
+  src: string;
+  title?: string;
+} | {
+  type: "component";
+  name: string;
+  props: Record<string, SlidePropValue>;
+  raw: string;
+} | {
+  type: "table";
+  align: TableAlign[];
+  header: string[];
+  rows: string[][];
+};
+//#endregion
+//#region src/renderer/jsx-renderer.d.ts
+type MaybePromise$1<T> = T | Promise<T>;
+type DeckRenderable = Child | HtmlEscapedString;
+type SlideComponentProps = Record<string, unknown> & {
+  children?: DeckRenderable;
+};
+type SlideComponent = (props: SlideComponentProps) => DeckRenderable;
+interface SlideComponentDefinition {
+  component: SlideComponent;
+  client?: boolean;
+  clientId?: string;
+}
+type SlideComponentInput = SlideComponent | SlideComponentDefinition;
+type SlideComponentRegistry = Record<string, SlideComponentDefinition>;
+//#endregion
+//#region src/server/document.d.ts
+type DeckDocumentSurface = "index" | "viewer" | "render" | "print" | "presentation" | "presenter" | "embed";
+interface DeckDocumentRenderInput<E extends Env = any> {
+  c: Context<E>;
+  surface: DeckDocumentSurface;
+  deck?: CompiledDeck;
+  slug?: string;
+  mountPath: string;
+  title: string;
+}
+interface DeckDocumentPageOptions<E extends Env = any> {
+  lang?: string | ((input: DeckDocumentRenderInput<E>) => MaybePromise$1<string | undefined>);
+  nonce?: string | ((input: DeckDocumentRenderInput<E>) => MaybePromise$1<string | undefined>);
+  head?: MaybePromise$1<DeckRenderable> | ((input: DeckDocumentRenderInput<E>) => MaybePromise$1<DeckRenderable>);
+}
+interface DeckDocumentOptions<E extends Env = any> extends DeckDocumentPageOptions<E> {
+  surfaces?: Partial<Record<DeckDocumentSurface, DeckDocumentPageOptions<E>>>;
+}
+interface ResolvedDeckDocument {
+  lang: string;
+  nonce?: string;
+  head: string;
+}
+//#endregion
+//#region src/deck/model.d.ts
+type DeckKind = "directory" | "single-file";
+declare const SLIDE_TRANSITIONS: readonly ["none", "fade", "fade-out", "slide-left", "slide-right", "slide-up", "slide-down", "view-transition"];
+type SlideTransition = (typeof SLIDE_TRANSITIONS)[number];
+interface DeckFrontmatter {
+  title?: string;
+  description?: string;
+  author?: string;
+  tags?: string[];
+  date?: string;
+  theme?: string;
+  transition?: SlideTransition;
+  transitionDuration?: string;
+  transitionEasing?: string;
+  draft?: boolean;
+  assets?: string | string[];
+  presenter?: boolean;
+  meta: Record<string, unknown>;
+}
+interface SlideFrontmatter {
+  title?: string;
+  layout?: string;
+  className?: string;
+  notes?: string;
+  background?: string;
+  transition?: SlideTransition;
+  transitionDuration?: string;
+  transitionEasing?: string;
+  meta: Record<string, unknown>;
+}
+interface ComponentPlaceholder {
+  id: string;
+  name: string;
+  props: Record<string, unknown>;
+  source: string;
+}
+interface AssetRef {
+  sourcePath: string;
+  publicPath: string;
+  type: "local" | "remote" | "r2" | "public";
+  contentType?: string;
+  cacheControl?: string | false;
+  r2Key?: string;
+  body?: BodyInit;
+}
+interface CompileWarning {
+  code: string;
+  message: string;
+  slideIndex?: number;
+}
+interface CompiledSlide {
+  index: number;
+  meta: SlideFrontmatter;
+  html: string;
+  nodes?: SlideNode[];
+  render?: (props?: {
+    components?: Record<string, unknown>;
+  }) => MaybePromise$1<DeckRenderable>;
+  components: ComponentPlaceholder[];
+  notes?: string;
+}
+interface CompiledDeck {
+  slug: string;
+  sourcePath: string;
+  kind: DeckKind;
+  meta: DeckFrontmatter;
+  themeStyle?: string;
+  themeSourcePath?: string;
+  slides: CompiledSlide[];
+  assets: AssetRef[];
+  componentRegistry?: Record<string, SlideComponentInput>;
+  warnings: CompileWarning[];
+}
+interface DeckEntry {
+  slug: string;
+  title?: string;
+  description?: string;
+  draft?: boolean;
+  sourcePath: string;
+}
+interface DeckFileEntry {
+  slug: string;
+  sourcePath: string;
+  kind: DeckKind;
+}
+interface DeckFileChange {
+  type: "created" | "changed" | "deleted";
+  path: string;
+  slug?: string;
+}
+interface LocalDeckIO {
+  listFiles(): Promise<DeckFileEntry[]>;
+  readMarkdown(slug: string): Promise<string | null>;
+  readAsset?(path: string): Promise<BodyInit | Uint8Array | null>;
+  watch?(onFileChange: (event: DeckFileChange) => void): () => void;
+}
+type DeckRequestContext<E extends Env = any> = Context<E>;
+interface DeckSource<E extends Env = any> {
+  listDecks<RequestEnv extends E>(c: Context<RequestEnv>): Promise<DeckEntry[]>;
+  getCompiledDeck<RequestEnv extends E>(c: Context<RequestEnv>, slug: string): Promise<CompiledDeck | null>;
+  getAsset?<RequestEnv extends E>(c: Context<RequestEnv>, slug: string, assetPath: string): Promise<Response | null>;
+}
+interface DeckManifest {
+  decks: CompiledDeck[];
+}
+interface CompileDeckInput {
+  slug: string;
+  sourcePath: string;
+  kind: DeckKind;
+  markdown: string;
+}
+interface DeckCompiler {
+  compileMarkdown(input: CompileDeckInput): Promise<CompiledDeck>;
+}
+declare class CompileError extends Error {
+  readonly code: string;
+  constructor(message: string, code: string);
+}
+declare class RenderError extends Error {
+  readonly code: string;
+  readonly cause?: unknown;
+  constructor(message: string, code: string, cause?: unknown);
+}
+//#endregion
+//#region src/routing/file-routing.d.ts
 interface ResolvedDeckFile {
-    slug: string;
-    sourcePath: string;
-    kind: DeckKind;
-    assetPaths: string[];
+  slug: string;
+  sourcePath: string;
+  kind: DeckKind;
+  assetPaths: string[];
 }
 declare function resolveDeckFiles(paths: string[], root?: string): ResolvedDeckFile[];
-
+//#endregion
+//#region src/generator/mdx/ogp.d.ts
 interface LinkCardOgpMetadata {
-    title?: string;
-    description?: string;
-    image?: string;
-    siteName?: string;
+  title?: string;
+  description?: string;
+  image?: string;
+  siteName?: string;
 }
-
+//#endregion
+//#region src/generator/component-registry.d.ts
 interface DeckComponentExport {
-    slug: string;
-    sourcePath: string;
-    modulePath: string;
-    exportName: string;
+  slug: string;
+  sourcePath: string;
+  modulePath: string;
+  exportName: string;
 }
 interface ResolvedDeckComponentExport extends DeckComponentExport {
-    internalName: string;
+  internalName: string;
 }
 interface ApplyDeckComponentRegistryInput {
-    manifest: DeckManifest;
-    components: DeckComponentExport[];
+  manifest: DeckManifest;
+  components: DeckComponentExport[];
 }
 interface ApplyDeckComponentRegistryResult {
-    manifest: DeckManifest;
-    components: ResolvedDeckComponentExport[];
+  manifest: DeckManifest;
+  components: ResolvedDeckComponentExport[];
 }
 declare function applyDeckComponentRegistry(input: ApplyDeckComponentRegistryInput): ApplyDeckComponentRegistryResult;
 declare function emitDeckComponentRegistryModule(components: ResolvedDeckComponentExport[]): string;
-
+//#endregion
+//#region src/node/compile-decks.d.ts
 interface BuildDeckManifestFromFileSystemInput {
-    cwd: string;
-    root: string;
-    mountPath?: string;
+  cwd: string;
+  root: string;
+  mountPath?: string;
 }
 interface WriteDeckManifestModuleInput {
-    manifest: DeckManifest;
-    outFile: string;
+  manifest: DeckManifest;
+  outFile: string;
 }
 interface WriteDeckComponentRegistryModuleInput {
-    components: ResolvedDeckComponentExport[];
-    outFile: string;
+  components: ResolvedDeckComponentExport[];
+  outFile: string;
 }
 interface WriteDecksRouterModuleInput {
-    manifestModulePath: string;
-    componentRegistryModulePath?: string;
-    outFile: string;
+  manifestModulePath: string;
+  componentRegistryModulePath?: string;
+  outFile: string;
 }
 interface CompileDecksInput extends BuildDeckManifestFromFileSystemInput {
-    out: string;
-    ogpCacheFile?: string;
-    refreshOgp?: boolean;
-    resolveOgp?(url: string): Promise<LinkCardOgpMetadata | undefined>;
+  out: string;
+  ogpCacheFile?: string;
+  refreshOgp?: boolean;
+  resolveOgp?(url: string): Promise<LinkCardOgpMetadata | undefined>;
 }
 declare function compileDecks(input: CompileDecksInput): Promise<DeckManifest>;
 declare function buildDeckManifestFromFileSystem(input: BuildDeckManifestFromFileSystemInput): Promise<DeckManifest>;
 declare function writeDeckManifestModule(input: WriteDeckManifestModuleInput): Promise<void>;
 declare function writeDeckComponentRegistryModule(input: WriteDeckComponentRegistryModuleInput): Promise<void>;
 declare function writeDecksRouterModule(input: WriteDecksRouterModuleInput): Promise<void>;
-
+//#endregion
+//#region src/node/local-deck-io.d.ts
 interface CreateLocalDeckIOInput {
-    cwd: string;
-    root: string;
-    pathExists?(path: string): boolean;
-    watchFileSystem?(path: string, options: {
-        recursive: boolean;
-    }, listener: (eventType: "rename" | "change", filename: string | null) => void): {
-        close(): void;
-    };
+  cwd: string;
+  root: string;
+  pathExists?(path: string): boolean;
+  watchFileSystem?(path: string, options: {
+    recursive: boolean;
+  }, listener: (eventType: "rename" | "change", filename: string | null) => void): {
+    close(): void;
+  };
 }
 declare function createLocalDeckIO(input: CreateLocalDeckIOInput): LocalDeckIO;
-
+//#endregion
+//#region src/node/local-dev-app.d.ts
 interface CreateLocalDevSlidesAppInput {
-    cwd: string;
-    root: string;
-    mountPath?: string;
-    watchFileSystem?: CreateLocalDeckIOInput["watchFileSystem"];
+  cwd: string;
+  root: string;
+  mountPath?: string;
+  watchFileSystem?: CreateLocalDeckIOInput["watchFileSystem"];
 }
 interface LocalDevSlidesApp {
-    app: Hono;
-    localDeckIO: LocalDeckIO;
-    stop(): void;
+  app: Hono;
+  localDeckIO: LocalDeckIO;
+  stop(): void;
 }
 declare function createLocalDevSlidesApp(input: CreateLocalDevSlidesAppInput): Promise<LocalDevSlidesApp>;
-
+//#endregion
+//#region src/renderer/control-icons.d.ts
+type DeckControlIconName = "deck-list" | "home" | "viewer" | "projection" | "presenter" | "previous" | "next" | "fullscreen" | "print" | "details" | "export-pdf" | "export-png";
+//#endregion
+//#region src/server/paths.d.ts
+/** All public URLs for one deck. */
+interface DeckPaths {
+  viewer: string;
+  render: string;
+  print: string;
+  presentation: string;
+  presenter: string;
+  embed: string;
+  exportPdf: string;
+  exportPng: string;
+  ogImage: string;
+  assets: string;
+}
+//#endregion
+//#region src/server/browser-export.d.ts
+interface DeckBrowserRunBinding {
+  quickAction(action: "pdf" | "screenshot", input: Record<string, unknown>): MaybePromise$1<Response>;
+}
+interface DeckBrowserRunPdfOptions {
+  filename?: string | ((deck: CompiledDeck) => string);
+  request?: Record<string, unknown>;
+}
+interface DeckBrowserRunPngOptions {
+  filename?: string | ((deck: CompiledDeck) => string);
+  request?: Record<string, unknown>;
+}
+/** Request data passed to Browser Rendering binding and authorization resolvers. */
+interface DeckExportResolverInput<E extends Env = any> {
+  c: Context<E>;
+  deck: CompiledDeck;
+  slug: string;
+  mountPath: string;
+  paths: DeckPaths;
+  format: "pdf" | "png";
+}
+interface DeckExportOptions<E extends Env = any> {
+  browser(input: DeckExportResolverInput<E>): MaybePromise$1<DeckBrowserRunBinding | null | undefined>;
+  authorize?(input: DeckExportResolverInput<E>): MaybePromise$1<boolean>;
+  pdf?: boolean | DeckBrowserRunPdfOptions;
+  png?: boolean | DeckBrowserRunPngOptions;
+}
+interface DeckViewerExportPaths {
+  pdf?: boolean;
+  png?: boolean;
+}
+//#endregion
+//#region src/server/viewer.d.ts
+interface DeckViewerOptions<E extends Env = any> {
+  controls?: false | DeckViewerControlsOptions;
+  openGraph?: boolean | DeckViewerOpenGraphOptions;
+  style?: string;
+  head?: MaybePromise$1<DeckRenderable> | ((input: DeckViewerRenderInput<E>) => MaybePromise$1<DeckRenderable>);
+  lang?: string | ((input: DeckViewerRenderInput<E>) => MaybePromise$1<string>);
+  nonce?: string | ((input: DeckViewerRenderInput<E>) => MaybePromise$1<string | undefined>);
+  render?(input: DeckViewerRenderInput<E>): MaybePromise$1<DeckRenderable>;
+}
+interface DeckViewerOpenGraphOptions {
+  /** Public image URL. Defaults to `paths.ogImage` when Open Graph metadata is enabled. */
+  imagePath?: string | ((input: DeckViewerOpenGraphInput) => MaybePromise$1<string | undefined>);
+}
+interface DeckViewerOpenGraphInput {
+  deck: CompiledDeck;
+  paths: DeckPaths;
+}
+type DeckViewerControlKey = "back" | "previous" | "position" | "next" | "fullscreen" | "print" | "exportPdf" | "exportPng";
+interface DeckViewerControlsOptions {
+  className?: string;
+  itemClassName?: string;
+  attributes?: Record<string, string | boolean | undefined>;
+  ariaLabel?: string;
+  hidden?: DeckViewerControlKey[];
+  labels?: Partial<Record<DeckViewerControlKey, string>>;
+  before?: DeckViewerControlSlotItems;
+  after?: DeckViewerControlSlotItems;
+  items?: DeckViewerControlItem[] | DeckViewerControlsItemsResolver;
+  renderItem?: DeckViewerControlItemRenderer;
+}
+type DeckViewerControlsItemsResolver = (defaults: DeckViewerControlDefaults, context: DeckViewerControlsContext) => DeckViewerControlItem[];
+type DeckViewerControlSlotItems = DeckViewerControlItem[] | ((context: DeckViewerControlsContext) => DeckViewerControlItem[]);
+interface DeckViewerControlRenderInput {
+  context: DeckViewerControlsContext;
+}
+type DeckViewerControlItemRenderer = (item: Exclude<DeckViewerControlItem, null | false | undefined>, context: DeckViewerControlsContext, renderDefault: () => DeckRenderable) => DeckRenderable;
+interface DeckViewerControlDefaults {
+  back: DeckViewerDefaultControlItem;
+  previous: DeckViewerDefaultControlItem;
+  position: DeckViewerDefaultControlItem;
+  next: DeckViewerDefaultControlItem;
+  fullscreen: DeckViewerDefaultControlItem;
+  print: DeckViewerDefaultControlItem | null;
+  exportPdf: DeckViewerDefaultControlItem | null;
+  exportPng: DeckViewerDefaultControlItem | null;
+}
+interface DeckViewerAvailablePages {
+  print: boolean;
+}
+interface DeckViewerControlsContext {
+  slug: string;
+  title: string;
+  mountPath: string;
+  meta: DeckPageMeta;
+  slides: DeckTocItem[];
+}
+type DeckViewerControlItem = DeckViewerDefaultControlItem | DeckViewerLinkControlItem | DeckViewerRenderControlItem | null | false | undefined;
+interface DeckViewerDefaultControlItem {
+  type: "default";
+  key: DeckViewerControlKey;
+  label?: string;
+  className?: string;
+  attributes?: Record<string, string | boolean | undefined>;
+}
+interface DeckViewerLinkControlItem {
+  type: "link";
+  key?: string;
+  href: string;
+  label: string;
+  icon?: DeckControlIconName;
+  download?: string;
+  className?: string;
+  attributes?: Record<string, string | boolean | undefined>;
+}
+interface DeckViewerRenderControlItem {
+  type: "render";
+  key?: string;
+  render(input: DeckViewerControlRenderInput): DeckRenderable;
+}
+interface DeckTocItem {
+  index: number;
+  title?: string;
+  label: string;
+}
+/** Metadata and complete public route map for a viewer page. */
+interface DeckPageMeta {
+  title: string;
+  description?: string;
+  paths: DeckPaths;
+  availablePages: DeckViewerAvailablePages;
+  availableExports: DeckViewerExportPaths;
+  imagePath?: string;
+}
+interface DeckViewerParts {
+  slug: string;
+  title: string;
+  renderUrl: string;
+  frame: DeckViewerPart;
+  controls: DeckViewerPart | null;
+  toc: DeckViewerPart;
+  slides: DeckTocItem[];
+  meta: DeckPageMeta;
+}
+/** One viewer part in both composable JSX form and pre-rendered HTML form. */
+interface DeckViewerPart {
+  content: DeckRenderable;
+  html: string;
+}
+interface DeckViewerRenderInput<E extends Env = any> extends DeckViewerParts {
+  c: Context<E>;
+  deck: CompiledDeck;
+  mountPath: string;
+}
+interface DeckViewerEmbedOptions {
+  deck: CompiledDeck;
+  mountPath: string;
+  viewerStateQuery?: string;
+  controls?: false | DeckViewerControlsOptions;
+  availablePages?: Partial<DeckViewerAvailablePages>;
+  exportPaths?: DeckViewerExportPaths;
+  style?: string;
+  toc?: boolean;
+  className?: string;
+  nonce?: string;
+}
+interface DeckViewerEmbed extends DeckViewerParts {
+  embed: DeckRenderable;
+  embedHtml: string;
+}
+//#endregion
+//#region src/server/external-embed.d.ts
+interface DeckExternalEmbedContext<E extends Env = any> {
+  c: Context<E>;
+  deck: CompiledDeck;
+  slug: string;
+  mountPath: string;
+}
+type DeckExternalEmbedViewerOptions = Omit<DeckViewerEmbedOptions, "deck" | "mountPath" | "nonce">;
+interface DeckExternalEmbedRenderInput<E extends Env = any> extends DeckExternalEmbedContext<E> {
+  viewer: DeckViewerEmbed;
+  document: ResolvedDeckDocument;
+}
+interface DeckExternalEmbedOptions<E extends Env = any> {
+  enabled?: boolean | ((input: DeckExternalEmbedContext<E>) => MaybePromise$1<boolean>);
+  frameAncestors?: string | string[] | ((input: DeckExternalEmbedContext<E>) => MaybePromise$1<string | string[] | undefined>);
+  document?: DeckDocumentPageOptions<E>;
+  viewer?: DeckExternalEmbedViewerOptions | ((input: DeckExternalEmbedContext<E>) => MaybePromise$1<DeckExternalEmbedViewerOptions>);
+  pageStyle?: string;
+  robots?: string | false;
+  render?(input: DeckExternalEmbedRenderInput<E>): MaybePromise$1<DeckRenderable>;
+}
+//#endregion
+//#region src/server/router.d.ts
+interface DecksRouterExtension<E extends Env = any> {
+  path: string;
+  router: Hono<E>;
+}
+interface DecksRouterOptions<E extends Env = any> {
+  source: DeckSource<E>;
+  /**
+   * Enables development-only deck behavior. When omitted, Vite and Wrangler
+   * development commands are detected from NODE_ENV. Explicit values and
+   * resolvers always take precedence.
+   */
+  dev?: boolean | DeckDevResolver<E>;
+  extensions?: DecksRouterExtension<E>[];
+  liveReloadPath?(slug: string, mountPath: string): string | undefined;
+  style?: string;
+  components?: SlideComponentRegistry | Record<string, SlideComponentInput>;
+  clientEntry?: string;
+  clientEntryAsset?: string;
+  clientEntryAssetPath?: string;
+  document?: DeckDocumentOptions<E>;
+  pages?: DecksRouterPagesOptions<E>;
+  embed?: false | DeckExternalEmbedOptions<E>;
+  viewer?: DeckViewerOptions<E>;
+  presenter?: false | DecksRouterPresenterOptions<E>;
+  export?: false | DeckExportOptions<E>;
+}
+type DeckRouteSurface = "index" | "viewer" | "render" | "print" | "presentation" | "presenter";
+interface DeckRouteSurfaceInput<E extends Env = any> {
+  c: Context<E>;
+  surface: DeckRouteSurface;
+  mountPath: string;
+  dev: boolean;
+  deck?: CompiledDeck;
+  slug?: string;
+}
+type DeckRouteEnabledResolver<E extends Env = any> = (input: DeckRouteSurfaceInput<E>) => MaybePromise$1<boolean>;
+type DeckRouteEnabled<E extends Env = any> = boolean | DeckRouteEnabledResolver<E>;
+interface DeckIndexPageInput<E extends Env = any> extends DeckRouteSurfaceInput<E> {
+  surface: "index";
+  decks: DeckEntry[];
+}
+interface DeckIndexRenderInput<E extends Env = any> extends DeckIndexPageInput<E> {
+  title: string;
+  document: ResolvedDeckDocument;
+  defaultContent: DeckRenderable;
+}
+interface DeckIndexPageOptions<E extends Env = any> {
+  enabled?: DeckRouteEnabled<E>;
+  title?: string | ((input: DeckIndexPageInput<E>) => MaybePromise$1<string>);
+  render?(input: DeckIndexRenderInput<E>): MaybePromise$1<DeckRenderable>;
+}
+interface DecksRouterPagesOptions<E extends Env = any> {
+  index?: false | DeckIndexPageOptions<E>;
+  viewer?: DeckRouteEnabled<E>;
+  render?: DeckRouteEnabled<E>;
+  print?: DeckRouteEnabled<E>;
+  presentation?: DeckRouteEnabled<E>;
+  presenter?: DeckRouteEnabled<E>;
+}
+/** Request data passed to the development-mode resolver. */
+interface DeckDevResolverInput<E extends Env = any> {
+  c: Context<E>;
+}
+type DeckDevResolver<E extends Env = any> = (input: DeckDevResolverInput<E>) => MaybePromise$1<boolean>;
+interface DecksRouterPresenterOptions<E extends Env = any> {
+  enabled?: boolean | DeckPresenterEnabledResolver<E>;
+  viewerControl?: boolean | DeckPresenterViewerControlOptions;
+}
+type DeckPresenterEnabledResolver<E extends Env = any> = (input: DeckPresenterEnabledInput<E>) => MaybePromise$1<boolean>;
+interface DeckPresenterEnabledInput<E extends Env = any> {
+  c: Context<E>;
+  deck: CompiledDeck;
+  slug: string;
+  mountPath: string;
+  dev: boolean;
+  presenterPath: string;
+  presentationPath: string;
+}
+interface DeckPresenterViewerControlOptions {
+  key?: string;
+  label?: string;
+  icon?: DeckControlIconName;
+  className?: string;
+  attributes?: Record<string, string | boolean | undefined>;
+  placement?: "before" | "after";
+}
+//#endregion
+//#region src/server/define-decks.d.ts
+/** Per-mount overrides merged on top of generated defaults and app config. */
+type DecksRouterOverrides<E extends Env = any> = Partial<Omit<DecksRouterOptions<E>, "components" | "clientEntryAsset">> & {
+  components?: SlideComponentRegistry | Record<string, SlideComponentInput>;
+};
+/** Runtime options that keep the configured kit on its single transformed source. */
+type DecksRouterConfig<E extends Env = any> = Omit<DecksRouterOverrides<E>, "source">;
+/** File-system settings consumed by the CLI. */
+interface DecksBuildConfig {
+  /** Deck source directory. @default "decks" */
+  root?: string;
+  /** Generated module directory. @default "src/generated" */
+  outDir?: string;
+  /** Optional deterministic Open Graph metadata cache. */
+  ogpCacheFile?: string;
+}
+/** Shared configuration consumed by both the CLI and the generated runtime kit. */
+interface DecksConfig<E extends Env = any> {
+  /** Public route where the configured router is mounted. */
+  mountPath: string;
+  build?: DecksBuildConfig;
+  source?(source: DeckSource<E>): DeckSource<E>;
+  router?: DecksRouterConfig<E>;
+}
+//#endregion
+//#region src/node/config.d.ts
 declare const DEFAULT_DECKS_CONFIG_FILE = "hono-decks.config.ts";
 interface LoadedDecksConfig<E extends Env = any> {
-    path: string;
-    config: DecksConfig<E>;
-    root: string;
-    outDir: string;
-    ogpCacheFile?: string;
+  path: string;
+  config: DecksConfig<E>;
+  root: string;
+  outDir: string;
+  ogpCacheFile?: string;
 }
 declare function loadDecksConfig<E extends Env = any>(input: {
-    cwd: string;
-    configFile?: string;
+  cwd: string;
+  configFile?: string;
 }): Promise<LoadedDecksConfig<E>>;
-
+//#endregion
+//#region src/server/middleware.d.ts
 declare module "hono" {
-    interface ContextVariableMap {
-        slideDeck: SlideDeck;
-        slideHtml: string;
-        slideMarkdown: string;
-    }
+  interface ContextVariableMap {
+    slideDeck: SlideDeck;
+    slideHtml: string;
+    slideMarkdown: string;
+  }
 }
 type MaybePromise<T> = T | Promise<T>;
 interface DeckMiddlewareOptions {
-    /** Static markdown, or a loader that can read from bindings/storage. */
-    markdown?: string | ((c: Context) => MaybePromise<string>);
-    /** When false, only parse/render and expose c.var.slideDeck / slideHtml, then call next(). */
-    respond?: boolean;
-    /** Page title used when respond=true. */
-    title?: string;
-    /** Extra CSS appended inside the generated deck page. */
-    style?: string;
+  /** Static markdown, or a loader that can read from bindings/storage. */
+  markdown?: string | ((c: Context) => MaybePromise<string>);
+  /** When false, only parse/render and expose c.var.slideDeck / slideHtml, then call next(). */
+  respond?: boolean;
+  /** Page title used when respond=true. */
+  title?: string;
+  /** Extra CSS appended inside the generated deck page. */
+  style?: string;
 }
 declare function deckMiddleware(options?: DeckMiddlewareOptions): MiddlewareHandler;
 declare function renderDeckPage(input: {
-    title: string;
-    slideHtml: string;
-    warnings?: string[];
-    style?: string;
+  title: string;
+  slideHtml: string;
+  warnings?: string[];
+  style?: string;
 }): string;
-
+//#endregion
+//#region src/parser/parser.d.ts
 declare function parseDeck(markdown: string): SlideDeck;
-
+//#endregion
+//#region src/renderer/render.d.ts
 declare function renderDeck(deck: SlideDeck): string;
 declare function renderSlide(slide: Slide): string;
-
+//#endregion
+//#region src/compiler/compiler.d.ts
 declare function compileMarkdown(input: CompileDeckInput): Promise<CompiledDeck>;
-
+//#endregion
+//#region src/runtime/preview-events.d.ts
 type PreviewEventType = "ready" | "deck:updated" | "deck:error";
 interface PreviewEvent {
-    type: PreviewEventType;
-    slug: string;
-    data?: unknown;
+  type: PreviewEventType;
+  slug: string;
+  data?: unknown;
 }
 interface PreviewEventHub {
-    publish(event: PreviewEvent): void;
-    drain(slug: string): PreviewEvent[];
-    subscribe?(slug: string, listener: (event: PreviewEvent) => void): () => void;
+  publish(event: PreviewEvent): void;
+  drain(slug: string): PreviewEvent[];
+  subscribe?(slug: string, listener: (event: PreviewEvent) => void): () => void;
 }
 declare function createPreviewEventHub(): PreviewEventHub;
-
+//#endregion
+//#region src/runtime/dev-runtime.d.ts
 interface DevDeckRuntimeInput {
-    initialDecks: CompiledDeck[];
-    localDeckIO: LocalDeckIO;
-    compiler: DeckCompiler;
-    previewEvents?: PreviewEventHub;
-    mountPath?: string;
+  initialDecks: CompiledDeck[];
+  localDeckIO: LocalDeckIO;
+  compiler: DeckCompiler;
+  previewEvents?: PreviewEventHub;
+  mountPath?: string;
 }
 interface DevDeckRuntime {
-    source: DeckSource;
-    handleFileChange(event: DeckFileChange): Promise<void>;
-    start(): () => void;
+  source: DeckSource;
+  handleFileChange(event: DeckFileChange): Promise<void>;
+  start(): () => void;
 }
 declare function createDevDeckRuntime(input: DevDeckRuntimeInput): DevDeckRuntime;
-
+//#endregion
+//#region src/generator/manifest-generator.d.ts
 interface BuildDeckManifestInput {
-    root: string;
-    paths: string[];
-    mountPath?: string;
-    readText(path: string): Promise<string>;
-    readBinary?(path: string): Promise<Uint8Array>;
+  root: string;
+  paths: string[];
+  mountPath?: string;
+  readText(path: string): Promise<string>;
+  readBinary?(path: string): Promise<Uint8Array>;
 }
 declare function buildDeckManifest(input: BuildDeckManifestInput): Promise<DeckManifest>;
 declare function emitDeckManifestModule(manifest: DeckManifest): string;
-
-export { type ApplyDeckComponentRegistryInput, type ApplyDeckComponentRegistryResult, type BuildDeckManifestFromFileSystemInput, type BuildDeckManifestInput, CompileDeckInput, type CompileDecksInput, CompiledDeck, type CreateLocalDeckIOInput, type CreateLocalDevSlidesAppInput, DEFAULT_DECKS_CONFIG_FILE, DeckCompiler, type DeckComponentExport, DeckFileChange, DeckManifest, type DeckMiddlewareOptions, DeckSource, type DevDeckRuntime, type DevDeckRuntimeInput, type LoadedDecksConfig, LocalDeckIO, type LocalDevSlidesApp, type PreviewEvent, type PreviewEventHub, type PreviewEventType, type ResolvedDeckComponentExport, type ResolvedDeckFile, Slide, SlideDeck, type WriteDeckComponentRegistryModuleInput, type WriteDeckManifestModuleInput, type WriteDecksRouterModuleInput, applyDeckComponentRegistry, buildDeckManifest, buildDeckManifestFromFileSystem, compileDecks, compileMarkdown, createDevDeckRuntime, createLocalDeckIO, createLocalDevSlidesApp, createPreviewEventHub, deckMiddleware, emitDeckComponentRegistryModule, emitDeckManifestModule, loadDecksConfig, parseDeck, renderDeck, renderDeckPage, renderSlide, resolveDeckFiles, writeDeckComponentRegistryModule, writeDeckManifestModule, writeDecksRouterModule };
+//#endregion
+export { type ApplyDeckComponentRegistryInput, type ApplyDeckComponentRegistryResult, type AssetRef, type BuildDeckManifestFromFileSystemInput, type BuildDeckManifestInput, type CompileDeckInput, type CompileDecksInput, CompileError, type CompileWarning, type CompiledDeck, type CompiledSlide, type ComponentPlaceholder, type CreateLocalDeckIOInput, type CreateLocalDevSlidesAppInput, DEFAULT_DECKS_CONFIG_FILE, type DeckCompiler, type DeckComponentExport, type DeckEntry, type DeckFileChange, type DeckFileEntry, type DeckFrontmatter, type DeckManifest, type DeckMiddlewareOptions, type DeckRequestContext, type DeckSource, type DevDeckRuntime, type DevDeckRuntimeInput, type LoadedDecksConfig, type LocalDeckIO, type LocalDevSlidesApp, type PreviewEvent, type PreviewEventHub, type PreviewEventType, RenderError, type ResolvedDeckComponentExport, type ResolvedDeckFile, type Slide, type SlideBlock, type SlideDeck, type SlideFrontmatter, type SlideNode, type SlidePropValue, type WriteDeckComponentRegistryModuleInput, type WriteDeckManifestModuleInput, type WriteDecksRouterModuleInput, applyDeckComponentRegistry, buildDeckManifest, buildDeckManifestFromFileSystem, compileDecks, compileMarkdown, createDevDeckRuntime, createLocalDeckIO, createLocalDevSlidesApp, createPreviewEventHub, deckMiddleware, emitDeckComponentRegistryModule, emitDeckManifestModule, loadDecksConfig, parseDeck, renderDeck, renderDeckPage, renderSlide, resolveDeckFiles, writeDeckComponentRegistryModule, writeDeckManifestModule, writeDecksRouterModule };