@inkami/blx 0.17.3

package/dist/inline-toolbar/link-popover.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Small floating input for entering/editing link URLs.
+ * Displayed below the inline toolbar or selection.
+ */
+export declare class LinkPopover {
+    private popover;
+    private input;
+    private applyBtn;
+    private removeBtn;
+    private onApply;
+    private onRemove;
+    private onClose;
+    constructor(onApply: (url: string) => void, onRemove: () => void, onClose: () => void);
+    get element(): HTMLElement;
+    get visible(): boolean;
+    /**
+     * Show the popover at a position relative to a given rect.
+     * Pre-fills the URL if editing an existing link.
+     */
+    show(anchorRect: DOMRect, existingUrl?: string): void;
+    hide(): void;
+    destroy(): void;
+    private submit;
+}

package/dist/keybindings/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { KeybindingMap } from "./types";
+export declare const DEFAULT_KEYBINDINGS: KeybindingMap;

package/dist/keybindings/index.d.ts

@@ -0,0 +1,4 @@
+export type { KeyDescriptor, KeybindingMap } from "./types";
+export { eventToDescriptor, KeySequencer } from "./key-matcher";
+export { DEFAULT_KEYBINDINGS } from "./defaults";
+export { VIM_KEYBINDINGS } from "./vim";

package/dist/keybindings/key-matcher.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Convert a KeyboardEvent into a canonical descriptor string.
+ *
+ * Modifiers are prepended in order: ctrl+meta+alt+shift+key
+ *
+ * For single-char keys (e.key.length === 1): shift is implicit in the
+ * character casing ("G" not "shift+G"), so shift is not prepended.
+ *
+ * For non-char keys (ArrowDown, Home, Tab, etc.): shift is included
+ * when held.
+ */
+export declare function eventToDescriptor(e: KeyboardEvent): string;
+/**
+ * Handles multi-key sequences of arbitrary length (e.g. "g,g", "d,d",
+ * " ,g,a") and single-key lookups against a keybinding map.
+ *
+ * `resolve()` returns:
+ * - An action name string when matched
+ * - `"pending"` when waiting for the next key in a sequence
+ * - `null` when no match is found
+ *
+ * When an accumulated buffer has both an exact match AND is the prefix of
+ * a longer sequence, the sequencer returns "pending" and waits. If the
+ * timeout fires before the next key, the `onFallback` callback is invoked
+ * with the shorter match's action name.
+ */
+export declare class KeySequencer {
+    private buffer;
+    private timer;
+    private sequenceTimeout;
+    /**
+     * Resolve a key descriptor against a binding map.
+     *
+     * @param onFallback — called when a pending sequence times out and had
+     *   a shorter exact action. The caller should execute the action.
+     */
+    resolve(descriptor: string, bindings: Record<string, string>, onFallback?: (action: string) => void): string | "pending" | null;
+    private clearTimer;
+    private clearPending;
+    destroy(): void;
+}

package/dist/keybindings/types.d.ts

@@ -0,0 +1,6 @@
+/** Key descriptor string, e.g. "shift+ArrowDown", "j", "G", "g,g" (sequence) */
+export type KeyDescriptor = string;
+export interface KeybindingMap {
+    normal: Record<KeyDescriptor, string>;
+    visualBlock: Record<KeyDescriptor, string>;
+}

package/dist/keybindings/vim.d.ts

@@ -0,0 +1,2 @@
+import type { KeybindingMap } from "./types";
+export declare const VIM_KEYBINDINGS: KeybindingMap;

package/dist/markdown/block-shortcuts.d.ts

