@book.dev/ui 1.60.0

package/dist/blockeditor/kit/inputs2.d.ts

@@ -0,0 +1,86 @@
+import React from 'react';
+import type { CustomBlockProps } from '../registry';
+/** Definitions consumed by kit/index.ts (type + renderer + slash entry). */
+export declare const INPUT2_BLOCKS: readonly [{
+    readonly type: "choicecards";
+    readonly render: React.FC<CustomBlockProps>;
+    readonly slash: {
+        readonly label: "Choice cards";
+        readonly hint: "Pick from image cards — single or multi";
+        readonly keywords: "choice cards image radio multi select picture option visual gallery pick";
+        readonly make: () => {
+            type: string;
+            props: {
+                name: string;
+                opts: {
+                    label: string;
+                }[];
+                value: null;
+            };
+        };
+    };
+}, {
+    readonly type: "longtext";
+    readonly render: React.FC<CustomBlockProps>;
+    readonly slash: {
+        readonly label: "Long text";
+        readonly hint: "A named multi-line text area";
+        readonly keywords: "long text textarea multiline paragraph notes comment input";
+        readonly make: () => {
+            type: string;
+            props: {
+                name: string;
+                value: string;
+            };
+        };
+    };
+}, {
+    readonly type: "richtext";
+    readonly render: React.FC<CustomBlockProps>;
+    readonly slash: {
+        readonly label: "Rich text";
+        readonly hint: "Formatted text — bold, italic, links";
+        readonly keywords: "rich text formatted markup bold italic underline link wysiwyg input";
+        readonly make: () => {
+            type: string;
+            props: {
+                name: string;
+                runs: never[];
+            };
+        };
+    };
+}, {
+    readonly type: "searchselect";
+    readonly render: React.FC<CustomBlockProps>;
+    readonly slash: {
+        readonly label: "Searchable select";
+        readonly hint: "Search a list — single or multi";
+        readonly keywords: "search select multiselect dropdown combobox autocomplete filter pick option";
+        readonly make: () => {
+            type: string;
+            props: {
+                name: string;
+                opts: {
+                    label: string;
+                }[];
+                value: null;
+            };
+        };
+    };
+}, {
+    readonly type: "tagfield";
+    readonly render: React.FC<CustomBlockProps>;
+    readonly slash: {
+        readonly label: "Tag field";
+        readonly hint: "Free-entry tags with suggestions";
+        readonly keywords: "tag tags chips labels keywords free entry suggestions multi input";
+        readonly make: () => {
+            type: string;
+            props: {
+                name: string;
+                selected: never[];
+                freeEntry: boolean;
+            };
+        };
+    };
+}];

package/dist/blockeditor/kit/kitConfig.d.ts

@@ -0,0 +1,5 @@
+export declare function registerKitConfig(blockId: string, open: () => void): () => void;
+/** Whether a block has a registered config affordance (i.e. is configurable). */
+export declare const hasKitConfig: (blockId: string) => boolean;
+/** Open a block's config popover. Returns false if the block has none. */
+export declare function openKitConfig(blockId: string): boolean;

package/dist/blockeditor/kit/kitPanel.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The bridge for the "Expand" view of an interactive block's settings. Rather
+ * than a bespoke drawer, the config reuses the app's existing **side pane**:
+ * KitConfig portals its live fields into a host element the {@link SplitPane}
+ * mounts when it shows the `CONFIG_PANE_ID` pseudo-page.
+ *
+ * Three module singletons, the same pattern as `kitConfig`/`openDocs`:
+ *  - `panel`  — which block is being configured (id + title), or null.
+ *  - `host`   — the DOM node inside the side pane to portal the fields into.
+ *  - `nav`    — how to open/close that side pane, wired by NavigationProvider
+ *               (the bridge stays free of React/navigation imports).
+ */
+export interface KitPanelState {
+    blockId: string;
+    title: string;
+}
+/** Open (or switch) the expanded config to a block, and reveal the side pane. */
+export declare function openKitPanel(blockId: string, title: string): void;
+/** Clear the expanded config. By default also hides the side pane; pass
+ *  `keepPane` when the pane is already going away (its own unmount calls this). */
+export declare function closeKitPanel(opts?: {
+    keepPane?: boolean;
+}): void;
+export declare const getKitPanel: () => KitPanelState | null;
+export declare function subscribeKitPanel(cb: () => void): () => void;
+/** The side pane publishes its portal host (null on unmount). */
+export declare function setKitPanelHost(el: HTMLElement | null): void;
+export declare const getKitPanelHost: () => HTMLElement | null;
+export declare function subscribeKitPanelHost(cb: () => void): () => void;
+/** NavigationProvider wires opening/closing the CONFIG side pane. */
+export declare function registerKitPanelNav(open: (blockId: string) => void, close: () => void): () => void;

