xiaodao-editor 0.1.1

package/dist/core/Editor.d.ts

@@ -0,0 +1,83 @@
+import { BlockId, DocumentData, Selection } from './types';
+import { EditorState } from './state/EditorState';
+import { Transaction } from './state/Transaction';
+import { EditorRegistries } from './extension/Registry';
+import { Extension } from './extension/Extension';
+export interface EditorConfig {
+    readonly extensions: readonly Extension[];
+    readonly defaultBlockType?: string;
+    readonly initialDocument?: DocumentData;
+    readonly initialSelection?: Selection;
+    readonly editable?: boolean;
+    readonly historyLimit?: number;
+}
+export interface StateUpdate {
+    readonly state: EditorState;
+    readonly changed: ReadonlySet<BlockId>;
+    readonly removed: ReadonlySet<BlockId>;
+}
+export type EditorListener = (update: StateUpdate) => void;
+/** Public read-only history API exposed by the Editor facade. */
+export interface EditorHistory {
+    /** True if an undo entry exists. */
+    canUndo(): boolean;
+    /** True if a redo entry exists. */
+    canRedo(): boolean;
+    /**
+     * Open an explicit grouping scope. Any `dispatch` between `beginGroup()` and
+     * the matching `endGroup()` merges into one undo entry. Scopes nest; only
+     * the outermost close "commits". Prefer this over using the
+     * `meta.historyGroup` key manually.
+     */
+    beginGroup(): string;
+    /** Close an explicit grouping scope opened by `beginGroup()`. */
+    endGroup(): void;
+}
+export declare class Editor {
+    readonly registries: EditorRegistries;
+    private state;
+    private readonly listeners;
+    private readonly _history;
+    readonly commands: Record<string, (...args: unknown[]) => boolean>;
+    editable: boolean;
+    /** The block id currently owning the focused contenteditable (set by the view). */
+    focusBlockId: BlockId | null;
+    /** Public history API: canUndo/canRedo plus grouping helpers. */
+    readonly history: EditorHistory;
+    constructor(config: EditorConfig);
+    getState(): EditorState;
+    toData(): DocumentData;
+    /**
+     * Export the current document as a Markdown string. Serializes the editor's
+     * own live document state directly (see `docToMarkdown` below); no external
+     * converter or intermediate re-serialization is involved.
+     */
+    toMarkdown(): string;
+    /**
+     * Replace the whole document by parsing a Markdown string. Resets history.
+     * The Markdown is parsed natively by the editor (see `markdownToDoc` below)
+     * straight into its document state; no external converter and no
+     * intermediate `DocumentData` round-trip is involved.
+     */
+    setDocFromMarkdown(markdown: string): void;
+    /** Replace the whole document (e.g. on external `v-model` change). Resets history. */
+    setDocument(json: DocumentData): void;
+    /** Take ownership of a normalized document and reset the editor state. */
+    private adoptDoc;
+    dispatch(tr: Transaction): void;
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    subscribe(listener: EditorListener): () => void;
+    private notify;
+    private eventContext;
+    handleKeyDown(event: KeyboardEvent): boolean;
+    handleInput(event: InputEvent): boolean;
+    handleCompositionStart(event: CompositionEvent): void;
+    handleCompositionEnd(event: CompositionEvent): void;
+    destroy(): void;
+    private seedEmptyDocument;
+}
+/** Validate that a block id exists in the current state (debugging helper). */
+export declare function hasBlock(editor: Editor, id: BlockId): boolean;

package/dist/core/command/Command.d.ts