@@ -0,0 +1,35 @@
+import type { BlockShortcutMatch } from "./types";
+/**
+ * Match a block shortcut pattern without checking the trigger character.
+ *
+ * Matches:
+ * - `#` → h1, `##` → h2, `###` → h3, `####` → h4
+ * - `-`, `*`, `+` → unordered list
+ * - `1.`, `1)` → ordered list
+ * - `[a-zA-Z][.)]` → ordered list (lettered)
+ * - `` ``` `` or `` ```lang `` → code block
+ * - `---` → horizontal rule
+ * - `>` → blockquote
+ */
+export declare function matchBlockShortcutPattern(prefix: string): BlockShortcutMatch | null;
+/**
+ * Detect a block-level markdown shortcut being completed by a space.
+ *
+ * Called BEFORE the character is inserted. Fires when:
+ * - `charBeingTyped === " "`
+ * - The text before the cursor matches a block shortcut pattern
+ *
+ * Works both on empty blocks (cursor at end) and blocks with existing
+ * text (e.g. typing `# ` at the beginning of "Hello" → heading).
+ */
+export declare function detectBlockShortcut(existingText: string, cursorOffset: number, charBeingTyped: string): BlockShortcutMatch | null;
+/**
+ * Detect a block shortcut that fires immediately when the pattern is complete
+ * and unambiguous (no possible extensions exist).
+ *
+ * Currently only `---` → horizontal rule qualifies: no `----` pattern exists,
+ * so the third dash completes the pattern.
+ *
+ * Called BEFORE the character is inserted.
+ */
+export declare function detectImmediateBlockShortcut(existingText: string, cursorOffset: number, charBeingTyped: string): BlockShortcutMatch | null;

package/dist/markdown/emoticon-substitutions.d.ts

@@ -0,0 +1,22 @@
+/** Map of emoticon text patterns to their emoji replacements */
+export declare const EMOTICON_MAP: Record<string, string>;
+export interface EmoticonMatch {
+    /** The emoji character to insert */
+    emoji: string;
+    /** Start offset in existingText where the emoticon prefix begins */
+    start: number;
+    /** End offset in existingText (exclusive) — the cursor position */
+    end: number;
+}
+/**
+ * Detect an emoticon being completed by the character about to be typed.
+ *
+ * Called BEFORE the character is inserted into the content (same convention
+ * as `detectInlineShortcut`). Builds a candidate string from the last
+ * N characters of `existingText` (up to `cursorOffset`) plus `charBeingTyped`,
+ * then checks longest-first against the emoticon map.
+ *
+ * Safety: only triggers when the emoticon is preceded by whitespace or
+ * is at the start of text, to avoid false positives like `http:/`.
+ */
+export declare function detectEmoticon(existingText: string, cursorOffset: number, charBeingTyped: string): EmoticonMatch | null;

package/dist/markdown/export.d.ts

@@ -0,0 +1,5 @@
+import type { BlockJSON } from "../types";
+/**
+ * Convert an array of editor blocks to a Markdown string.
+ */
+export declare function blocksToMarkdown(blocks: BlockJSON[]): string;

package/dist/markdown/index.d.ts

@@ -0,0 +1,4 @@
+export { detectInlineShortcut } from "./inline-shortcuts";
+export { detectBlockShortcut } from "./block-shortcuts";
+export { blocksToMarkdown } from "./export";
+export type { InlineShortcutMatch, BlockShortcutMatch } from "./types";

package/dist/markdown/inline-shortcuts.d.ts

@@ -0,0 +1,13 @@
+import type { InlineShortcutMatch } from "./types";
+/**
+ * Detect an inline markdown shortcut being completed.
+ *
+ * Called BEFORE the character is inserted into the content.
+ * Scans backward for a matching opening marker:
+ * - `charBeingTyped === "*"` + `existingText[cursorOffset-1] === "*"` → bold (`**`)
+ * - `charBeingTyped === "_"` → italic (`_`)
+ * - `charBeingTyped === "\`"` → code (`` ` ``)
+ *
+ * There must be at least 1 character between the markers.
+ */
+export declare function detectInlineShortcut(existingText: string, cursorOffset: number, charBeingTyped: string): InlineShortcutMatch | null;

package/dist/markdown/types.d.ts