package/dist/blockeditor/kit/lock.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Group lock state, provided by a `group` block to everything rendered inside
+ * it. A locked group makes its contents read-only — `BlockEditor` swaps in a
+ * read-only editor for descendant blocks — except interactive widgets a reader
+ * is meant to keep operating (those carry `props.interactive`).
+ */
+export interface KitLockState {
+    locked: boolean;
+}
+export declare const KitLockContext: import("react").Context<KitLockState>;
+/** Whether the nearest enclosing group is locked. */
+export declare const useKitLock: () => boolean;

package/dist/blockeditor/kit/options.d.ts

@@ -0,0 +1,60 @@
+import { type BlockMap } from '../model';
+/**
+ * Choice options for the radio / checklist / dropdown inputs.
+ *
+ * An option has a **display label** (what the reader sees) and a **value** (what
+ * the reactive scope and exports serialise). They're decoupled so a friendly
+ * "Option 1" can publish a clean `option-1`. The value defaults to a slug of
+ * the label, so the simple case (label only) still works and old documents —
+ * which stored a plain comma-separated `options` string where value == label —
+ * keep resolving unchanged.
+ */
+export interface KitOption {
+    label: string;
+    value: string;
+    /** Choice-card media (optional): a cover image (URL or data URL), an
+     *  icon/emoji, or a palette colour token shown when no image is set. */
+    image?: string;
+    icon?: string;
+    color?: string;
+}
+/** Stored option (value may be blank → falls back to a slug of the label). */
+interface RawOption {
+    label: string;
+    value?: string;
+    image?: string;
+    icon?: string;
+    color?: string;
+}
+/** A URL/identifier-friendly slug of a label ("Option 1" → "option-1"). */
+export declare const slugify: (s: string) => string;
+/**
+ * Turn ANY free-text display label into a valid TypeScript identifier, so a
+ * reader-facing name like "Tax rate (2024) 💰" still publishes a usable symbol
+ * (`taxRate2024`) with the author never touching the config. The rules, in
+ * order: fold accents to ASCII ("Café" → "Cafe"); split on every run of
+ * non-identifier characters and camelCase the words; prefix a leading digit
+ * with `_`; suffix a reserved word with `_`. Returns '' only when nothing
+ * usable remains (the caller falls back to the block's default symbol). The
+ * reactive engine references these via `new Function(name, …)`, so the result
+ * is always legal.
+ */
+export declare const varNameFromLabel: (label: string) => string;
+/** The value an option actually publishes (explicit value, else slug of label). */
+export declare const optionValue: (opt: RawOption) => string;
+/** Parse the legacy comma-separated string. `Label = value` sets an explicit
+ *  value; a bare `Label` keeps value == label (the historical behaviour). */
+export declare function parseOptionsString(raw: string): RawOption[];
+/** The stored raw options for a block: the structured `opts` array if present,
+ *  else the parsed legacy `options` string. */
+export declare function rawOptions(props: {
+    opts?: unknown;
+    options?: unknown;
+}): RawOption[];
+/** Fully-resolved options (every value non-empty) for rendering + publishing. */
+export declare function resolveOptions(block: BlockMap): KitOption[];
+/** Same resolution from a plain props bag (export path). */
+export declare function resolveOptionsFromProps(props: Record<string, unknown>): KitOption[];
+/** Map a stored value back to its display label (falls back to the value). */
+export declare const labelOf: (options: KitOption[], value: string) => string;
+export {};

package/dist/blockeditor/kit/progress.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { CustomBlockProps } from '../registry';
+export declare const PROGRESS_BLOCKS: readonly [{
+    readonly type: "progressbar";
+    readonly render: React.FC<CustomBlockProps>;
+    readonly slash: {
+        readonly label: "Progress bar";
+        readonly hint: "A bar computed from an expression over inputs";
+        readonly keywords: "progress bar meter completion percent gauge status indicator";
+        readonly make: () => {
+            type: string;
+            props: {
+                label: string;
+                source: string;
+                max: number;
+                format: string;
+            };
+        };
+    };
+}];