@@ -0,0 +1,32 @@
+import { EditorState } from '../state/EditorState';
+import { Transaction } from '../state/Transaction';
+export type Dispatch = (tr: Transaction) => void;
+export type CommandFn<TArgs = void> = (args: TArgs) => (state: EditorState, dispatch?: Dispatch) => boolean;
+export interface CommandEntry<TArgs = void> {
+    readonly name: string;
+    readonly run: CommandFn<TArgs>;
+}
+/** A command contributed by an extension. */
+export type CommandSpec<TArgs = void> = CommandEntry<TArgs>;
+/**
+ * A command entry with type-erased arguments, as stored in the registry.
+ * The registry is fundamentally heterogeneous (each command has its own arg
+ * type), so the arg type is erased at registration. Type safety is preserved
+ * at definition sites (`CommandEntry<YourArgs>`) and at typed command proxies.
+ */
+export type AnyCommandEntry = CommandEntry<any>;
+/** Resolves a command name + args to a boolean (handled?), given live state. */
+export type CommandDispatcher = (name: string, args: unknown) => boolean;
+export declare class CommandRegistry {
+    private readonly entries;
+    register(spec: AnyCommandEntry): void;
+    /** Replace an existing command (used so extensions can override primitives). */
+    override(spec: AnyCommandEntry): void;
+    has(name: string): boolean;
+    get(name: string): AnyCommandEntry | undefined;
+    /**
+     * Build a proxy so callers can write `editor.commands.insertBlock({...})`.
+     * Each property access returns a function that dispatches the named command.
+     */
+    createProxy(dispatch: CommandDispatcher): Record<string, (...args: unknown[]) => boolean>;
+}

package/dist/core/command/InputRule.d.ts

@@ -0,0 +1,21 @@
+import { BlockId } from '../types';
+export interface InputRuleContext {
+    readonly blockId: BlockId;
+    /** Full block text up to and including the just-typed character. */
+    readonly textBeforeCaret: string;
+}
+export interface InputRuleSpec {
+    readonly name: string;
+    /** Tested against `textBeforeCaret`. Must be anchored (e.g. /^# $/). */
+    readonly pattern: RegExp;
+    /** Command to dispatch when the pattern matches. */
+    readonly command: string;
+    /** Build command args from the match (optional). */
+    readonly args?: (match: RegExpExecArray) => unknown;
+}
+export type InputRule = InputRuleSpec;
+export declare class InputRuleRegistry {
+    private readonly rules;
+    register(spec: InputRuleSpec): void;
+    get all(): readonly InputRule[];
+}

package/dist/core/command/Keymap.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Keymap: binds normalized keyboard shortcuts to commands. Bindings are
+ * ordered by priority; the first match wins and a handler returning `true`
+ * stops propagation. Key names follow ProseMirror conventions
+ * (e.g. "Mod-Enter", "Shift-ArrowUp", "Backspace").
+ *
+ * See docs/editor-architecture.md §11.1.
+ */
+export interface KeymapBinding {
+    /** Normalized key, e.g. "Enter", "Shift-Tab", "Mod-B", "ArrowUp". */
+    readonly key: string;
+    /** Command name to dispatch when the key matches. */
+    readonly command: string;
+    /** Args passed to the command. */
+    readonly args?: unknown;
+    /** Lower numbers run first. Default 0. */
+    readonly priority?: number;
+}
+export type KeymapSpec = readonly KeymapBinding[];
+/**
+ * Derive a normalized key name from a keyboard event. Produces the *actual*
+ * platform modifier (Ctrl or Cmd), not a generic "Mod" token. Binding keys
+ * use "Mod" as a placeholder; `keyMatches` resolves it to the same actual
+ * modifier before comparing.
+ *
+ * Example: Cmd+Shift+Z on Mac → "Cmd-Shift-Z".
+ */
+export declare function keyNameFromEvent(event: KeyboardEvent): string;
+/**
+ * Match a binding key (which may use "Mod" as a placeholder) against an
+ * event key (which uses the actual modifier: Ctrl or Cmd).
+ *
+ * Comparison is case-insensitive so that binding keys may use lowercase
+ * letters (e.g. "Mod-z") while event keys use uppercase ("Cmd-Z").
+ */
+export declare function keyMatches(bindingKey: string, eventKey: string): boolean;
+export declare class KeymapRegistry {
+    private readonly bindings;
+    register(spec: KeymapSpec): void;
+    /** Resolve the first matching binding for an event key. */
+    resolve(eventKey: string): KeymapBinding | undefined;
+}