@@ -0,0 +1,29 @@
+import type { Attributes } from "../attributed-string";
+/** Result of detecting an inline markdown shortcut (bold, italic, code, link) */
+export interface InlineShortcutMatch {
+    /** The kind of shortcut detected */
+    kind: "bold" | "italic" | "code" | "strikethrough" | "link";
+    /** The attribute(s) to apply to the matched content */
+    attribute: Attributes;
+    /** Offset into existingText where the opening marker starts */
+    openMarkerStart: number;
+    /** Offset into existingText where the opening marker ends (exclusive) */
+    openMarkerEnd: number;
+    /** Offset into existingText where the content starts */
+    contentStart: number;
+    /** Offset into existingText where the content ends (exclusive) */
+    contentEnd: number;
+    /** Offset into existingText where the close marker ends (exclusive, includes the char being typed) */
+    closeMarkerEnd: number;
+}
+/** Result of detecting a block-level markdown shortcut (heading, list) */
+export interface BlockShortcutMatch {
+    /** The kind of shortcut detected */
+    kind: "heading" | "unordered-list" | "ordered-list" | "checklist" | "code-block" | "horizontal-rule" | "blockquote";
+    /** The new block type to convert to */
+    newType: string;
+    /** Metadata for the new block type */
+    metadata: Record<string, unknown>;
+    /** Length of the prefix (including the space being typed) */
+    prefixLength: number;
+}

package/dist/plugins/blockquote.d.ts

@@ -0,0 +1,6 @@
+import type { BlockTypePlugin } from "../schema";
+export interface BlockquoteMetadata {
+    [key: string]: unknown;
+    dir?: "ltr" | "rtl" | "auto";
+}
+export declare const blockquotePlugin: BlockTypePlugin<BlockquoteMetadata>;

package/dist/plugins/checklist.d.ts

@@ -0,0 +1,18 @@
+import type { BlockTypePlugin } from "../schema";
+export interface ChecklistMetadata {
+    [key: string]: unknown;
+    checked: boolean;
+    dueDate?: string;
+    scheduledDate?: string;
+    eventDate?: string;
+    recurrence?: {
+        interval: number;
+        unit: "day" | "week" | "month" | "year";
+        anchor?: string;
+        fromCompletion?: boolean;
+    };
+    /** @deprecated — migrated to dueDate/scheduledDate/eventDate by deserializeMetadata */
+    agendaDate?: string;
+    dir?: "ltr" | "rtl" | "auto";
+}
+export declare const checklistPlugin: BlockTypePlugin<ChecklistMetadata>;

package/dist/plugins/code.d.ts

@@ -0,0 +1,50 @@
+import type { BlockTypePlugin } from "../schema";
+export interface CodeBlockMetadata {
+    [key: string]: unknown;
+    language: string;
+    agendaDate?: string;
+}
+export declare const CODE_LANGUAGES: readonly [{
+    readonly id: "plain";
+    readonly label: "Plain Text";
+}, {
+    readonly id: "json";
+    readonly label: "JSON";
+}, {
+    readonly id: "javascript";
+    readonly label: "JavaScript";
+}, {
+    readonly id: "typescript";
+    readonly label: "TypeScript";
+}, {
+    readonly id: "html";
+    readonly label: "HTML";
+}, {
+    readonly id: "css";
+    readonly label: "CSS";
+}, {
+    readonly id: "python";
+    readonly label: "Python";
+}, {
+    readonly id: "java";
+    readonly label: "Java";
+}, {
+    readonly id: "c";
+    readonly label: "C";
+}, {
+    readonly id: "cpp";
+    readonly label: "C++";
+}, {
+    readonly id: "go";
+    readonly label: "Go";
+}, {
+    readonly id: "rust";
+    readonly label: "Rust";
+}, {
+    readonly id: "sql";
+    readonly label: "SQL";
+}, {
+    readonly id: "yaml";
+    readonly label: "YAML";
+}];
+export declare const codeBlockPlugin: BlockTypePlugin<CodeBlockMetadata>;

package/dist/plugins/excalidraw.d.ts