package/dist/blockeditor/kit/scope.d.ts

@@ -0,0 +1,100 @@
+import type * as Y from 'yjs';
+import { type BlockMap } from '../model';
+/**
+ * The name a block publishes under: its explicit variable `name` when set,
+ * otherwise one derived from the human display `label` ("Dark mode" → darkMode).
+ * So an author who only fills in a display name still gets a working reactive
+ * symbol — without it, display-name-only inputs published nothing and the whole
+ * dataflow looked empty. Returns '' when neither yields a legal identifier.
+ */
+export declare function publishedName(block: BlockMap): string;
+/** Block types that publish a named value into the scope. */
+export declare const INPUT_TYPES: Set<string>;
+/**
+ * The reactive namespace a group publishes under — a legal identifier derived
+ * from the group's display name. Inputs inside a named group are exported as
+ * `group.field.value`; an unnamed group adds no namespace.
+ */
+export declare function groupKey(block: BlockMap): string;
+/** The plain-text projection of a rich-text input's stored runs. Used as the
+ *  block's published value (so evalExpr/export read a string) and by the export
+ *  tokenizer. Defined here so scope, the renderer, and exports agree. */
+export declare function richTextPlain(block: BlockMap): string;
+/** The published value of one input block (shape depends on the type). */
+export declare function inputValue(block: BlockMap): unknown;
+/** Every named input's current value, by name. */
+export declare function inputScope(doc: Y.Doc): Record<string, unknown>;
+/** Find the first input block published under `name`, or null. */
+export declare function findInput(doc: Y.Doc, name: string): BlockMap | null;
+/** Write an input's value back from a synced/plain value (inverse of inputValue). */
+export declare function setInputValue(block: BlockMap, value: unknown): void;
+/** A group's own inputs, keyed by published field name (not crossing into any
+ *  nested group, which keeps its own namespace). Drives cross-page sync. */
+export declare function groupInputs(group: BlockMap): Map<string, BlockMap>;
+/**
+ * Write a numeric input's value (button actions: set / increment). Clamps to
+ * the input's own min/max when it declares them. No-op when the name doesn't
+ * resolve or the target isn't numeric.
+ */
+export declare function setNamedNumber(doc: Y.Doc, name: string, next: (current: number) => number): void;
+/**
+ * Evaluate an expression over the input scope. Same trust model as the app's
+ * expr blocks: the document's own code runs client-side with the inputs in
+ * scope. Returns `{value}` or `{error}` — callers render, never throw.
+ */
+export declare function evalExpr(source: string, scope: Record<string, unknown>): {
+    value?: unknown;
+    error?: string;
+};
+/**
+ * Evaluate live-code: a single expression, or — when that doesn't parse — a
+ * function body (multi-line code with its own `return`). Lets a live code
+ * block hold real programs, not just one-liners.
+ */
+export declare function evalCode(source: string, scope: Record<string, unknown>): {
+    value?: unknown;
+    error?: string;
+};
+export interface ComputedScope {
+    /** Every name a consumer can reference: inputs + named live-code outputs. */
+    scope: Record<string, unknown>;
+    /** Per-block evaluation results (live code + legacy formulas), by block id. */
+    results: Map<string, {
+        value?: unknown;
+        error?: string;
+    }>;
+}
+/**
+ * The document's full reactive scope: input values first, then every LIVE
+ * code block (and legacy formula block) evaluated **in document order**, each
+ * seeing the inputs plus all named outputs above it — so computations chain.
+ * A single ordered pass: forward references read `undefined`, cycles can't
+ * happen.
+ */
+export declare function computeScope(doc: Y.Doc): ComputedScope;
+/** Render an evaluated value the way the formula block does (compact numbers). */
+export declare function formatValue(value: unknown): string;
+/** The status-light state. `off` = neutral (no/unevaluable value). */
+export type Status = 'ok' | 'warn' | 'bad' | 'off';
+/**
+ * Map a status-light expression result to a state. Booleans → ok/bad; numbers
+ * → ok at/above `okAt`, warn at/above `warnAt`, else bad; the strings
+ * ok/warn/bad pass through; anything else is neutral. Shared by the live block
+ * and the exporters so a light's colour is identical in the window and a PDF.
+ */
+export declare function statusOf(value: unknown, error: string | undefined, okAt: number, warnAt: number): Status;
+/** One reactive block's resolved value for export (and a status light's state). */
+export interface ExportCell {
+    value: unknown;
+    /** Status lights only: the resolved ok/warn/bad/off state. */
+    status?: Status;
+}
+/**
+ * Resolve every reactive block's CURRENT value the way the editor does, keyed by
+ * block id — so static exports (PDF / Markdown) and the pre-hydration HTML show
+ * the same numbers, charts, lights and bars as the live window. Inputs publish
+ * their value; live code / formulas come from {@link computeScope}; charts,
+ * status lights, and progress bars evaluate their expression over the same
+ * scope (mirroring their block components).
+ */
+export declare function computeExportCells(doc: Y.Doc): Map<string, ExportCell>;

