@book.dev/ui 1.60.0

package/dist/components/ui/markdown.d.ts

@@ -0,0 +1,19 @@
+import { type ReactNode } from 'react';
+/**
+ * A small, dependency-free Markdown renderer for short assistant replies. It
+ * covers the constructs models actually emit in chat — headings, bullet/ordered
+ * lists, fenced + inline code, blockquotes, horizontal rules, links, and
+ * bold/italic/strikethrough — and renders to React elements (never
+ * `dangerouslySetInnerHTML`, so there is no HTML-injection surface). Partial
+ * Markdown renders gracefully, so it is safe to feed a streaming, half-written
+ * answer and re-render as more arrives.
+ *
+ * It is intentionally not a complete CommonMark implementation (no nested
+ * lists, tables, or reference links); those are rare in chat and not worth the
+ * weight. Unmatched syntax falls back to literal text.
+ */
+export declare function Markdown({ content, className }: {
+    content: string;
+    className?: string;
+}): ReactNode;
+export default Markdown;

package/dist/components/ui/navigation-menu.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+import * as NavigationMenuPrimitive from "@radix-ui/react-navigation-menu";
+declare const NavigationMenu: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuProps & React.RefAttributes<HTMLElement>, "ref"> & React.RefAttributes<HTMLElement>>;
+declare const NavigationMenuList: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuListProps & React.RefAttributes<HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const NavigationMenuItem: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuItemProps & React.RefAttributes<HTMLLIElement>>;
+declare const navigationMenuTriggerStyle: (props?: import("class-variance-authority/types").ClassProp | undefined) => string;
+declare const NavigationMenuTrigger: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const NavigationMenuContent: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuLink: React.ForwardRefExoticComponent<NavigationMenuPrimitive.NavigationMenuLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const NavigationMenuViewport: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuViewportProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const NavigationMenuIndicator: React.ForwardRefExoticComponent<Omit<NavigationMenuPrimitive.NavigationMenuIndicatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { navigationMenuTriggerStyle, NavigationMenu, NavigationMenuList, NavigationMenuItem, NavigationMenuContent, NavigationMenuTrigger, NavigationMenuLink, NavigationMenuIndicator, NavigationMenuViewport, };

package/dist/components/ui/popover.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent };

package/dist/components/ui/scroll-area.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+declare const ScrollArea: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const ScrollBar: React.ForwardRefExoticComponent<Omit<ScrollAreaPrimitive.ScrollAreaScrollbarProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { ScrollArea, ScrollBar };

package/dist/components/ui/select.d.ts

@@ -0,0 +1,42 @@
+import * as React from "react";
+/**
+ * A custom `Select` — a Radix-Popover listbox styled to match {@link Input},
+ * replacing the native `<select>` for a consistent, themed experience (the OS
+ * dropdown looked foreign and ignored our palette). It deliberately keeps the
+ * native API so call sites migrate by renaming the element only: it accepts
+ * `<option>` / `<optgroup>` children, a `value`, and an `onChange` that fires
+ * with a synthetic `{target: {value}}` event. Keyboard parity with the native
+ * control: arrows, Home/End, type-ahead, Enter/Space to pick, Esc to close.
+ *
+ * Pass `unstyled` when the caller's `className` fully styles the trigger (the
+ * dense database menus and the kit inputs do this); otherwise the trigger wears
+ * the shared input styling.
+ */
+/** The native-compatible change event shape the control emits. */
+export interface SelectChangeEvent {
+    target: {
+        value: string;
+    };
+    currentTarget: {
+        value: string;
+    };
+}
+export interface SelectProps {
+    value?: string | number;
+    onChange?: (event: SelectChangeEvent) => void;
+    children?: React.ReactNode;
+    placeholder?: string;
+    disabled?: boolean;
+    inputSize?: "default" | "sm";
+    /** Skip the default input styling — the caller's `className` styles the trigger. */
+    unstyled?: boolean;
+    className?: string;
+    /** Class for the trigger's wrapper (e.g. width); the popup matches its width. */
+    wrapperClassName?: string;
+    align?: "start" | "center" | "end";
+    "aria-label"?: string;
+    id?: string;
+    name?: string;
+}
+declare const Select: React.ForwardRefExoticComponent<SelectProps & React.RefAttributes<HTMLButtonElement>>;
+export { Select };