@@ -0,0 +1,26 @@
+import type { BlockTypePlugin } from "../schema";
+export interface ExcalidrawMetadata {
+    [key: string]: unknown;
+    /** Serialized Excalidraw scene data (JSON string of { elements, appState }) */
+    sceneData: string;
+    /** Cached SVG string for preview rendering without loading Excalidraw */
+    previewSvg?: string;
+    /** Display width in pixels (null = auto) */
+    width?: number;
+}
+export declare const excalidrawPlugin: BlockTypePlugin<ExcalidrawMetadata>;
+/**
+ * Re-render an Excalidraw scene to SVG with a specific theme.
+ * Returns null if excalidraw is not available or the scene is invalid.
+ */
+export declare function renderExcalidrawSvg(sceneData: string, theme?: "light" | "dark"): Promise<string | null>;
+/**
+ * Opens the Excalidraw editor in a fullscreen modal overlay.
+ * Dynamically imports react, react-dom, and @excalidraw/excalidraw.
+ *
+ * Returns a cleanup function. Calls `onSave` with the scene data and SVG
+ * preview when the user closes the modal.
+ */
+export declare function openExcalidrawModal(sceneData: string | null, onSave: (sceneData: string, previewSvg: string) => void, onClose: () => void, options?: {
+    theme?: "light" | "dark";
+}): Promise<void>;

package/dist/plugins/heading.d.ts

@@ -0,0 +1,20 @@
+import type { BlockTypePlugin } from "../schema";
+export type TaskStatus = "todo" | "in-progress" | "done";
+export interface HeadingMetadata {
+    [key: string]: unknown;
+    level: 1 | 2 | 3 | 4;
+    taskStatus?: TaskStatus;
+    dueDate?: string;
+    scheduledDate?: string;
+    eventDate?: string;
+    recurrence?: {
+        interval: number;
+        unit: "day" | "week" | "month" | "year";
+        anchor?: string;
+        fromCompletion?: boolean;
+    };
+    /** @deprecated — migrated to dueDate/scheduledDate/eventDate by deserializeMetadata */
+    agendaDate?: string;
+    dir?: "ltr" | "rtl" | "auto";
+}
+export declare const headingPlugin: BlockTypePlugin<HeadingMetadata>;

package/dist/plugins/horizontal-rule.d.ts

@@ -0,0 +1,5 @@
+import type { BlockTypePlugin } from "../schema";
+export interface HorizontalRuleMetadata {
+    [key: string]: unknown;
+}
+export declare const horizontalRulePlugin: BlockTypePlugin<HorizontalRuleMetadata>;

package/dist/plugins/image.d.ts

@@ -0,0 +1,19 @@
+import type { BlockTypePlugin } from "../schema";
+export interface ImageMetadata {
+    [key: string]: unknown;
+    /** Image source URL, data: URI, or blob-store reference (`blxblob:…`) */
+    src: string;
+    /** Alt text for accessibility */
+    alt?: string;
+    /** Caption text */
+    caption?: string;
+    /** Display width in pixels (null = auto) */
+    width?: number;
+    /** Intrinsic image width, captured on first load. Used with naturalHeight
+     *  to set width/height attributes so the browser reserves correct aspect
+     *  ratio space before the image loads, preventing layout shift. */
+    naturalWidth?: number;
+    /** Intrinsic image height, captured on first load. */
+    naturalHeight?: number;
+}
+export declare const imagePlugin: BlockTypePlugin<ImageMetadata>;

package/dist/plugins/index.d.ts

@@ -0,0 +1,28 @@
+import type { SchemaRegistry } from "../schema";
+export { paragraphPlugin } from "./paragraph";
+export { headingPlugin } from "./heading";
+export { listPlugin } from "./list";
+export { codeBlockPlugin, CODE_LANGUAGES } from "./code";
+export { horizontalRulePlugin } from "./horizontal-rule";
+export { checklistPlugin } from "./checklist";
+export { youtubePlugin, parseYouTubeUrl } from "./youtube";
+export { imagePlugin } from "./image";
+export { tablePlugin } from "./table";
+export { blockquotePlugin } from "./blockquote";
+export { mermaidPlugin, renderMermaidSvg } from "./mermaid";
+export { excalidrawPlugin, openExcalidrawModal, renderExcalidrawSvg } from "./excalidraw";
+export { renderAttributedString, setUrlResolver, resolveUrl, getBlockDir, setBlockRefRenderCallback } from "./render-utils";
+export type { ParagraphMetadata } from "./paragraph";
+export type { HeadingMetadata, TaskStatus } from "./heading";
+export type { ListMetadata } from "./list";
+export type { CodeBlockMetadata } from "./code";
+export type { HorizontalRuleMetadata } from "./horizontal-rule";
+export type { ChecklistMetadata } from "./checklist";
+export type { YouTubeMetadata } from "./youtube";
+export type { ImageMetadata } from "./image";
+export type { TableMetadata } from "./table";
+export type { BlockquoteMetadata } from "./blockquote";
+export type { MermaidMetadata } from "./mermaid";
+export type { ExcalidrawMetadata } from "./excalidraw";
+/** Register the default set of block type plugins */
+export declare function registerDefaultPlugins(registry: SchemaRegistry): void;

