hono-decks 0.2.0 → 0.2.2

package/dist/client.d.ts

@@ -1,12 +1,18 @@
-import { S as SlideComponent } from './jsx-renderer-BO-N4tMZ.js';
-import 'hono/jsx';
-import 'hono/utils/html';
-
+import { Child } from "hono/jsx";
+import { HtmlEscapedString } from "hono/utils/html";
+//#region src/renderer/jsx-renderer.d.ts
+type DeckRenderable = Child | HtmlEscapedString;
+type SlideComponentProps = Record<string, unknown> & {
+  children?: DeckRenderable;
+};
+type SlideComponent = (props: SlideComponentProps) => DeckRenderable;
+//#endregion
+//#region src/client/islands.d.ts
 type ClientSlideComponentRegistry = Record<string, SlideComponent>;
 interface HydrateSlideIslandsInput {
-    root?: ParentNode;
-    components: ClientSlideComponentRegistry;
+  root?: ParentNode;
+  components: ClientSlideComponentRegistry;
 }
 declare function hydrateSlideIslands(input: HydrateSlideIslandsInput): void;
-
-export { type ClientSlideComponentRegistry, type HydrateSlideIslandsInput, hydrateSlideIslands };
+//#endregion
+export { type ClientSlideComponentRegistry, type HydrateSlideIslandsInput, hydrateSlideIslands };

package/dist/client.js

@@ -1,22 +1,19 @@
-// src/client/islands.ts
 import { render } from "hono/jsx/dom";
 import { jsx } from "hono/jsx/dom/jsx-runtime";
+//#region src/client/islands.ts
 function hydrateSlideIslands(input) {
-  const root = input.root ?? document;
-  const islands = root.querySelectorAll("[data-hono-decks-island]");
-  for (const island of islands) {
-    const name = island.dataset.honoDecksIsland;
-    if (!name) continue;
-    const component = input.components[name];
-    if (!component) continue;
-    const props = parseIslandProps(island.dataset.honoDecksProps);
-    render(jsx(component, props), island);
-  }
+	const islands = (input.root ?? document).querySelectorAll("[data-hono-decks-island]");
+	for (const island of islands) {
+		const name = island.dataset.honoDecksIsland;
+		if (!name) continue;
+		const component = input.components[name];
+		if (!component) continue;
+		render(jsx(component, parseIslandProps(island.dataset.honoDecksProps)), island);
+	}
 }
 function parseIslandProps(value) {
-  if (!value) return {};
-  return JSON.parse(value);
+	if (!value) return {};
+	return JSON.parse(value);
 }
-export {
-  hydrateSlideIslands
-};
+//#endregion
+export { hydrateSlideIslands };

package/dist/mod.d.ts