package/dist/components/ui/skeleton.d.ts

@@ -0,0 +1,6 @@
+/** A shimmering placeholder that reserves space while content is (re)computing,
+ *  so a block can fill in without shifting the surrounding layout. The shimmer
+ *  (a soft highlight sweep, see `.ob-skeleton` in index.css) reads calmer than
+ *  an opacity pulse and freezes gracefully under reduced motion. */
+declare function Skeleton({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
+export { Skeleton };

package/dist/components/ui/switch.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/components/ui/tree.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Tree component
+ * https://github.com/shadcn-ui/ui/issues/355
+ *
+ * Expansion and selection are fully controlled here (a lifted `expandedIds`
+ * set), so navigating to a page never collapses folders the user opened by hand
+ * — selecting a page only *adds* its ancestors to the open set. Rows support
+ * native HTML5 drag-and-drop (reorder among siblings + nest); the move maths
+ * live in `lib/treeMove.ts`.
+ */
+import React from "react";
+import { type LucideIcon } from "lucide-react";
+import type { DropWhere } from "@/lib/treeMove";
+interface TreeDataItem {
+    id: string;
+    name: string;
+    icon?: LucideIcon | string;
+    children?: TreeDataItem[];
+}
+declare const Tree: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    data: TreeDataItem[] | TreeDataItem;
+    selectedItemId?: string;
+    onSelectChange?: (item: TreeDataItem | undefined) => void;
+    expandAll?: boolean;
+    folderIcon?: LucideIcon;
+    itemIcon?: LucideIcon;
+    /** Right-click menu for a row (e.g. page actions). Rendered in a ContextMenuContent. */
+    renderItemContextMenu?: (item: TreeDataItem) => React.ReactNode;
+    /** Trailing controls revealed on row hover/focus (e.g. add / ⋯). `openMenu`
+     *  opens the row's context menu at the row, so a button can mirror right-click. */
+    renderRowActions?: (item: TreeDataItem, helpers: {
+        openMenu: () => void;
+    }) => React.ReactNode;
+    /** Called when a row is dropped on another (drag-to-reorder / drag-to-nest). */
+    onMove?: (draggedId: string, targetId: string, where: DropWhere) => void;
+} & React.RefAttributes<HTMLDivElement>>;
+export { Tree, type TreeDataItem };

package/dist/components/useAppCommands.d.ts

@@ -0,0 +1,25 @@
+import type { LucideIcon } from 'lucide-react';
+import { type ShortcutCombo } from '@/lib/shortcuts';
+/** A command's bucket in the palette (each renders as a labelled group). */
+export type CommandGroup = 'create' | 'view' | 'navigation' | 'app';
+export interface AppCommand {
+    id: string;
+    group: CommandGroup;
+    /** Localised display label. */
+    title: string;
+    /** Extra search terms so the palette finds it under synonyms. */
+    keywords?: string;
+    icon: LucideIcon;
+    /** Shown as a hint and bound by the global key handler when present. */
+    shortcut?: ShortcutCombo;
+    /** Runs the command. Does *not* close the palette — the caller decides. */
+    run: () => void;
+    /** Greyed out and non-firing (e.g. Back with no history). */
+    disabled?: boolean;
+}
+/**
+ * The single source of truth for app-level commands. The command palette
+ * renders them, the global key handler ({@link useGlobalShortcuts}) fires the
+ * ones with a shortcut, and both stay in sync because they read this list.
+ */
+export declare function useAppCommands(): AppCommand[];

package/dist/data/DataProvider.d.ts

@@ -0,0 +1,30 @@
+import React, { PropsWithChildren } from 'react';
+import type { DataClient, PageSnapshot } from '@book.dev/sdk';
+/**
+ * Provides the active {@link DataClient} to the document UI. The host (desktop
+ * app or web shell) decides which client to inject — local Tauri store or a
+ * remote HTTP server.
+ */
+export declare const DataProvider: React.FC<PropsWithChildren<{
+    client: DataClient;
+}>>;
+/** Access the active data client. Throws if used outside a {@link DataProvider}. */
+export declare const useData: () => DataClient;
+/**
+ * Wire a page's persistence to the active client, producing the `onLoad`/
+ * `onSave` callbacks the document editor expects. Saving stores the snapshot as
+ * the page's `data`; loading returns the stored snapshot (or `null`).
+ */
+export declare const usePagePersistence: (pageId: string, name?: string | null) => {
+    onLoad: () => Promise<PageSnapshot | null>;
+    onSave: (snapshot: PageSnapshot) => Promise<void>;
+};
+/**
+ * Read (or lazily mint + persist) the id of the page this install is currently
+ * editing. Until multi-page navigation lands, this keeps a single document
+ * stable across restarts. Returns `null` during SSR / first paint, then the id
+ * after mount — render the document only once it is non-null.
+ */
+export declare const useCurrentPageId: () => string | null;
+/** Imperative variant of {@link useCurrentPageId}. Browser-only. */
+export declare const getOrCreateCurrentPageId: () => string;

package/dist/data/index.d.ts

@@ -0,0 +1 @@
+export { DataProvider, useData, usePagePersistence, useCurrentPageId, getOrCreateCurrentPageId, } from './DataProvider';

package/dist/databaseMapLeaflet-8LYcHcR6.js

@@ -0,0 +1,87 @@
+import { useEffect as e, useRef as t } from "react";
+import { jsx as n, jsxs as r } from "react/jsx-runtime";
+import i from "leaflet";
+import { MapContainer as a, TileLayer as o, useMap as s } from "react-leaflet";
+import "leaflet.markercluster";
+import "leaflet/dist/leaflet.css";
+import "leaflet.markercluster/dist/MarkerCluster.css";
+//#region src/components/database/databaseMapLeaflet.tsx
+var c = (e) => i.divIcon({
+	className: "ob-map-pin",
+	html: `<svg width="22" height="30" viewBox="0 0 22 30" xmlns="http://www.w3.org/2000/svg" aria-hidden="true">
+      <path d="M11 0C5 0 0 4.6 0 10.4 0 18 11 30 11 30s11-12 11-19.6C22 4.6 17 0 11 0z" fill="${e}" stroke="#ffffff" stroke-width="1.5"/>
+      <circle cx="11" cy="10.5" r="3.6" fill="#ffffff"/>
+    </svg>`,
+	iconSize: [22, 30],
+	iconAnchor: [11, 30],
+	tooltipAnchor: [0, -28]
+}), l = (e) => {
+	let t = e.getChildCount(), n = t < 10 ? 32 : t < 100 ? 38 : 44;
+	return i.divIcon({
+		html: `<div class="ob-map-cluster" style="width:${n}px;height:${n}px">${t}</div>`,
+		className: "ob-map-cluster-wrap",
+		iconSize: [n, n]
+	});
+}, u = (e) => e.map((e) => `${e.lat.toFixed(5)},${e.lng.toFixed(5)},${e.color}`).sort().join("|"), d = ({ markers: n }) => {
+	let r = s(), a = u(n), o = t("");
+	return e(() => {
+		if (a === o.current || n.length === 0) return;
+		if (o.current = a, n.length === 1) {
+			r.setView([n[0].lat, n[0].lng], 12);
+			return;
+		}
+		let e = i.latLngBounds(n.map((e) => [e.lat, e.lng]));
+		r.fitBounds(e, {
+			padding: [40, 40],
+			maxZoom: 14
+		});
+	}, [r, a]), null;
+}, f = ({ markers: n, clustered: r, onOpen: a }) => {
+	let o = s(), d = t(a);
+	return d.current = a, e(() => {
+		let e = r ? i.markerClusterGroup({
+			chunkedLoading: !0,
+			showCoverageOnHover: !1,
+			maxClusterRadius: 56,
+			iconCreateFunction: l
+		}) : i.layerGroup();
+		for (let t of n) {
+			let n = i.marker([t.lat, t.lng], {
+				icon: c(t.color),
+				title: t.label,
+				keyboard: !0
+			});
+			n.bindTooltip(t.label, {
+				direction: "top",
+				offset: [0, -28]
+			}), n.on("click", () => d.current(t.row.id)), e.addLayer(n);
+		}
+		return o.addLayer(e), () => {
+			o.removeLayer(e);
+		};
+	}, [
+		o,
+		u(n),
+		r
+	]), null;
+}, p = ({ markers: e, clustered: t, onOpen: i }) => /* @__PURE__ */ r(a, {
+	center: [20, 0],
+	zoom: 2,
+	scrollWheelZoom: !0,
+	className: "h-full w-full",
+	children: [
+		/* @__PURE__ */ n(o, {
+			attribution: "© <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors",
+			url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+			maxZoom: 19
+		}),
+		/* @__PURE__ */ n(f, {
+			markers: e,
+			clustered: t,
+			onOpen: i
+		}),
+		/* @__PURE__ */ n(d, { markers: e })
+	]
+});
+//#endregion
+export { p as default };

package/dist/export/__tests__/chartNormalize.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/export/__tests__/export.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/export/__tests__/exportReactive.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/export/chartNormalize.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Normalizes a cell value into a list of named numeric series.
+ *
+ * Accepted shapes:
+ *   - `number[]`                                          → one series, named after the cell
+ *   - `{ series: Array<{ name?, data: number[] }> }`     → multiple named series from one cell
+ *
+ * Non-conforming inputs (string, null, malformed objects) return []. Within
+ * each series, non-numeric values are filtered out — the chart only plots
+ * what's actually plottable. Empty series (zero numeric values) are dropped.
+ *
+ * The shape is intentionally a union (not a Chart.js-style always-nested
+ * object) so the common "one cell, one curve" case is just `[1, 2, 3]`
+ * with the cell's display name as the series label, and richer
+ * compositions opt into the `{series}` form when they need multiple
+ * curves out of one expression.
+ */
+export type NormalizedSeries = {
+    name: string;
+    data: number[];
+};
+export declare function normalizeChartInput(value: unknown, fallbackName: string): NormalizedSeries[];

package/dist/export/chartSvg.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedSeries } from './chartNormalize';
+export declare function buildChartSvg(series: NormalizedSeries[], width?: number, color?: string): SVGElement | null;