package/dist/plugins/list.d.ts

@@ -0,0 +1,18 @@
+import type { BlockTypePlugin } from "../schema";
+export interface ListMetadata {
+    [key: string]: unknown;
+    ordered: boolean;
+    dueDate?: string;
+    scheduledDate?: string;
+    eventDate?: string;
+    recurrence?: {
+        interval: number;
+        unit: "day" | "week" | "month" | "year";
+        anchor?: string;
+        fromCompletion?: boolean;
+    };
+    /** @deprecated — migrated to dueDate/scheduledDate/eventDate by deserializeMetadata */
+    agendaDate?: string;
+    dir?: "ltr" | "rtl" | "auto";
+}
+export declare const listPlugin: BlockTypePlugin<ListMetadata>;

package/dist/plugins/mermaid.d.ts

@@ -0,0 +1,11 @@
+import type { BlockTypePlugin } from "../schema";
+export interface MermaidMetadata {
+    [key: string]: unknown;
+}
+/**
+ * Render mermaid source to an SVG string with a specific theme.
+ * Returns null if mermaid is not available or the source has invalid syntax.
+ * Serialized through the render queue to avoid mermaid concurrency issues.
+ */
+export declare function renderMermaidSvg(source: string, theme?: "light" | "dark"): Promise<string | null>;
+export declare const mermaidPlugin: BlockTypePlugin<MermaidMetadata>;

package/dist/plugins/paragraph.d.ts

@@ -0,0 +1,18 @@
+import type { BlockTypePlugin } from "../schema";
+export interface ParagraphMetadata {
+    [key: string]: unknown;
+    align?: "left" | "center" | "right" | "start" | "end";
+    dueDate?: string;
+    scheduledDate?: string;
+    eventDate?: string;
+    recurrence?: {
+        interval: number;
+        unit: "day" | "week" | "month" | "year";
+        anchor?: string;
+        fromCompletion?: boolean;
+    };
+    /** @deprecated — migrated to dueDate/scheduledDate/eventDate by deserializeMetadata */
+    agendaDate?: string;
+    dir?: "ltr" | "rtl" | "auto";
+}
+export declare const paragraphPlugin: BlockTypePlugin<ParagraphMetadata>;

package/dist/plugins/prism-loader.d.ts

@@ -0,0 +1,16 @@
+import Prism from "prismjs";
+import "prismjs/components/prism-markup";
+import "prismjs/components/prism-css";
+import "prismjs/components/prism-clike";
+import "prismjs/components/prism-javascript";
+import "prismjs/components/prism-typescript";
+import "prismjs/components/prism-python";
+import "prismjs/components/prism-java";
+import "prismjs/components/prism-c";
+import "prismjs/components/prism-cpp";
+import "prismjs/components/prism-go";
+import "prismjs/components/prism-rust";
+import "prismjs/components/prism-sql";
+import "prismjs/components/prism-yaml";
+import "prismjs/components/prism-json";
+export { Prism };

package/dist/plugins/render-utils.d.ts

