API reference

Defines the shared CLI and runtime configuration.

Use it whenKeeping mount path, build input, and runtime policy in one file.

import { defineDecksConfig } from "hono-decks"

defineDecksConfig(config: DecksConfig): DecksConfig

The application kit returned by generated createDecks(config).

Use it whenUsing routes, custom pages, and URLs from one config.

import type { ConfiguredDecks } from "hono-decks"

interface ConfiguredDecks { mountPath; source; router(); context(); paths(slug) }

Creates every public URL for one deck.

Use it whenCreating a path map outside a configured kit.

import { createDeckPaths } from "hono-decks"

createDeckPaths(mountPath, slug): DeckPaths

Builds a low-level router from a custom DeckSource.

Use it whenBuilding a custom pipeline without generated createDecks(config).

import { decksRouter } from "hono-decks/advanced"

decksRouter(options: DecksRouterOptions): Hono

Returns viewer parts independently.

Use it whenComposing a fully custom viewer layout.

import { createDeckViewerParts } from "hono-decks/advanced"

createDeckViewerParts(input): Promise<DeckViewerParts>

Creates an embedded viewer with scoped CSS and runtime behavior.

Use it whenEmbedding a viewer directly in a custom page. Use the router embed option for an external iframe route.

import { createDeckViewerEmbed } from "hono-decks"

createDeckViewerEmbed(input: DeckViewerEmbedOptions): Promise<DeckViewerEmbed>

Wraps generated assets with an R2-backed source.

Use it whenMoving generated asset delivery to Cloudflare R2 without changing relative MDX paths.

import { withR2Assets } from "hono-decks"

withR2Assets(source: DeckSource, options: R2AssetSourceOptions): DeckSource

Creates a typed registry for built-in and application components.

Use it whenRegistering shared components across decks or replacing built-ins. Keep deck-specific components under components/.

import { defineSlideComponents } from "hono-decks"

defineSlideComponents(input: Record<string, SlideComponentInput>): SlideComponentRegistry

Renders a compiled deck directly.

Use it whenBuilding a low-level custom rendering pipeline.

import { renderCompiledDeckAsync } from "hono-decks/advanced"

renderCompiledDeckAsync(deck: CompiledDeck, input?): Promise<string>

Configures the viewer's Open Graph and Twitter Card image from the canonical path or a resolver.

Use it whenConnecting a build-generated or CDN-hosted image to viewer social metadata.

import type { DeckViewerOpenGraphOptions } from "hono-decks"

interface DeckViewerOpenGraphOptions { imagePath?: string | (({ deck, paths }) => MaybePromise<string | undefined>) }

Configures index rendering and HTML route surfaces per request.

Use it whenDisabling unused public surfaces or gating them by authentication and environment.

import type { DecksRouterPagesOptions } from "hono-decks"

interface DecksRouterPagesOptions { index?; viewer?; render?; print?; presentation?; presenter? }

Passes Hono context, deck, mount path, and dev state into route gates.

Use it whenTyping a reusable pages resolver defined outside the router configuration.

import type { DeckRouteSurfaceInput } from "hono-decks"

interface DeckRouteSurfaceInput { c; surface; mountPath; dev; deck?; slug? }

Defines language, nonce, head content, and per-surface overrides.

Use it whenApplying lang, CSP nonce, or head elements to every generated HTML surface.

import type { DeckDocumentOptions } from "hono-decks"

interface DeckDocumentOptions extends DeckDocumentPageOptions { surfaces? }

Opts into an external iframe document route with explicit policy.

Use it whenEmbedding decks on another origin with explicit parent origins and viewer settings.

import type { DeckExternalEmbedOptions } from "hono-decks"

interface DeckExternalEmbedOptions { frameAncestors?; document?; viewer? }

Separates runtime deck and asset access from storage implementations.

Use it whenLoading decks outside the generated manifest or implementing a custom storage source.

import type { DeckSource } from "hono-decks"

interface DeckSource { listDecks(c); getCompiledDeck(c, slug); getAsset?(c, slug, path) }

Compiles filesystem decks and emits the manifest and generated modules.

Use it whenCalling the compiler from a custom build script or plugin. Most projects use the hono-decks compile CLI.

import { compileDecks } from "hono-decks/node"

compileDecks(input: CompileDecksInput): Promise<DeckManifest>

Keeps dev-only raw deck I/O separate from the runtime DeckSource.

Use it whenBuilding custom deck editing or preview tooling. It does not belong in ordinary runtime code.

import { createLocalDeckIO } from "hono-decks/node"

createLocalDeckIO(input: CreateLocalDeckIOInput): LocalDeckIO

Hydrates interactive islands from the generated client entry.

Use it whenBuilding a custom client delivery pipeline. The generated client entry normally calls it for you.

import { hydrateSlideIslands } from "hono-decks/client"

hydrateSlideIslands(input: HydrateSlideIslandsInput): void