package/dist/core/command/SlashCommand.d.ts

@@ -0,0 +1,24 @@
+import { BlockType } from '../types';
+export interface SlashCommandSpec {
+    readonly id: string;
+    readonly title: string;
+    readonly keywords?: readonly string[];
+    readonly description?: string;
+    /** Opaque icon token; the view layer interprets it. */
+    readonly icon?: unknown;
+    /** Command to dispatch when chosen. */
+    readonly command: string;
+    readonly args?: unknown;
+    /** If set, only show when the current block is one of these types. */
+    readonly applicableTo?: readonly BlockType[];
+    /** Optional category for visual grouping in the menu. */
+    readonly category?: string;
+}
+export type SlashCommand = SlashCommandSpec;
+export declare class SlashCommandRegistry {
+    private readonly commands;
+    register(spec: SlashCommandSpec): void;
+    get all(): readonly SlashCommand[];
+    /** Naive substring search over title + keywords; refined in Phase 2. */
+    search(query: string): readonly SlashCommand[];
+}

package/dist/core/command/primitiveCommands.d.ts

@@ -0,0 +1,97 @@
+import { Attrs, BlockId, BlockType, InlineSeq, Selection } from '../types';
+import { AnyCommandEntry, Dispatch } from './Command';
+import { EditorRegistries } from '../extension/Registry';
+export interface InsertBlockArgs {
+    readonly type: BlockType;
+    readonly attrs?: Attrs;
+    readonly content?: InlineSeq;
+    /** Insert after this block (resolves parent + index). */
+    readonly after?: BlockId;
+    /** Or insert at an explicit parent/index. */
+    readonly parent?: BlockId | null;
+    readonly index?: number;
+}
+export interface ReplaceBlockArgs {
+    readonly id: BlockId;
+    readonly type: BlockType;
+    readonly attrs?: Attrs;
+}
+export interface SetTextArgs {
+    readonly id: BlockId;
+    readonly content: InlineSeq;
+    readonly selectionAfter?: Selection;
+}
+export interface SplitBlockArgs {
+    readonly id: BlockId;
+    readonly offset: number;
+    /**
+     * Type for the newly-created block. Defaults to the editor's default block
+     * type (paragraph). Used by the Enter handler to continue a list: passing
+     * the current list type yields a new list item instead of a paragraph.
+     */
+    readonly asType?: BlockType;
+    /** Attrs for the new block; defaults to defaultAttrsFor(asType). */
+    readonly asAttrs?: Attrs;
+}
+export interface MoveCaretArgs {
+    readonly offset?: number;
+}
+export interface ConvertBlockArgs {
+    readonly id: BlockId;
+    readonly type: BlockType;
+    readonly attrs?: Attrs;
+}
+export interface SetBlockAlignArgs {
+    readonly id: BlockId;
+    readonly align: 'left' | 'center' | 'right' | 'justify';
+}
+export interface SetBlockColorArgs {
+    readonly id: BlockId;
+    /** Color preset key (e.g. 'blue'). Pass 'default' to reset. */
+    readonly color: string;
+}
+export interface SetBlockBgColorArgs {
+    readonly id: BlockId;
+    readonly bgColor: string;
+}
+export interface SetStartNumberArgs {
+    readonly id: BlockId;
+    /**
+     * The explicit starting number for this ordered-list item.
+     * Pass `null` / `undefined` to clear the override — the item will then
+     * follow the previous block's numbering (standard "continue" behavior).
+     */
+    readonly startNumber: number | null;
+}
+export interface IndentBlockArgs {
+    readonly id?: BlockId;
+}
+export interface ToggleMarkArgs {
+    readonly id: BlockId;
+    readonly markType: string;
+    readonly from: number;
+    readonly to: number;
+}
+export interface SetInlineMarkArgs {
+    readonly id: BlockId;
+    readonly markType: string;
+    readonly attrs: Attrs | null;
+    readonly from: number;
+    readonly to: number;
+}
+export interface SetLinkArgs {
+    readonly id: BlockId;
+    readonly href: string;
+    readonly from: number;
+    readonly to: number;
+    /** Optional new text for the linked range. If omitted, text is unchanged. */
+    readonly text?: string;
+}
+export interface UnsetLinkArgs {
+    readonly id: BlockId;
+    readonly from: number;
+    readonly to: number;
+}
+/** Build all primitive commands. Registered by the Editor at construction. */
+export declare function createPrimitiveCommands(registries: EditorRegistries): AnyCommandEntry[];
+export type { Dispatch };