package/dist/blockeditor/model.d.ts

@@ -0,0 +1,236 @@
+import * as Y from 'yjs';
+/**
+ * The block editor's document model: a CRDT block tree in a Y.Doc.
+ *
+ * Shape — one uniform recursive structure for everything:
+ *
+ *   doc.getArray('blocks')      Y.Array<Y.Map>      top-level blocks
+ *   block (Y.Map):
+ *     id        string          stable id (drag/drop, React keys, anchors)
+ *     type      BlockType
+ *     text      Y.Text          rich text (attribute runs), text blocks only
+ *     props     Y.Map           type-specific config (heading level, spans…)
+ *     children  Y.Array<Y.Map>  container blocks (columns → column → blocks,
+ *                               table → row → cell)
+ *
+ * Uniformity is the point: a table cell and a layout column hold ordinary
+ * blocks, so editing, drag-and-drop, selection, and serialization recurse
+ * with no special cases. Inline formatting lives in Y.Text attribute runs
+ * ({b,i,u,s,c,a,m} — bold, italic, underline, strike, code, anchor href,
+ * mention page id) so concurrent edits merge at the character level.
+ *
+ * Two serializations:
+ *  - the Y update (base64) — the CRDT history, what collaboration merges;
+ *  - a plain JSON projection — what the server, exports, and tests read.
+ * Both are stored in the page snapshot (see `encodeSnapshot`).
+ */
+export type BlockType = 'paragraph' | 'heading' | 'list' | 'todo' | 'quote' | 'callout' | 'code' | 'notes' | 'divider' | 'columns' | 'column' | 'table' | 'row' | 'cell' | 'group' | 'tabs' | 'tab' | 'accordion' | 'accordionsection';
+/** Inline formatting attributes carried by Y.Text runs. */
+export interface InlineAttrs {
+    b?: boolean;
+    i?: boolean;
+    u?: boolean;
+    s?: boolean;
+    c?: boolean;
+    /** Link href. */
+    a?: string;
+    /** Mention: a page id (rendered as a live page chip). */
+    m?: string;
+    /** Text colour — a palette token (see `colors.ts`). */
+    tc?: string;
+    /** Highlight colour — a palette token. */
+    hl?: string;
+}
+/** One run of a block's rich text in the JSON projection. */
+export interface TextRun {
+    t: string;
+    a?: InlineAttrs;
+}
+/** The JSON projection of a block (exports, server, tests). */
+export interface BlockJSON {
+    id: string;
+    type: AnyBlockType;
+    text?: TextRun[];
+    props?: Record<string, unknown>;
+    children?: BlockJSON[];
+}
+/** Block types that carry editable rich text. */
+export declare const TEXT_BLOCKS: ReadonlySet<BlockType>;
+/** Block types whose `children` hold ordinary blocks. */
+export declare const CONTAINER_BLOCKS: ReadonlySet<BlockType>;
+export type BlockMap = Y.Map<unknown>;
+/** Core types plus registered custom types (registry.tsx). */
+export type AnyBlockType = BlockType | (string & {});
+export interface NewBlock {
+    type: AnyBlockType;
+    text?: string | TextRun[];
+    props?: Record<string, unknown>;
+    children?: NewBlock[];
+    id?: string;
+}
+/** Build a detached block Y.Map (insert it into an array before editing). */
+export declare function makeBlock(input: NewBlock): BlockMap;
+/**
+ * Coerce an untrusted plain object (e.g. from an AI `append_blocks` proposal)
+ * into a {@link NewBlock}, recursing into `children`. Returns null for anything
+ * that isn't a usable block. Keeps {@link makeBlock} fed only well-formed input
+ * so a malformed model response can't corrupt the document — and unlike the old
+ * flat `{type, text}` handling, it preserves rich-text runs, props, and nested
+ * children, so the agent can build interactive kit inputs and layouts.
+ */
+export declare function coerceNewBlock(value: unknown): NewBlock | null;
+/** A fresh empty document (one empty paragraph, like a new page). */
+export declare function createDoc(blocks?: NewBlock[]): Y.Doc;
+export declare function rootBlocks(doc: Y.Doc): Y.Array<BlockMap>;
+/**
+ * A doc seeded *deterministically*: the seed content is written by a fixed
+ * replica (clientID 1) with caller-supplied block ids, so every client that
+ * seeds the same template produces byte-identical CRDT state. Two tabs that
+ * race to initialize then merge into ONE copy of the content instead of two.
+ * Blocks without explicit ids would defeat the purpose — they get stable ids
+ * derived from their position instead of random ones.
+ */
+export declare function createSeededDoc(blocks: NewBlock[], seedTag?: string): Y.Doc;
+export declare const blockId: (b: BlockMap) => string;
+export declare const blockType: (b: BlockMap) => BlockType;
+export declare const blockText: (b: BlockMap) => Y.Text | undefined;
+export declare const blockChildren: (b: BlockMap) => Y.Array<BlockMap> | undefined;
+/**
+ * Rewrite a Y.Text to `next` with a MINIMAL splice: the shared leading prefix
+ * and trailing suffix are left untouched, so only the changed middle is deleted
+ * and reinserted. Better for cursors, collaboration, and inline formatting on
+ * the unchanged ends than a full delete-all + reinsert.
+ */
+export declare function replaceText(text: Y.Text, next: string): void;
+export declare function blockProp<T>(b: BlockMap, key: string): T | undefined;
+export declare function setBlockProp(b: BlockMap, key: string, value: unknown): void;
+/** Depth-first walk over every block in the tree. */
+export declare function walkBlocks(list: Y.Array<BlockMap>): Generator<{
+    block: BlockMap;
+    parent: Y.Array<BlockMap>;
+    index: number;
+}>;
+/** Locate a block (and its parent array + index) by id anywhere in the doc. */
+export declare function findBlock(doc: Y.Doc, id: string): {
+    block: BlockMap;
+    parent: Y.Array<BlockMap>;
+    index: number;
+} | null;
+/** Deep-clone a block into a fresh detached Y.Map (same ids). */
+export declare function cloneBlock(b: BlockMap, freshIds?: boolean): BlockMap;
+export declare function insertBlock(doc: Y.Doc, parent: Y.Array<BlockMap>, index: number, input: NewBlock): string;
+export declare function removeBlock(doc: Y.Doc, id: string): void;
+/**
+ * Move a block to `toIndex` of the array identified by `targetParentId`
+ * (`null` = the root list). Clones under the hood (Yjs re-parent rule);
+ * `toIndex` is interpreted against the array *without* the moved block.
+ */
+export declare function moveBlock(doc: Y.Doc, id: string, targetParentId: string | null, toIndex: number): void;
+/** Split a text block at `offset`: the tail (text + attrs) becomes a new block below. */
+export declare function splitBlock(doc: Y.Doc, id: string, offset: number, newType?: BlockType): string | null;
+/**
+ * Merge a text block into the previous text block (Backspace at offset 0).
+ * Returns the previous block's id and its pre-merge length (caret target).
+ */
+export declare function mergeWithPrevious(doc: Y.Doc, id: string): {
+    id: string;
+    offset: number;
+} | null;
+/** Change a block's type in place (keeps text); optional props patch. */
+export declare function turnInto(doc: Y.Doc, id: string, type: BlockType, props?: Record<string, unknown>): void;
+/**
+ * Apply an optional `{type, props}` patch to a block IN PLACE — call from inside
+ * a transaction. Like {@link turnInto} but the type is optional (props-only
+ * updates keep the type) and there's no own transaction, so the agent bridge can
+ * fold it into its single 'local' transaction. Turning into a text block adds an
+ * empty Y.Text when missing.
+ */
+export declare function patchBlock(block: BlockMap, patch: {
+    type?: string;
+    props?: Record<string, unknown>;
+}): void;
+/** Most columns a layout can hold (a 12-unit grid stays legible up to six). */
+export declare const MAX_COLUMNS = 6;
+/**
+ * Make a columns layout: wraps `targetId` and the moved block `movedId`
+ * side-by-side (moved goes left when `side === 'left'`). If `targetId` is
+ * already a column's child, the moved block becomes a new adjacent column
+ * instead (2 → 3 → … columns by dropping beside, up to {@link MAX_COLUMNS}).
+ */
+export declare function dropBeside(doc: Y.Doc, movedId: string, targetId: string, side: 'left' | 'right'): void;
+/** The block whose `children` array is `arr`, or null for the root list. */
+export declare function parentBlockOf(doc: Y.Doc, arr: Y.Array<BlockMap>): BlockMap | null;
+/** Drop empty columns; unwrap single-column layouts; drop empty layouts. */
+export declare function pruneEmptyContainers(doc: Y.Doc): void;
+/** A document never renders empty — keep one paragraph to type into. */
+export declare function ensureNotEmpty(doc: Y.Doc): void;
+export declare function makeTable(rows: number, cols: number): NewBlock;
+/** Insert a row at `rowIndex` (clamped); matches the table's column count. */
+export declare function tableInsertRow(doc: Y.Doc, tableId: string, rowIndex: number): void;
+export declare function tableInsertColumn(doc: Y.Doc, tableId: string, colIndex: number): void;
+export declare function tableDeleteRow(doc: Y.Doc, tableId: string, rowIndex: number): void;
+export declare function tableDeleteColumn(doc: Y.Doc, tableId: string, colIndex: number): void;
+/**
+ * Locate a cell within its table: row/column indices plus the table block.
+ * Powers cell navigation (Tab/Enter) — cells are blocks, but movement inside
+ * a table is grid-shaped, not list-shaped.
+ */
+export declare function cellPosition(doc: Y.Doc, cellId: string): {
+    table: BlockMap;
+    row: number;
+    col: number;
+    rows: number;
+    cols: number;
+} | null;
+/**
+ * The neighbouring cell id for grid navigation. `next`/`prev` move within
+ * the row and wrap across rows; `down`/`up` move within the column. Returns
+ * null at the table's edge (callers may grow the table and retry).
+ */
+export declare function cellNeighbor(doc: Y.Doc, cellId: string, dir: 'next' | 'prev' | 'down' | 'up'): string | null;
+export declare function blockToJSON(b: BlockMap): BlockJSON;
+export declare function docToJSON(doc: Y.Doc): BlockJSON[];
+/** The plain concatenated text of a block (search, summaries). */
+export declare function blockPlainText(b: BlockMap): string;
+/** Persisted form inside a page snapshot. */
+export interface BlockDocSnapshot {
+    v: 1;
+    /** Base64 Y update — the CRDT state vector clients merge from. */
+    update: string;
+    /** Plain JSON projection — exports / server / non-CRDT readers. */
+    blocks: BlockJSON[];
+}
+export declare function encodeSnapshot(doc: Y.Doc): BlockDocSnapshot;
+/** Rebuild a Y.Doc from a snapshot (falls back to the JSON projection). */
+export declare function decodeSnapshot(snapshot: BlockDocSnapshot | undefined | null): Y.Doc;
+interface EditorJsBlock {
+    id?: string;
+    type: string;
+    data: Record<string, unknown>;
+}
+/** Strip an EditorJS HTML string into rich runs (b/i/code/links survive). */
+export declare function htmlToRuns(html: string): TextRun[];
+/**
+ * Parse clipboard/external HTML into blocks: top-level block elements map to
+ * block types, inline markup folds into rich runs (via {@link htmlToRuns}),
+ * lists flatten to one block per item, tables come across whole. Anything
+ * unrecognized degrades to a paragraph with its text — never dropped.
+ */
+export declare function htmlToBlocks(html: string): NewBlock[];
+/** Reactive context for migration: cell values + the name index, straight
+ *  from the page snapshot (`values` / `names`). */
+export interface MigrationContext {
+    values?: Array<[string, unknown]>;
+    names?: Array<[string, string]>;
+    /** Page titles by id — gives subpage/database mentions their real names. */
+    pageLabels?: Map<string, string>;
+}
+/**
+ * One-way migration of an EditorJS document into the block model. Every block
+ * type the app ships maps to something — reactive blocks (slider/expr) become
+ * the editor's reactive plugins, links to nested pages survive as mention
+ * runs, derived blocks (toc) are skipped, and the rest degrade to readable
+ * text. Nothing is lost silently — the original snapshot stays on the page.
+ */
+export declare function migrateEditorJs(blocks: EditorJsBlock[], ctx?: MigrationContext): NewBlock[];
+export {};