@@ -1,39 +1,524 @@
-import { C as CompiledDeck, A as AssetRef, b as DeckSource } from './define-decks-U4NxIs66.js';
-export { c as CompileWarning, a as CompiledSlide, d as ComponentPlaceholder, e as ConfiguredDecks, f as DeckBrowserRunBinding, g as DeckBrowserRunPdfOptions, h as DeckBrowserRunPngOptions, j as DeckContextVariables, k as DeckControlIconName, l as DeckDevResolver, m as DeckDevResolverInput, n as DeckDocumentOptions, o as DeckDocumentPageOptions, p as DeckDocumentRenderInput, q as DeckDocumentSurface, r as DeckEntry, s as DeckExportOptions, t as DeckExportResolverInput, u as DeckExternalEmbedContext, v as DeckExternalEmbedOptions, w as DeckExternalEmbedRenderInput, x as DeckExternalEmbedViewerOptions, y as DeckFrontmatter, z as DeckIndexPageInput, B as DeckIndexPageOptions, E as DeckIndexRenderInput, F as DeckKind, D as DeckManifest, G as DeckPageMeta, H as DeckPaths, I as DeckPresenterEnabledInput, J as DeckPresenterEnabledResolver, K as DeckPresenterViewerControlOptions, L as DeckRequestContext, M as DeckRouteEnabled, N as DeckRouteEnabledResolver, O as DeckRouteSurface, P as DeckRouteSurfaceInput, Q as DeckTocItem, S as DeckViewerAvailablePages, T as DeckViewerControlDefaults, U as DeckViewerControlItem, V as DeckViewerControlItemRenderer, W as DeckViewerControlKey, X as DeckViewerControlRenderInput, Y as DeckViewerControlSlotItems, Z as DeckViewerControlsContext, _ as DeckViewerControlsItemsResolver, $ as DeckViewerControlsOptions, a0 as DeckViewerDefaultControlItem, a1 as DeckViewerEmbed, a2 as DeckViewerEmbedOptions, a3 as DeckViewerExportPaths, a4 as DeckViewerLinkControlItem, a5 as DeckViewerOptions, a6 as DeckViewerPart, a7 as DeckViewerParts, a8 as DeckViewerRenderControlItem, a9 as DeckViewerRenderInput, aa as DecksBuildConfig, ab as DecksConfig, ad as DecksRouterConfig, ae as DecksRouterExtension, af as DecksRouterOptions, ah as DecksRouterPagesOptions, ai as DecksRouterPresenterOptions, R as ResolvedDeckDocument, ak as SLIDE_TRANSITIONS, al as SlideFrontmatter, am as SlideTransition, ap as createDeckPaths, aq as createDeckViewerEmbed, av as defineDecksConfig } from './define-decks-U4NxIs66.js';
-import { Env, Context } from 'hono';
-export { D as DeckRenderable, M as MaybePromise, S as SlideComponent, c as SlideComponentDefinition, b as SlideComponentInput, d as SlideComponentProps, a as SlideComponentRegistry, f as defineSlideComponents } from './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
+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;
+};
+//#endregion
+//#region src/renderer/jsx-renderer.d.ts
+type MaybePromise<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>;
+declare function defineSlideComponents(input: Record<string, SlideComponentInput>): SlideComponentRegistry;
+//#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<string | undefined>);
+  nonce?: string | ((input: DeckDocumentRenderInput<E>) => MaybePromise<string | undefined>);
+  head?: MaybePromise<DeckRenderable> | ((input: DeckDocumentRenderInput<E>) => MaybePromise<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<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;
+}
+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[];
+}
+//#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;
+}
+/** Creates the canonical route map used by routers, controls, and app code. */
+declare function createDeckPaths(mountPath: string, slug: string): DeckPaths;
+//#endregion
+//#region src/server/browser-export.d.ts
+interface DeckBrowserRunBinding {
+  quickAction(action: "pdf" | "screenshot", input: Record<string, unknown>): MaybePromise<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<DeckBrowserRunBinding | null | undefined>;
+  authorize?(input: DeckExportResolverInput<E>): MaybePromise<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<DeckRenderable> | ((input: DeckViewerRenderInput<E>) => MaybePromise<DeckRenderable>);
+  lang?: string | ((input: DeckViewerRenderInput<E>) => MaybePromise<string>);
+  nonce?: string | ((input: DeckViewerRenderInput<E>) => MaybePromise<string | undefined>);
+  render?(input: DeckViewerRenderInput<E>): MaybePromise<DeckRenderable>;
+}
+interface DeckViewerOpenGraphOptions {
+  /** Public image URL. Defaults to `paths.ogImage` when Open Graph metadata is enabled. */
+  imagePath?: string | ((input: DeckViewerOpenGraphInput) => MaybePromise<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;
+}
+declare function createDeckViewerEmbed(input: DeckViewerEmbedOptions): Promise<DeckViewerEmbed>;
+//#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<boolean>);
+  frameAncestors?: string | string[] | ((input: DeckExternalEmbedContext<E>) => MaybePromise<string | string[] | undefined>);
+  document?: DeckDocumentPageOptions<E>;
+  viewer?: DeckExternalEmbedViewerOptions | ((input: DeckExternalEmbedContext<E>) => MaybePromise<DeckExternalEmbedViewerOptions>);
+  pageStyle?: string;
+  robots?: string | false;
+  render?(input: DeckExternalEmbedRenderInput<E>): MaybePromise<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<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<string>);
+  render?(input: DeckIndexRenderInput<E>): MaybePromise<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<boolean>;
+interface DecksRouterPresenterOptions<E extends Env = any> {
+  enabled?: boolean | DeckPresenterEnabledResolver<E>;
+  viewerControl?: boolean | DeckPresenterViewerControlOptions;
+}
+type DeckPresenterEnabledResolver<E extends Env = any> = (input: DeckPresenterEnabledInput<E>) => MaybePromise<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";
+}
+interface DeckContextVariables {
+  deck: CompiledDeck;
+  deckViewer: DeckViewerParts;
+  deckToc: DeckTocItem[];
+  deckMeta: DeckPageMeta;
+}
+//#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>;
+}
+/** A generated deck collection configured for one application. */
+interface ConfiguredDecks<E extends Env = any> {
+  mountPath: string;
+  source: DeckSource<E>;
+  router(overrides?: DecksRouterConfig<E>): Hono<E>;
+  context(overrides?: Pick<DecksRouterOptions<E>, "dev" | "pages" | "viewer">): MiddlewareHandler<E & {
+    Variables: DeckContextVariables;
+  }>;
+  paths(slug: string): DeckPaths;
+}
+/** Defines the single configuration consumed by the CLI and runtime. */
+declare function defineDecksConfig<E extends Env = any>(config: DecksConfig<E>): DecksConfig<E>;
+//#endregion
+//#region src/source/r2-assets.d.ts
 interface R2ObjectHttpMetadataLike {
-    contentType?: string;
-    cacheControl?: string;
-    contentDisposition?: string;
-    contentEncoding?: string;
-    contentLanguage?: string;
+  contentType?: string;
+  cacheControl?: string;
+  contentDisposition?: string;
+  contentEncoding?: string;
+  contentLanguage?: string;
 }
 interface R2ObjectBodyLike {
-    body?: BodyInit | null;
-    httpMetadata?: R2ObjectHttpMetadataLike;
-    arrayBuffer?(): Promise<ArrayBuffer>;
-    writeHttpMetadata?(headers: Headers): void;
+  body?: BodyInit | null;
+  httpMetadata?: R2ObjectHttpMetadataLike;
+  arrayBuffer?(): Promise<ArrayBuffer>;
+  writeHttpMetadata?(headers: Headers): void;
 }
 interface R2BucketLike {
-    get(key: string): Promise<R2ObjectBodyLike | null>;
+  get(key: string): Promise<R2ObjectBodyLike | null>;
 }
 type R2BucketResolver<E extends Env = any> = R2BucketLike | (<RequestEnv extends E>(c: Context<RequestEnv>) => R2BucketLike | undefined | Promise<R2BucketLike | undefined>);
 interface R2AssetKeyInput {
-    deck: CompiledDeck;
-    asset: AssetRef;
-    slug: string;
-    assetPath: string;
+  deck: CompiledDeck;
+  asset: AssetRef;
+  slug: string;
+  assetPath: string;
 }
 interface R2AssetSourceOptions<E extends Env = any> {
-    bucket: R2BucketResolver<E>;
-    keyPrefix?: string;
-    key?(input: R2AssetKeyInput): string;
-    cacheControl?: string | false | ((input: R2AssetKeyInput) => string | false | undefined);
+  bucket: R2BucketResolver<E>;
+  keyPrefix?: string;
+  key?(input: R2AssetKeyInput): string;
+  cacheControl?: string | false | ((input: R2AssetKeyInput) => string | false | undefined);
 }
 declare function withR2Assets<E extends Env = any>(source: DeckSource<E>, options: R2AssetSourceOptions<E>): DeckSource<E>;