package/dist/core/extension/Extension.d.ts

@@ -0,0 +1,52 @@
+import { BlockSchemaSpec } from '../schema/BlockSchema';
+import { BlockType } from '../types';
+import { AnyCommandEntry } from '../command/Command';
+import { InputRuleSpec } from '../command/InputRule';
+import { KeymapSpec } from '../command/Keymap';
+import { Plugin } from '../plugin/Plugin';
+import { SlashCommandSpec } from '../command/SlashCommand';
+import { DeserializerSpec, SerializerSpec } from '../serialize/Serializer';
+/**
+ * Framework-opaque renderer spec. `component` is a Vue component in practice
+ * but typed as `unknown` so the core stays framework-agnostic; the view layer
+ * (`BlockHost`) interprets it.
+ */
+export interface BlockRendererSpec {
+    readonly component: unknown;
+    /** Does this block own a contenteditable text region? Default: from schema. */
+    readonly editable?: boolean;
+}
+export interface ToolbarActionSpec {
+    readonly id: string;
+    readonly label: string;
+    readonly command: string;
+    readonly args?: unknown;
+    readonly icon?: unknown;
+}
+export interface Extension {
+    readonly name: string;
+    /** Other extensions this one bundles. Flattened and de-duplicated by name. */
+    readonly uses?: readonly Extension[];
+    /** Declares a block type (schema). */
+    readonly schema?: BlockSchemaSpec;
+    /** Vue component that renders blocks of this type. */
+    readonly renderer?: BlockRendererSpec;
+    /** Commands contributed by this extension. */
+    readonly commands?: readonly AnyCommandEntry[];
+    /** Keyboard shortcut → command bindings. */
+    readonly keymap?: KeymapSpec;
+    /** Text patterns → command (activated in Phase 2). */
+    readonly inputRules?: readonly InputRuleSpec[];
+    /** Slash-menu / command-palette entries (activated in Phase 2). */
+    readonly slashCommands?: readonly SlashCommandSpec[];
+    /** Hover/insert toolbar actions (activated in Phase 4). */
+    readonly toolbar?: readonly ToolbarActionSpec[];
+    /** Per-block serialization (Markdown/HTML). */
+    readonly serialize?: SerializerSpec;
+    /** Per-block deserialization (Markdown/HTML). */
+    readonly deserialize?: DeserializerSpec;
+    /** Editor-level plugins (history, keymap, selection sync, …). */
+    readonly plugins?: readonly Plugin[];
+}
+/** A block type this extension declares (for convenience). */
+export declare function extensionBlockType(ext: Extension): BlockType | null;

package/dist/core/extension/Registry.d.ts