package/dist/blockeditor/present.d.ts

@@ -0,0 +1,18 @@
+import * as Y from 'yjs';
+import { type BlockMap } from './model';
+/**
+ * Present mode splits a page into slides at every top-level `divider` block.
+ * Within a slide, `notes` blocks are speaker-only (shown in the presenter view,
+ * never to the audience); everything else is audience `content`.
+ */
+export interface Slide {
+    content: BlockMap[];
+    notes: BlockMap[];
+}
+/**
+ * Group a document's top-level blocks into slides at each `divider`. A
+ * divider-less doc is a single slide; leading/trailing/doubled dividers never
+ * yield an empty slide; an empty doc yields one empty slide so the deck always
+ * has something to show.
+ */
+export declare function splitSlides(doc: Y.Doc): Slide[];

package/dist/blockeditor/provider.d.ts

@@ -0,0 +1,16 @@
+import * as Y from 'yjs';
+export interface PresencePeer {
+    clientId: number;
+    name: string;
+    color: string;
+    blockId: string | null;
+    at: number;
+}
+export interface BroadcastConnection {
+    disconnect(): void;
+    /** Update this client's presence (focused block). */
+    setPresence(blockId: string | null): void;
+    /** Subscribe to the live peer list (excluding self). */
+    onPeers(cb: (peers: PresencePeer[]) => void): () => void;
+}
+export declare function connectBroadcast(doc: Y.Doc, channelName: string, userName?: string): BroadcastConnection;