@@ -0,0 +1,43 @@
+import type { AttributedString } from "../attributed-string";
+/**
+ * Override the URL resolver used when rendering link elements.
+ * The resolver receives the raw `href` string from the content model
+ * and should return a fully-qualified URL for the `<a>` element.
+ *
+ * Pass `undefined` to reset to the default resolver.
+ */
+export declare function setUrlResolver(resolver: ((url: string) => string) | undefined): void;
+/** Resolve a URL using the configured resolver. */
+export declare function resolveUrl(url: string): string;
+/**
+ * Set a callback that is invoked after each blockRef span is rendered.
+ * Use it to add CSS classes or data attributes for app-specific styling
+ * (e.g. broken-link indicators).
+ *
+ * Pass `undefined` to clear the callback.
+ */
+export declare function setBlockRefRenderCallback(cb: ((element: HTMLElement, refId: string) => void) | undefined): void;
+/**
+ * Returns the `dir` attribute value for a block's contenteditable element.
+ * Defaults to "auto" which lets the browser's Unicode Bidi Algorithm detect
+ * text direction from the first strong character.
+ */
+export declare function getBlockDir(metadata: Record<string, unknown>): string;
+/**
+ * Toggle the empty state class and placeholder attribute on an element.
+ * When the content is empty, adds `blx-empty` class and sets `data-placeholder`.
+ * When non-empty, removes both.
+ */
+export declare function updateEmptyState(el: HTMLElement, content: AttributedString, placeholder?: string): void;
+/**
+ * Check whether the block is rendered inside a read-only context.
+ * Returns true when the nearest editor root (or any ancestor) has the
+ * `.blx-readonly` or `.blx-replay-mode` CSS class.
+ */
+export declare function isBlockReadOnly(container: HTMLElement): boolean;
+/**
+ * Render an AttributedString into a target element.
+ * Clears existing content and creates inline spans for each attributed span.
+ * Emoji characters render natively via the platform's emoji font.
+ */
+export declare function renderAttributedString(target: HTMLElement, content: AttributedString): void;

package/dist/plugins/table.d.ts

@@ -0,0 +1,22 @@
+import { AttributedString } from "../attributed-string";
+import type { BlockTypePlugin } from "../schema";
+export interface TableMetadata {
+    [key: string]: unknown;
+    /** Header row cells (one AttributedString per column) */
+    header: AttributedString[];
+    /** Body rows (each row is one AttributedString per column) */
+    rows: AttributedString[][];
+    /** Column alignments: "left" | "center" | "right" | "none" */
+    columnAlignments?: string[];
+    /** Column widths as percentages */
+    columnWidths?: number[];
+}
+/** Unified selection state for the table */
+export interface TableSelection {
+    type: "rect" | "row" | "col";
+    anchorRow: number;
+    anchorCol: number;
+    focusRow: number;
+    focusCol: number;
+}
+export declare const tablePlugin: BlockTypePlugin<TableMetadata>;

package/dist/plugins/youtube.d.ts

@@ -0,0 +1,21 @@
+import type { BlockTypePlugin } from "../schema";
+export interface YouTubeMetadata {
+    [key: string]: unknown;
+    videoId: string;
+    startTime?: number;
+}
+/**
+ * Extract a YouTube video ID from various URL formats:
+ * - https://www.youtube.com/watch?v=VIDEO_ID
+ * - https://youtu.be/VIDEO_ID
+ * - https://www.youtube.com/embed/VIDEO_ID
+ * - https://youtube.com/shorts/VIDEO_ID
+ * - https://www.youtube-nocookie.com/embed/VIDEO_ID
+ *
+ * Returns `{ videoId, startTime? }` or `null` if no match.
+ */
+export declare function parseYouTubeUrl(raw: string): {
+    videoId: string;
+    startTime?: number;
+} | null;
+export declare const youtubePlugin: BlockTypePlugin<YouTubeMetadata>;

package/dist/schema/index.d.ts

@@ -0,0 +1,2 @@
+export { SchemaRegistry } from "./schema-registry";
+export type { BlockTypePlugin, BlockMetadata, ConversionTarget } from "./types";

package/dist/schema/schema-registry.d.ts