@@ -0,0 +1,46 @@
+import { BlockType } from '../types';
+import { AnyCommandEntry, CommandRegistry } from '../command/Command';
+import { InputRuleRegistry } from '../command/InputRule';
+import { KeymapRegistry } from '../command/Keymap';
+import { SlashCommandRegistry } from '../command/SlashCommand';
+import { BlockRendererSpec, Extension, ToolbarActionSpec } from './Extension';
+import { Plugin } from '../plugin/Plugin';
+import { SchemaRegistry } from '../schema/SchemaRegistry';
+import { DeserializerRegistry, SerializerRegistry } from '../serialize/Serializer';
+/** Opaque renderer registry: maps a block type to its renderer spec. */
+export declare class RendererRegistry {
+    private readonly map;
+    register(type: BlockType, spec: BlockRendererSpec): void;
+    get(type: BlockType): BlockRendererSpec | undefined;
+}
+export declare class ToolbarRegistry {
+    private readonly map;
+    register(type: BlockType, actions: readonly ToolbarActionSpec[]): void;
+    get(type: BlockType): readonly ToolbarActionSpec[];
+}
+export interface EditorRegistries {
+    readonly schema: SchemaRegistry;
+    readonly renderers: RendererRegistry;
+    readonly commands: CommandRegistry;
+    readonly keymap: KeymapRegistry;
+    readonly inputRules: InputRuleRegistry;
+    readonly slash: SlashCommandRegistry;
+    readonly toolbar: ToolbarRegistry;
+    readonly serializers: SerializerRegistry;
+    readonly deserializers: DeserializerRegistry;
+    readonly plugins: readonly Plugin[];
+    /** Extension-contributed commands (registered after primitives so they can override). */
+    readonly extensionCommands: readonly AnyCommandEntry[];
+    /** The block type used by "empty Enter exits" (default: 'paragraph'). */
+    readonly defaultBlockType: BlockType;
+}
+export interface BuildRegistriesOptions {
+    readonly defaultBlockType?: BlockType;
+}
+/**
+ * Flatten an extension array: recursively expand `uses`, de-duplicate by name
+ * keeping the *last* occurrence (so user-provided extensions override
+ * built-ins with the same name).
+ */
+export declare function flattenExtensions(extensions: readonly Extension[]): Extension[];
+export declare function buildRegistries(extensions: readonly Extension[], options?: BuildRegistriesOptions): EditorRegistries;

package/dist/core/history/HistoryManager.d.ts

@@ -0,0 +1,37 @@
+import { DocState, Selection } from '../types';
+import { Transaction } from '../state/Transaction';
+export declare class HistoryManager {
+    private readonly undoStack;
+    private readonly redoStack;
+    private readonly limit;
+    /** Stack of explicit groups opened by `beginGroup`/`endGroup`. */
+    private manualGroupStack;
+    /** Monotonically increasing counter for unique group ids. */
+    private groupCounter;
+    constructor(limit?: number);
+    /**
+     * Begin a new explicit grouping scope. Any `record()` call made between
+     * `beginGroup()` and the matching `endGroup()` (even across nested scopes)
+     * will be assigned to the same generated `historyGroup` key, so they merge
+     * into a single undo entry. Scopes nest: the outermost `endGroup()` closes
+     * the group (subsequent records become their own entries again).
+     *
+     * Typical use: bracket a sequence of commands (e.g. `setText` + `convertBlock`)
+     * so the user can undo them as one step.
+     */
+    beginGroup(): string;
+    /** Close an explicit grouping scope opened by `beginGroup()`. */
+    endGroup(): void;
+    /** The currently-active manual group id, or null if none. */
+    get currentGroup(): string | null;
+    /** Record a transaction against the state that preceded it. */
+    record(tr: Transaction, prevSelection: Selection, prevDoc: DocState): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    /** Clear all history (used when the document is replaced wholesale). */
+    reset(): void;
+    /** Build the transaction that undoes the last entry, or null if none. */
+    undo(): Transaction | null;
+    /** Build the transaction that redoes the last undone entry, or null if none. */
+    redo(): Transaction | null;
+}

package/dist/core/ids.d.ts

@@ -0,0 +1,5 @@
+import { BlockId } from './types';
+/** Generate a fresh, unique block id. */
+export declare function createBlockId(): BlockId;
+/** Coerce a string into a `BlockId` (use only when rehydrating trusted data). */
+export declare function asBlockId(value: string): BlockId;