-
-export { AssetRef, CompiledDeck, DeckSource, type R2AssetKeyInput, type R2AssetSourceOptions, type R2BucketLike, type R2BucketResolver, type R2ObjectBodyLike, type R2ObjectHttpMetadataLike, withR2Assets };
+//#endregion
+export { type AssetRef, type CompileWarning, type CompiledDeck, type CompiledSlide, type ComponentPlaceholder, type ConfiguredDecks, type DeckBrowserRunBinding, type DeckBrowserRunPdfOptions, type DeckBrowserRunPngOptions, type DeckContextVariables, type DeckControlIconName, type DeckDevResolver, type DeckDevResolverInput, type DeckDocumentOptions, type DeckDocumentPageOptions, type DeckDocumentRenderInput, type DeckDocumentSurface, type DeckEntry, type DeckExportOptions, type DeckExportResolverInput, type DeckExternalEmbedContext, type DeckExternalEmbedOptions, type DeckExternalEmbedRenderInput, type DeckExternalEmbedViewerOptions, type DeckFrontmatter, type DeckIndexPageInput, type DeckIndexPageOptions, type DeckIndexRenderInput, type DeckKind, type DeckManifest, type DeckPageMeta, type DeckPaths, type DeckPresenterEnabledInput, type DeckPresenterEnabledResolver, type DeckPresenterViewerControlOptions, type DeckRenderable, type DeckRequestContext, type DeckRouteEnabled, type DeckRouteEnabledResolver, type DeckRouteSurface, type DeckRouteSurfaceInput, type DeckSource, type DeckTocItem, type DeckViewerAvailablePages, type DeckViewerControlDefaults, type DeckViewerControlItem, type DeckViewerControlItemRenderer, type DeckViewerControlKey, type DeckViewerControlRenderInput, type DeckViewerControlSlotItems, type DeckViewerControlsContext, type DeckViewerControlsItemsResolver, type DeckViewerControlsOptions, type DeckViewerDefaultControlItem, type DeckViewerEmbed, type DeckViewerEmbedOptions, type DeckViewerExportPaths, type DeckViewerLinkControlItem, type DeckViewerOptions, type DeckViewerPart, type DeckViewerParts, type DeckViewerRenderControlItem, type DeckViewerRenderInput, type DecksBuildConfig, type DecksConfig, type DecksRouterConfig, type DecksRouterExtension, type DecksRouterOptions, type DecksRouterPagesOptions, type DecksRouterPresenterOptions, type MaybePromise, type R2AssetKeyInput, type R2AssetSourceOptions, type R2BucketLike, type R2BucketResolver, type R2ObjectBodyLike, type R2ObjectHttpMetadataLike, type ResolvedDeckDocument, SLIDE_TRANSITIONS, type SlideComponent, type SlideComponentDefinition, type SlideComponentInput, type SlideComponentProps, type SlideComponentRegistry, type SlideFrontmatter, type SlideTransition, createDeckPaths, createDeckViewerEmbed, defineDecksConfig, defineSlideComponents, withR2Assets };