package/dist/export/documentModel.d.ts

@@ -0,0 +1,136 @@
+/**
+ * A normalized, presentation-agnostic model of a page document, built once from
+ * a {@link PageSnapshot} and consumed by every exporter (Markdown, PDF, HTML).
+ *
+ * It parses each EditorJS block into a typed shape: inline HTML → formatting
+ * runs (bold/italic/code/marker/link/`@`-mention), lists into nested items, and
+ * reactive blocks (slider/expr/chart) resolved against the snapshot's persisted
+ * `values`/`names`. Pure and DOM-light (uses `DOMParser`, available in the
+ * browser and happy-dom) so it is unit-tested directly.
+ */
+import type { PageSnapshot } from '@book.dev/sdk';
+import { type NormalizedSeries } from './chartNormalize';
+export interface InlineRun {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    code?: boolean;
+    marker?: boolean;
+    /** Text colour (CSS hex) — from the editor's `tc` palette token. */
+    color?: string;
+    /** Highlight colour (CSS hex) when a `<mark>` carries one. */
+    markerColor?: string;
+    link?: string;
+    mention?: {
+        pageId: string;
+        label: string;
+    };
+}
+export interface ListItem {
+    runs: InlineRun[];
+    items: ListItem[];
+}
+export type DocBlock = {
+    type: 'paragraph';
+    runs: InlineRun[];
+} | {
+    type: 'header';
+    level: number;
+    runs: InlineRun[];
+} | {
+    type: 'list';
+    ordered: boolean;
+    items: ListItem[];
+} | {
+    type: 'quote';
+    runs: InlineRun[];
+    caption: string;
+} | {
+    type: 'code';
+    code: string;
+} | {
+    type: 'delimiter';
+} | {
+    type: 'table';
+    withHeadings: boolean;
+    rows: InlineRun[][][];
+} | {
+    type: 'callout';
+    variant: string;
+    runs: InlineRun[];
+} | {
+    type: 'accordion';
+    title: InlineRun[];
+    content: InlineRun[];
+    open: boolean;
+} | {
+    type: 'checklist';
+    items: {
+        runs: InlineRun[];
+        checked: boolean;
+    }[];
+} | {
+    type: 'toc';
+    entries: {
+        level: number;
+        text: string;
+    }[];
+} | {
+    type: 'button';
+    label: string;
+    url: string;
+} | {
+    type: 'divider';
+    style: string;
+    label: string;
+} | {
+    type: 'slider';
+    name: string;
+    value: unknown;
+} | {
+    type: 'expr';
+    name: string;
+    value: unknown;
+    source: string;
+} | {
+    type: 'chart';
+    series: NormalizedSeries[];
+    kind: string;
+    labels: string[];
+    title: string;
+    value: unknown;
+} | {
+    type: 'kvalue';
+    label: string;
+    value: unknown;
+} | {
+    type: 'light';
+    label: string;
+    status: string;
+    value: unknown;
+} | {
+    type: 'progress';
+    label: string;
+    pct: number;
+    readout: string;
+} | {
+    type: 'unknown';
+    raw: string;
+};
+export interface DocModel {
+    title: string;
+    icon: string;
+    blocks: DocBlock[];
+}
+/** Parse a block's inline HTML into formatting runs. */
+export declare function parseInline(html: string): InlineRun[];
+/** Plain text of an inline run list (for titles, captions, etc.). */
+export declare function runsToText(runs: InlineRun[]): string;
+export interface BuildModelOptions {
+    title: string;
+    icon: string;
+    snapshot: PageSnapshot;
+}
+export declare function buildDocumentModel({ title, icon, snapshot: rawSnapshot }: BuildModelOptions): DocModel;