package/dist/core/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Public surface of the framework-agnostic editor core. The view layer and
+ * extensions import from here. Nothing in this barrel imports Vue.
+ */
+export * from './types';
+export { createBlockId, asBlockId } from './ids';
+export type { BlockSchema, BlockSchemaSpec, AttrSpec, } from './schema/BlockSchema';
+export { defineSchema, defaultAttrs, coerceAttrs, canContain, hasText, isIsolating, isEmpty, } from './schema/BlockSchema';
+export { SchemaRegistry } from './schema/SchemaRegistry';
+export * from './state/store';
+export type { Step } from './state/Step';
+export { applySteps, type ApplyResult } from './state/Step';
+export { createState, applyTransaction, type EditorState, type ApplyTransactionResult } from './state/EditorState';
+export { createTransaction, TransactionBuilder, type Transaction, type TransactionMeta, type InsertBlockParams, } from './state/Transaction';
+export { invertSteps } from './state/invert';
+export * from './selection/Selection';
+export type { CommandFn, CommandEntry, CommandSpec, AnyCommandEntry, Dispatch, CommandDispatcher } from './command/Command';
+export { CommandRegistry } from './command/Command';
+export { createPrimitiveCommands } from './command/primitiveCommands';
+export type { KeymapBinding, KeymapSpec } from './command/Keymap';
+export { KeymapRegistry, keyNameFromEvent, keyMatches } from './command/Keymap';
+export type { InputRuleSpec, InputRule } from './command/InputRule';
+export { InputRuleRegistry } from './command/InputRule';
+export type { SlashCommandSpec, SlashCommand } from './command/SlashCommand';
+export { SlashCommandRegistry } from './command/SlashCommand';
+export type { SerializerSpec, DeserializerSpec, SerializeResult } from './serialize/Serializer';
+export { SerializerRegistry, DeserializerRegistry } from './serialize/Serializer';
+export type { Plugin, PluginState, EventContext } from './plugin/Plugin';
+export type { Extension, BlockRendererSpec, ToolbarActionSpec } from './extension/Extension';
+export { extensionBlockType } from './extension/Extension';
+export { flattenExtensions, buildRegistries } from './extension/Registry';
+export type { EditorRegistries, RendererRegistry, ToolbarRegistry, BuildRegistriesOptions, } from './extension/Registry';
+export { HistoryManager } from './history/HistoryManager';
+export { Editor } from './Editor';
+export type { EditorConfig, StateUpdate, EditorListener } from './Editor';

package/dist/core/plugin/Plugin.d.ts

@@ -0,0 +1,26 @@
+import { EditorState } from '../state/EditorState';
+import { Transaction } from '../state/Transaction';
+/** Opaque per-plugin state slice. Each plugin owns its concrete type. */
+export type PluginState = unknown;
+export interface EventContext {
+    readonly state: EditorState;
+    readonly dispatch: (tr: Transaction) => void;
+    /** The focused block id, if any (the block owning the active contenteditable). */
+    readonly focusBlockId: () => string | null;
+}
+export interface Plugin {
+    readonly name: string;
+    /** Called once when the editor is created. Returns the initial plugin state. */
+    init?(state: EditorState): PluginState;
+    /**
+     * Called for every applied transaction. Receives the transaction, the
+     * *previous* state, and the new (doc/selection) state being assembled.
+     * Returns the plugin's new state slice.
+     */
+    applyTransaction?(tr: Transaction, prevState: EditorState, nextDoc: EditorState['doc'], nextSelection: EditorState['selection']): PluginState;
+    onKeyDown?(event: KeyboardEvent, ctx: EventContext): boolean;
+    onInput?(event: InputEvent, ctx: EventContext): boolean;
+    onCompositionStart?(event: CompositionEvent, ctx: EventContext): void;
+    onCompositionEnd?(event: CompositionEvent, ctx: EventContext): void;
+    onDestroy?(): void;
+}