package/dist/blockeditor/reactiveBlocks.d.ts

@@ -0,0 +1,2 @@
+/** Register the built-in reactive blocks (idempotent enough for app startup). */
+export declare function registerReactiveBlocks(): void;

package/dist/blockeditor/registry.d.ts

@@ -0,0 +1,38 @@
+import type React from 'react';
+import type { BlockMap, NewBlock } from './model';
+import type { BlockEditorController } from './useBlockEditor';
+/**
+ * The custom-block extension point. Anything the core editor doesn't know
+ * (reactive widgets, embeds, app-specific views) registers here: a renderer
+ * keyed by block `type`, optionally with a slash-menu entry. The registry is
+ * a module-level singleton — same pattern as the app's pageLinks bridge — so
+ * registration works from any layer without threading React context.
+ *
+ * Custom blocks receive the raw block Y.Map and the editor controller; they
+ * own their props via `blockProp`/`setBlockProp` (CRDT-synced like
+ * everything else) and are rendered inside the standard row (gutter, drag,
+ * selection all behave normally).
+ */
+export interface CustomBlockProps {
+    block: BlockMap;
+    editor: BlockEditorController;
+}
+export interface CustomBlockDef {
+    /** The block `type` this renders (must not collide with core types). */
+    type: string;
+    render: React.FC<CustomBlockProps>;
+    /** Optional slash-menu entry that inserts this block. */
+    slash?: {
+        label: string;
+        hint: string;
+        keywords: string;
+        make: () => NewBlock;
+        /** Slash-menu category. Built-ins set `interactive`; third-party blocks
+         *  default to `extensions`. */
+        group?: 'interactive' | 'extensions';
+    };
+}
+export declare function registerCustomBlock(def: CustomBlockDef): () => void;
+export declare const getCustomBlock: (type: string) => CustomBlockDef | undefined;
+export declare const customSlashItems: () => CustomBlockDef[];
+export declare const subscribeRegistry: (cb: () => void) => (() => void);