package/dist/export/exportSite.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Gather a page and everything reachable from it into a self-contained bundle for
+ * the interactive HTML export: the page, its nested subpages, the databases it
+ * hosts (with their rows — which are themselves pages), and every page those link
+ * to. A breadth-first crawl from the root, deduped by id and capped, so a single
+ * exported file carries a whole navigable mini-site.
+ */
+import { type DataClient, type DatabaseRow, type DatabaseSchema, type PageSnapshot } from '@book.dev/sdk';
+/** A database hosted by a page, projected for static rendering. */
+export interface SiteDatabase {
+    schema: DatabaseSchema;
+    rows: DatabaseRow[];
+}
+/** One page in the exported bundle. */
+export interface SitePage {
+    id: string;
+    title: string;
+    icon: string;
+    snapshot: PageSnapshot;
+    /** Present when this page hosts a database (its rows are also pages in the bundle). */
+    database?: SiteDatabase;
+}
+/** The exported mini-site: the root page plus every page reachable from it. */
+export interface SiteBundle {
+    rootId: string;
+    pages: SitePage[];
+}
+/** Page ids a snapshot references: subpage/database blocks and inline `@`-mentions. */
+export declare function referencedPageIds(rawSnapshot: PageSnapshot): string[];
+/**
+ * Crawl from `rootId` and return every reachable page. The root's live content is
+ * supplied via `root` (so unsaved edits export faithfully); every other page is
+ * fetched from the store. Hosted databases contribute their schema, rows, and the
+ * row pages themselves.
+ */
+export declare function gatherSite(client: DataClient, rootId: string, root: {
+    snapshot: PageSnapshot;
+    title: string;
+    icon: string;
+}): Promise<SiteBundle>;