package/dist/core/schema/BlockSchema.d.ts

@@ -0,0 +1,70 @@
+import { Attrs, Block, BlockType, JSONValue } from '../types';
+export interface AttrSpec {
+    /** Default value used when a block is created without this attr. */
+    readonly default: JSONValue;
+    /** Optional runtime validation; rejected attrs fall back to the default. */
+    readonly validate?: (value: unknown) => boolean;
+}
+export interface BlockSchemaSpec {
+    readonly type: BlockType;
+    readonly attrs?: Readonly<Record<string, AttrSpec>>;
+    /** Does this block own an editable inline text region? */
+    readonly content?: 'text' | 'none';
+    /** May this block contain child blocks? */
+    readonly nestable?: boolean;
+    /** Whitelist of allowed child types. Omit / '*' means any registered type. */
+    readonly allowedChildren?: readonly BlockType[] | '*';
+    /**
+     * If true, this block is a boundary for delete/merge: Backspace at its start
+     * will not merge it into the previous block (e.g. a code block).
+     */
+    readonly isolating?: boolean;
+    /**
+     * If true, this block is a list item (bullet / ordered / todo). Enter on a
+     * non-empty item continues the list by inserting a new item of the same
+     * type; Backspace at offset 0 converts it to a paragraph instead of
+     * merging into the previous block. The core uses this schema flag rather
+     * than switching on `block.type`.
+     */
+    readonly listLike?: boolean;
+    /**
+     * If false, inline marks (bold/italic/underline/strikethrough/code) and
+     * block-level color/bgColor are not allowed on this block. When a block
+     * is converted to a type with inlineMarks=false, all existing marks are
+     * stripped and color/bgColor are reset to defaults.
+     */
+    readonly inlineMarks?: boolean;
+    /**
+     * Inline mark types that are disallowed on this block type even though
+     * inlineMarks=true. Used when a block renders a mark globally (e.g. quote
+     * blocks render italic by default) so the corresponding inline mark would
+     * be redundant. The toggleMark command refuses to apply these; the UI
+     * should disable the matching buttons.
+     */
+    readonly disallowedMarks?: readonly string[];
+    /** Is this block "empty" (used for placeholder + "empty Enter exits")? */
+    readonly empty?: (block: Block) => boolean;
+}
+export interface BlockSchema {
+    readonly type: BlockType;
+    readonly attrs: Readonly<Record<string, AttrSpec>>;
+    readonly content: 'text' | 'none';
+    readonly nestable: boolean;
+    readonly allowedChildren: readonly BlockType[] | '*';
+    readonly isolating: boolean;
+    readonly listLike: boolean;
+    readonly inlineMarks: boolean;
+    readonly disallowedMarks: readonly string[];
+    readonly empty: (block: Block) => boolean;
+}
+/** Normalize a spec into a full schema with defaults applied. */
+export declare function defineSchema(spec: BlockSchemaSpec): BlockSchema;
+/** Compute the default attrs for a schema (used when creating a block). */
+export declare function defaultAttrs(schema: BlockSchema): Attrs;
+/** Coerce arbitrary attrs through a schema, validating and filling defaults. */
+export declare function coerceAttrs(schema: BlockSchema, raw: Readonly<Record<string, unknown>>): Attrs;
+/** Does the parent schema permit a child of the given type? */
+export declare function canContain(parent: BlockSchema, childType: BlockType): boolean;
+export declare function hasText(schema: BlockSchema): boolean;
+export declare function isIsolating(schema: BlockSchema): boolean;
+export declare function isEmpty(schema: BlockSchema, block: Block): boolean;

package/dist/core/schema/SchemaRegistry.d.ts