@@ -0,0 +1,35 @@
+import type { BlockTypePlugin, BlockMetadata, ConversionTarget } from "./types";
+import type { BlockJSON } from "../types";
+/**
+ * Registry for block type plugins.
+ */
+export declare class SchemaRegistry {
+    private plugins;
+    private aliases;
+    register(plugin: BlockTypePlugin<BlockMetadata>): void;
+    unregister(type: string): boolean;
+    /**
+     * Register an alias so that old/renamed block types resolve to a current plugin.
+     * When blocks are loaded with `oldType`, they will be treated as `newType`.
+     */
+    registerAlias(oldType: string, newType: string): void;
+    get(type: string): BlockTypePlugin | undefined;
+    has(type: string): boolean;
+    /**
+     * Resolve a block type through aliases. Returns the canonical type name.
+     */
+    resolveType(type: string): string;
+    /**
+     * Migrate an array of block JSON objects, rewriting any aliased types
+     * to their canonical names. Returns true if any blocks were modified.
+     */
+    migrateBlocks(blocks: BlockJSON[]): boolean;
+    getAll(): ReadonlyArray<BlockTypePlugin>;
+    getTypes(): ReadonlyArray<string>;
+    /**
+     * Get the conversion targets for a given block type.
+     * If the plugin defines `convertibleTo()`, use that.
+     * Otherwise, build a default list from all registered text-content plugins.
+     */
+    getConversionTargets(type: string): ConversionTarget[];
+}

package/dist/schema/types.d.ts

@@ -0,0 +1,67 @@
+import type { AttributedString } from "../attributed-string";
+/** Metadata can be any serializable record */
+export interface BlockMetadata {
+    [key: string]: unknown;
+}
+/** Describes a block type that this block can be converted to */
+export interface ConversionTarget {
+    /** Target block type */
+    type: string;
+    /** Display label (e.g. "Heading 2") */
+    label: string;
+    /** Description shown in Turn Into menu */
+    description?: string;
+    /** Metadata for the target block type */
+    metadata?: Record<string, unknown>;
+    /** Keyboard shortcut hint (e.g. "Ctrl+Shift+2") */
+    shortcutHint?: string;
+}
+/**
+ * Plugin that defines how a block type behaves and renders.
+ */
+export interface BlockTypePlugin<M extends BlockMetadata = BlockMetadata> {
+    /** Unique type identifier, e.g. "paragraph", "heading" */
+    readonly type: string;
+    /** Human-readable label */
+    readonly label: string;
+    /** Whether this block type has editable text content */
+    readonly hasTextContent: boolean;
+    /** Create default content for a new block of this type */
+    defaultContent(): AttributedString;
+    /** Create default metadata for a new block of this type */
+    defaultMetadata(): M;
+    /**
+     * Render the block into the container.
+     * Returns the contenteditable element (if hasTextContent), or null.
+     */
+    render(container: HTMLElement, content: AttributedString, metadata: M): HTMLElement | null;
+    /**
+     * Update an existing render without full re-render (optional optimization).
+     */
+    update?(container: HTMLElement, contentEditable: HTMLElement | null, content: AttributedString, metadata: M): void;
+    /** Serialize metadata to JSON-safe form */
+    serializeMetadata?(metadata: M): Record<string, unknown>;
+    /** Deserialize metadata from JSON */
+    deserializeMetadata?(raw: Record<string, unknown>): M;
+    /** Attribute keys allowed for this block type. null = all allowed. */
+    allowedAttributes?: string[] | null;
+    /** If true, block cannot be moved, deleted, or reordered. */
+    immovable?: boolean;
+    /** If true, block cannot be converted to another type. */
+    inconvertible?: boolean;
+    /** Whether this block type supports nesting via indent/outdent (Tab/Shift+Tab). Defaults to true. */
+    indentable?: boolean;
+    /** Whether Tab inserts literal spaces instead of indenting (e.g. code blocks). Only applies when indentable is false. */
+    tabInsertsSpaces?: boolean;
+    /**
+     * What block types this block can be converted to.
+     * Return an empty array to prevent conversion.
+     * If not defined, the schema registry builds a default list from all text-content plugins.
+     */
+    convertibleTo?(): ConversionTarget[];
+    /**
+     * Build metadata when converting TO this type from another.
+     * Falls back to defaultMetadata() if not defined.
+     */
+    metadataFromConversion?(fromType: string, fromMetadata: BlockMetadata): M;
+}