package/dist/export/format.d.ts

@@ -0,0 +1,2 @@
+/** Shared value formatting for exports (mirrors the editor's result display). */
+export declare function formatValue(v: unknown): string;

package/dist/export/kitChart.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Kind-faithful kit-chart drawing (line, area, bar, pie, donut, scatter, funnel)
+ * as pure SVG — no charting library. The geometry mirrors the editor's
+ * `chartMath`, so an exported chart looks like the one in the window.
+ *
+ * The drawing lives as a JS **source string** ({@link KIT_CHART_JS}) so it has a
+ * single definition used two ways: inlined verbatim into the standalone HTML
+ * runtime (where it redraws live as sliders move), and executed here via
+ * `new Function` for the static PDF export ({@link kitChartSvg}). Keeping it as
+ * one string avoids the two copies drifting apart.
+ */
+export declare const KIT_CHART_JS = "\nconst KIT_PALETTE=[\"#6366f1\",\"#f59e0b\",\"#10b981\",\"#ef4444\",\"#8b5cf6\",\"#06b6d4\",\"#f97316\",\"#14b8a6\"];\nfunction kitSeries(v){ if(v&&typeof v===\"object\"&&Array.isArray(v.series)) return v.series.filter(s=>Array.isArray(s.data)&&s.data.every(n=>typeof n===\"number\")&&s.data.length).map(s=>({name:String(s.name??\"\"),values:s.data})); if(Array.isArray(v)&&v.every(n=>typeof n===\"number\")) return v.length?[{name:\"\",values:v}]:[]; if(Array.isArray(v)&&v.length&&v.every(p=>p&&typeof p===\"object\"&&isFinite(p.x)&&isFinite(p.y))) return [{name:\"\",values:v.map(p=>p.y)}]; if(Array.isArray(v)&&v.every(a=>Array.isArray(a)&&a.every(n=>typeof n===\"number\"))) return v.filter(a=>a.length).map((a,i)=>({name:\"s\"+(i+1),values:a})); if(v&&typeof v===\"object\"&&!Array.isArray(v)) return Object.entries(v).filter(([,a])=>Array.isArray(a)&&a.every(n=>typeof n===\"number\")&&a.length).map(([n,a])=>({name:n,values:a})); if(typeof v===\"number\"&&isFinite(v)) return [{name:\"\",values:[v]}]; return []; }\nfunction kitLabelled(v,labels){ if(v&&typeof v===\"object\"&&!Array.isArray(v)){ const e=Object.entries(v).filter(([,n])=>typeof n===\"number\"&&isFinite(n)); if(e.length) return e.map(([label,value])=>({label,value})); } if(Array.isArray(v)&&v.every(n=>typeof n===\"number\")) return v.map((value,i)=>({label:labels[i]||(\"#\"+(i+1)),value})); return []; }\nfunction kitExtent(vals){ if(!vals.length) return {min:0,max:1}; let min=Math.min.apply(null,vals.concat([0])), max=Math.max.apply(null,vals); if(min===max){min-=1;max+=1;} return {min,max}; }\nfunction kitScale(v,d,r0,r1){ return r0+((v-d.min)/(d.max-d.min))*(r1-r0); }\nfunction kitTicks(d){ const span=d.max-d.min, step0=Math.pow(10,Math.floor(Math.log10(span/3))); const step=[step0,step0*2,step0*5,step0*10].find(s=>span/s<=4)||step0*10; const out=[]; for(let v=Math.ceil(d.min/step)*step; v<=d.max+1e-9; v+=step) out.push(Math.round(v*1e6)/1e6); return out; }\nfunction drawKit(v,kind,labels){\n  labels = labels || [];\n  const W=660,H=300,PAD=34,P=KIT_PALETTE;\n  const grid=(d)=>kitTicks(d).map(t=>{const y=kitScale(t,d,H-PAD,PAD);return '<line x1=\"'+PAD+'\" x2=\"'+(W-PAD)+'\" y1=\"'+y+'\" y2=\"'+y+'\" stroke=\"currentColor\" opacity=\"0.15\" stroke-dasharray=\"2 4\"/><text x=\"'+(PAD-6)+'\" y=\"'+(y+3)+'\" font-size=\"10\" fill=\"currentColor\" opacity=\"0.55\" text-anchor=\"end\">'+t+'</text>';}).join('');\n  let body='';\n  if(kind==='pie'||kind==='donut'){\n    const slices=kitLabelled(v,labels).filter(s=>s.value>0); if(!slices.length) return '';\n    const total=slices.reduce((a,s)=>a+s.value,0), r=H/2-16, r0=kind==='donut'?r*0.55:0, cx=H/2, cy=H/2; let ang=-Math.PI/2;\n    body=slices.map((s,i)=>{ const sweep=s.value/total*Math.PI*2, a0=ang, a1=ang+sweep; ang=a1; const end=sweep>=Math.PI*2-1e-6?a1-1e-4:a1, large=sweep>Math.PI?1:0; const pt=(a,rad)=>(cx+Math.cos(a)*rad)+','+(cy+Math.sin(a)*rad);\n      const path=r0>0?'M '+pt(a0,r)+' A '+r+' '+r+' 0 '+large+' 1 '+pt(end,r)+' L '+pt(end,r0)+' A '+r0+' '+r0+' 0 '+large+' 0 '+pt(a0,r0)+' Z':'M '+cx+','+cy+' L '+pt(a0,r)+' A '+r+' '+r+' 0 '+large+' 1 '+pt(end,r)+' Z';\n      return '<path d=\"'+path+'\" fill=\"'+P[i%P.length]+'\"/>';\n    }).join('')+slices.map((s,i)=>'<g transform=\"translate('+(H+24)+','+(28+i*20)+')\"><rect width=\"10\" height=\"10\" rx=\"2\" fill=\"'+P[i%P.length]+'\"/><text x=\"16\" y=\"9\" font-size=\"11\" fill=\"currentColor\" opacity=\"0.7\">'+s.label+' \u00B7 '+Math.round(s.value/total*100)+'%</text></g>').join('');\n  } else if(kind==='funnel'){\n    const stages=kitLabelled(v,labels); const max=Math.max.apply(null,stages.map(s=>Math.max(0,s.value)).concat([0])); if(!stages.length||max<=0) return '';\n    const gap=3, rowH=(H-PAD-gap*(stages.length-1))/stages.length;\n    body=stages.map((s,i)=>{ const w=Math.max(Math.max(0,s.value)/max*(W-PAD*2),2), x=PAD+((W-PAD*2)-w)/2, y=12+i*(rowH+gap);\n      return '<rect x=\"'+x+'\" y=\"'+y+'\" width=\"'+w+'\" height=\"'+rowH+'\" rx=\"4\" fill=\"'+P[i%P.length]+'\" opacity=\"0.85\"/><text x=\"'+(W/2)+'\" y=\"'+(y+rowH/2+4)+'\" font-size=\"11\" font-weight=\"600\" text-anchor=\"middle\" fill=\"#fff\">'+s.label+' \u00B7 '+s.value+'</text>';\n    }).join('');\n  } else if(kind==='scatter'){\n    const pts=Array.isArray(v)&&v.length&&v.every(p=>p&&typeof p===\"object\"&&isFinite(p.x)&&isFinite(p.y))?v:(Array.isArray(v)&&v.every(n=>typeof n===\"number\")?v.map((y,x)=>({x,y})):[]); if(!pts.length) return '';\n    const dx=kitExtent(pts.map(p=>p.x)), dy=kitExtent(pts.map(p=>p.y));\n    body=grid(dy)+pts.map(p=>'<circle cx=\"'+kitScale(p.x,dx,PAD,W-PAD)+'\" cy=\"'+kitScale(p.y,dy,H-PAD,PAD)+'\" r=\"4\" fill=\"'+P[0]+'\" opacity=\"0.75\"/>').join('');\n  } else if(kind==='bar'){\n    const series=kitSeries(v); if(!series.length) return '';\n    const d=kitExtent(series.flatMap(s=>s.values)), n=Math.max.apply(null,series.map(s=>s.values.length)), groupW=(W-PAD*2)/n, barW=Math.max(groupW*0.7/series.length,2), zero=kitScale(Math.max(d.min,0),d,H-PAD,PAD);\n    body=grid(d)+series.map((s,si)=>s.values.map((val,i)=>{ const y=kitScale(val,d,H-PAD,PAD), x=PAD+i*groupW+groupW*0.15+si*barW; return '<rect x=\"'+x+'\" y=\"'+Math.min(y,zero)+'\" width=\"'+(barW-1)+'\" height=\"'+Math.max(Math.abs(zero-y),1)+'\" rx=\"2\" fill=\"'+P[si%P.length]+'\"/>'; }).join('')).join('')+labels.slice(0,n).map((l,i)=>'<text x=\"'+(PAD+i*groupW+groupW/2)+'\" y=\"'+(H-8)+'\" font-size=\"10\" text-anchor=\"middle\" fill=\"currentColor\" opacity=\"0.55\">'+l+'</text>').join('');\n  } else { // line / area\n    const series=kitSeries(v); if(!series.length) return '';\n    const d=kitExtent(series.flatMap(s=>s.values)), base=kitScale(Math.max(d.min,0),d,H-PAD,PAD);\n    const n=Math.max.apply(null,series.map(s=>s.values.length));\n    body=grid(d)+series.map((s,i)=>{ const len=s.values.length; const pts=s.values.map((val,j)=>{ const x=len===1?W/2:PAD+(j/(len-1))*(W-PAD*2); return (Math.round(x*10)/10)+','+(Math.round(kitScale(val,d,H-PAD,PAD)*10)/10); }).join(' ');\n      const first=pts.split(' ')[0].split(',')[0], parts=pts.split(' '), last=parts[parts.length-1].split(',')[0];\n      return (kind==='area'?'<polygon points=\"'+first+','+base+' '+pts+' '+last+','+base+'\" fill=\"'+P[i%P.length]+'\" opacity=\"0.15\"/>':'')+'<polyline points=\"'+pts+'\" fill=\"none\" stroke=\"'+P[i%P.length]+'\" stroke-width=\"2\" stroke-linejoin=\"round\"/>';\n    }).join('')+labels.slice(0,n).map((l,i)=>'<text x=\"'+(n===1?W/2:PAD+(i/(n-1))*(W-PAD*2))+'\" y=\"'+(H-8)+'\" font-size=\"10\" text-anchor=\"middle\" fill=\"currentColor\" opacity=\"0.55\">'+l+'</text>').join('');\n  }\n  if(kind!=='pie'&&kind!=='donut'&&kind!=='funnel'&&kind!=='scatter'){\n    const named=kitSeries(v).filter(s=>s.name);\n    if(named.length>1) body+=named.map((s,i)=>'<g transform=\"translate('+(W-PAD-90)+','+(16+i*18)+')\"><rect width=\"10\" height=\"10\" rx=\"2\" fill=\"'+P[i%P.length]+'\"/><text x=\"16\" y=\"9\" font-size=\"11\" fill=\"currentColor\" opacity=\"0.7\">'+s.name+'</text></g>').join('');\n  }\n  return '<svg viewBox=\"0 0 '+W+' '+H+'\" xmlns=\"http://www.w3.org/2000/svg\" style=\"width:100%;height:auto\">'+body+'</svg>';\n}\n";
+/** The chart's fixed view-box dimensions (mirrors the source above). */
+export declare const KIT_CHART_W = 660;
+export declare const KIT_CHART_H = 300;
+/**
+ * Draw a kit chart to an SVG string for a value/kind/labels — the static-export
+ * counterpart of the runtime's live redraw. Returns '' when there's nothing
+ * plottable.
+ */
+export declare function kitChartSvg(value: unknown, kind: string, labels?: string[]): string;