@@ -0,0 +1,22 @@
+import { Block, BlockType } from '../types';
+import { BlockSchema } from './BlockSchema';
+export declare class SchemaRegistry {
+    private readonly schemas;
+    private readonly fallback;
+    constructor(schemas: ReadonlyMap<BlockType, BlockSchema>, fallback: BlockSchema);
+    /** Resolve a schema by type, falling back to the paragraph-like default. */
+    get(type: BlockType): BlockSchema;
+    has(type: BlockType): boolean;
+    /** Compute default attrs for a type (used when creating a block). */
+    defaultAttrsFor(type: BlockType): Readonly<Record<string, import('../types').JSONValue>>;
+    /** Coerce raw attrs through the type's schema. */
+    coerceAttrsFor(type: BlockType, raw: Readonly<Record<string, unknown>>): Readonly<Record<string, import('../types').JSONValue>>;
+    canContain(parentType: BlockType, childType: BlockType): boolean;
+    hasText(type: BlockType): boolean;
+    isIsolating(type: BlockType): boolean;
+    isListLike(type: BlockType): boolean;
+    hasInlineMarks(type: BlockType): boolean;
+    /** Is the given inline mark type disallowed on this block type? */
+    isMarkDisallowed(type: BlockType, markType: string): boolean;
+    isEmpty(block: Block): boolean;
+}

package/dist/core/selection/Selection.d.ts

@@ -0,0 +1,25 @@
+import { Anchor, BlockId, Selection } from '../types';
+export declare function caretSelection(blockId: BlockId, offset: number): Selection;
+export declare function textSelection(anchor: Anchor, focus: Anchor): Selection;
+export declare function blocksSelection(blockIds: readonly BlockId[]): Selection;
+export declare function isCaret(sel: Selection): sel is Extract<Selection, {
+    kind: 'caret';
+}>;
+export declare function isText(sel: Selection): sel is Extract<Selection, {
+    kind: 'text';
+}>;
+export declare function isBlocks(sel: Selection): sel is Extract<Selection, {
+    kind: 'blocks';
+}>;
+/** A collapsed text/caret selection targets a single offset in a single block. */
+export declare function isCollapsed(sel: Selection): boolean;
+/** The "primary" block of a selection (where commands like Enter operate). */
+export declare function primaryBlock(sel: Selection): BlockId | null;
+/** The focus offset for a caret/text selection, or 0 for blocks selection. */
+export declare function focusOffset(sel: Selection): number;
+/**
+ * Normalize a selection so the anchor precedes (or equals) the focus in
+ * document order. Used when computing deletion ranges for Backspace/typing
+ * over a selection. Returns the [start, end] anchors in order.
+ */
+export declare function orderedAnchors(sel: Selection, compare: (a: Anchor, b: Anchor) => number): readonly [Anchor, Anchor] | null;

package/dist/core/serialize/Serializer.d.ts

@@ -0,0 +1,31 @@
+import { Attrs, Block, BlockType, InlineSeq } from '../types';
+export interface SerializeResult {
+    readonly type: BlockType;
+    readonly attrs?: Attrs;
+    readonly content?: InlineSeq;
+}
+export interface SerializerSpec {
+    /** Serialize a block to a Markdown line/representation. */
+    readonly toMarkdown?: (block: Block) => string;
+    /** Serialize a block to an HTML string. */
+    readonly toHTML?: (block: Block) => string;
+}
+export interface DeserializerSpec {
+    /**
+     * Attempt to parse a single Markdown line into a block descriptor, or return
+     * null if this deserializer does not match.
+     */
+    readonly fromMarkdown?: (line: string) => SerializeResult | null;
+}
+export declare class SerializerRegistry {
+    private readonly toMarkdown;
+    private readonly toHTML;
+    register(type: BlockType, spec: SerializerSpec): void;
+    markdownFor(block: Block): string | undefined;
+    htmlFor(block: Block): string | undefined;
+}
+export declare class DeserializerRegistry {
+    private readonly fromMarkdown;
+    register(spec: DeserializerSpec): void;
+    parseMarkdownLine(line: string): SerializeResult | null;
+}