package/dist/export/toHtml.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Render a page — or a whole reachable mini-site — to a **self-contained,
+ * interactive** HTML document. Prose, lists, code, mentions and links are styled
+ * static HTML; reactive blocks stay *live* (sliders recompute their dependent
+ * expressions and redraw charts) via a small inlined runtime; and nested pages,
+ * subpages and database rows are **navigable** — clicking one swaps the document
+ * to that page, all inside the single file.
+ *
+ * - {@link toHtml} renders one page snapshot (the Markdown/PDF-parity baseline).
+ * - {@link toHtmlSite} renders a {@link SiteBundle}: every page as a section, a
+ *   client-side router, and databases drawn as tables of navigable rows.
+ */
+import type { PageSnapshot } from '@book.dev/sdk';
+import type { SiteBundle } from './exportSite';
+/** Build the interactive HTML for a single page snapshot (Markdown/PDF parity). */
+export declare function toHtml(rawSnapshot: PageSnapshot, title: string, icon: string): string;
+/** Build a self-contained, interactive slide deck: blocks split into slides at
+ *  every divider, widgets stay live offline, arrow-key navigation. */
+export declare function toSlideDeck(rawSnapshot: PageSnapshot, title: string, icon: string): string;
+/**
+ * Build one interactive HTML file for a whole {@link SiteBundle}: every page as a
+ * navigable section, databases as tables of navigable rows, and a client-side
+ * router that swaps the visible page on link clicks (with browser back/forward).
+ */
+export declare function toHtmlSite(bundle: SiteBundle): string;

package/dist/export/toMarkdown.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Render a {@link DocModel} to Markdown. Pure and unit-tested. Reactive blocks
+ * collapse to their current value (`**name** = value`); charts to a caption with
+ * series names; `@`-mentions to their label text (there is no portable URL).
+ */
+import type { DocModel } from './documentModel';
+export declare function toMarkdown(model: DocModel): string;

package/dist/export/toPdf.d.ts

@@ -0,0 +1,14 @@
+import 'svg2pdf.js';
+export type PdfMode = 'paged' | 'continuous';
+/**
+ * Render exported HTML to a vector PDF. `mode` controls pagination:
+ *  - `continuous`: a single page sized to the full content height;
+ *  - `paged`: US-Letter pages, the content sliced across them by viewBox.
+ */
+export declare function toPdf(html: string, mode: PdfMode): Promise<Blob>;
+/**
+ * Render a slide-deck HTML (from {@link toHtmlSlides}) to a PDF — one slide per
+ * page, each fit to a landscape page at the slide's own aspect. All slides are
+ * forced visible first (the deck hides all but the current one).
+ */
+export declare function toPdfSlides(html: string): Promise<Blob>;