@rtif-sdk/engine 1.0.0

package/dist/history.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Undo/redo history stack management.
+ * All functions are pure — they return new HistoryState, never mutate.
+ *
+ * History stores `{ forward, inverse }` pairs so that:
+ * - Undo applies inverse ops in reverse order (undoing last op first)
+ * - Redo replays the original forward ops — no recomputation needed
+ */
+import type { Operation } from '@rtif-sdk/core';
+/** Default max undo depth */
+export declare const DEFAULT_MAX_DEPTH = 100;
+/**
+ * A single undo/redo entry storing both the forward ops and their inverses.
+ * Forward ops are the original operations as dispatched.
+ * Inverse ops are the operations that reverse them (in application order,
+ * meaning `inverse[i]` undoes `forward[i]`).
+ */
+export interface HistoryEntry {
+    readonly forward: ReadonlyArray<Operation>;
+    readonly inverse: ReadonlyArray<Operation>;
+}
+/** History state for undo/redo */
+export interface HistoryState {
+    /** Stack of operation groups for undo (last element = most recent) */
+    readonly undoStack: ReadonlyArray<HistoryEntry>;
+    /** Stack of operation groups for redo (last element = most recent) */
+    readonly redoStack: ReadonlyArray<HistoryEntry>;
+}
+/**
+ * Create an empty history state.
+ *
+ * @returns A fresh history with empty undo and redo stacks
+ *
+ * @example
+ * ```ts
+ * const history = createHistory();
+ * // { undoStack: [], redoStack: [] }
+ * ```
+ */
+export declare function createHistory(): HistoryState;
+/**
+ * Push an operation group onto the undo stack, clearing redo.
+ * A new action invalidates the redo stack. Trims oldest entries if
+ * the stack exceeds `maxDepth`.
+ *
+ * @param history - The current history state
+ * @param entry - The history entry containing forward and inverse ops
+ * @param maxDepth - Maximum undo stack depth (default 100)
+ * @returns New history state with the entry pushed
+ *
+ * @example
+ * ```ts
+ * const h1 = pushUndoGroup(history, { forward: [op], inverse: [invOp] }, 100);
+ * ```
+ */
+export declare function pushUndoGroup(history: HistoryState, entry: HistoryEntry, maxDepth?: number): HistoryState;
+/**
+ * Pop the most recent undo entry from the stack.
+ * Returns `undefined` if the undo stack is empty.
+ * Does NOT push to redo — the engine handles that after applying the ops.
+ *
+ * @param history - The current history state
+ * @returns The popped entry and new history, or undefined if empty
+ *
+ * @example
+ * ```ts
+ * const result = popUndo(history);
+ * if (result) {
+ *   const { entry, history: newHistory } = result;
+ *   // entry.inverse contains the ops to apply (in reverse order)
+ *   // entry.forward is available for the redo stack
+ * }
+ * ```
+ */
+export declare function popUndo(history: HistoryState): {
+    entry: HistoryEntry;
+    history: HistoryState;
+} | undefined;
+/**
+ * Pop the most recent redo entry from the stack.
+ * Returns `undefined` if the redo stack is empty.
+ * Does NOT push to undo — the engine handles that after applying the ops.
+ *
+ * @param history - The current history state
+ * @returns The popped entry and new history, or undefined if empty
+ *
+ * @example
+ * ```ts
+ * const result = popRedo(history);
+ * if (result) {
+ *   const { entry, history: newHistory } = result;
+ *   // entry.forward contains the ops to replay
+ *   // entry.inverse is available for the undo stack
+ * }
+ * ```
+ */
+export declare function popRedo(history: HistoryState): {
+    entry: HistoryEntry;
+    history: HistoryState;
+} | undefined;
+/**
+ * Push an entry onto the redo stack.
+ * Used internally by the engine after undo applies the inverse ops.
+ *
+ * @param history - The current history state
+ * @param entry - The history entry to push
+ * @returns New history state with the entry pushed to redo
+ *
+ * @example
+ * ```ts
+ * const h1 = pushRedoGroup(history, { forward: [op], inverse: [invOp] });
+ * ```
+ */
+export declare function pushRedoGroup(history: HistoryState, entry: HistoryEntry): HistoryState;
+/**
+ * Push an entry onto the undo stack without clearing redo.
+ * Used internally by the engine after redo applies forward ops.
+ *
+ * @param history - The current history state
+ * @param entry - The history entry to push
+ * @param maxDepth - Maximum undo stack depth (default 100)
+ * @returns New history state with the entry pushed to undo
+ *
+ * @example
+ * ```ts
+ * const h1 = pushUndoGroupKeepRedo(history, { forward: [op], inverse: [invOp] });
+ * ```
+ */
+export declare function pushUndoGroupKeepRedo(history: HistoryState, entry: HistoryEntry, maxDepth?: number): HistoryState;
+//# sourceMappingURL=history.d.ts.map

package/dist/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../src/history.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,6BAA6B;AAC7B,eAAO,MAAM,iBAAiB,MAAM,CAAC;AAErC;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;CAC5C;AAED,kCAAkC;AAClC,MAAM,WAAW,YAAY;IAC3B,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;IAChD,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;CACjD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,IAAI,YAAY,CAE5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,YAAY,EACnB,QAAQ,GAAE,MAA0B,GACnC,YAAY,CAWd;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,YAAY,GACpB;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GAAG,SAAS,CAa5D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CACrB,OAAO,EAAE,YAAY,GACpB;IAAE,KAAK,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GAAG,SAAS,CAa5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,YAAY,GAClB,YAAY,CAKd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,YAAY,EACnB,QAAQ,GAAE,MAA0B,GACnC,YAAY,CAUd"}

package/dist/history.js

@@ -0,0 +1,156 @@
+/**
+ * Undo/redo history stack management.
+ * All functions are pure — they return new HistoryState, never mutate.
+ *
+ * History stores `{ forward, inverse }` pairs so that:
+ * - Undo applies inverse ops in reverse order (undoing last op first)
+ * - Redo replays the original forward ops — no recomputation needed
+ */
+/** Default max undo depth */
+export const DEFAULT_MAX_DEPTH = 100;
+/**
+ * Create an empty history state.
+ *
+ * @returns A fresh history with empty undo and redo stacks
+ *
+ * @example
+ * ```ts
+ * const history = createHistory();
+ * // { undoStack: [], redoStack: [] }
+ * ```
+ */
+export function createHistory() {
+    return { undoStack: [], redoStack: [] };
+}
+/**
+ * Push an operation group onto the undo stack, clearing redo.
+ * A new action invalidates the redo stack. Trims oldest entries if
+ * the stack exceeds `maxDepth`.
+ *
+ * @param history - The current history state
+ * @param entry - The history entry containing forward and inverse ops
+ * @param maxDepth - Maximum undo stack depth (default 100)
+ * @returns New history state with the entry pushed
+ *
+ * @example
+ * ```ts
+ * const h1 = pushUndoGroup(history, { forward: [op], inverse: [invOp] }, 100);
+ * ```
+ */
+export function pushUndoGroup(history, entry, maxDepth = DEFAULT_MAX_DEPTH) {
+    const newStack = [...history.undoStack, entry];
+    // Trim oldest if over maxDepth
+    const trimmed = newStack.length > maxDepth
+        ? newStack.slice(newStack.length - maxDepth)
+        : newStack;
+    return {
+        undoStack: trimmed,
+        redoStack: [],
+    };
+}
+/**
+ * Pop the most recent undo entry from the stack.
+ * Returns `undefined` if the undo stack is empty.
+ * Does NOT push to redo — the engine handles that after applying the ops.
+ *
+ * @param history - The current history state
+ * @returns The popped entry and new history, or undefined if empty
+ *
+ * @example
+ * ```ts
+ * const result = popUndo(history);
+ * if (result) {
+ *   const { entry, history: newHistory } = result;
+ *   // entry.inverse contains the ops to apply (in reverse order)
+ *   // entry.forward is available for the redo stack
+ * }
+ * ```
+ */
+export function popUndo(history) {
+    if (history.undoStack.length === 0) {
+        return undefined;
+    }
+    const entry = history.undoStack[history.undoStack.length - 1];
+    return {
+        entry,
+        history: {
+            undoStack: history.undoStack.slice(0, -1),
+            redoStack: history.redoStack,
+        },
+    };
+}
+/**
+ * Pop the most recent redo entry from the stack.
+ * Returns `undefined` if the redo stack is empty.
+ * Does NOT push to undo — the engine handles that after applying the ops.
+ *
+ * @param history - The current history state
+ * @returns The popped entry and new history, or undefined if empty
+ *
+ * @example
+ * ```ts
+ * const result = popRedo(history);
+ * if (result) {
+ *   const { entry, history: newHistory } = result;
+ *   // entry.forward contains the ops to replay
+ *   // entry.inverse is available for the undo stack
+ * }
+ * ```
+ */
+export function popRedo(history) {
+    if (history.redoStack.length === 0) {
+        return undefined;
+    }
+    const entry = history.redoStack[history.redoStack.length - 1];
+    return {
+        entry,
+        history: {
+            undoStack: history.undoStack,
+            redoStack: history.redoStack.slice(0, -1),
+        },
+    };
+}
+/**
+ * Push an entry onto the redo stack.
+ * Used internally by the engine after undo applies the inverse ops.
+ *
+ * @param history - The current history state
+ * @param entry - The history entry to push
+ * @returns New history state with the entry pushed to redo
+ *
+ * @example
+ * ```ts
+ * const h1 = pushRedoGroup(history, { forward: [op], inverse: [invOp] });
+ * ```
+ */
+export function pushRedoGroup(history, entry) {
+    return {
+        undoStack: history.undoStack,
+        redoStack: [...history.redoStack, entry],
+    };
+}
+/**
+ * Push an entry onto the undo stack without clearing redo.
+ * Used internally by the engine after redo applies forward ops.
+ *
+ * @param history - The current history state
+ * @param entry - The history entry to push
+ * @param maxDepth - Maximum undo stack depth (default 100)
+ * @returns New history state with the entry pushed to undo
+ *
+ * @example
+ * ```ts
+ * const h1 = pushUndoGroupKeepRedo(history, { forward: [op], inverse: [invOp] });
+ * ```
+ */
+export function pushUndoGroupKeepRedo(history, entry, maxDepth = DEFAULT_MAX_DEPTH) {
+    const newStack = [...history.undoStack, entry];
+    const trimmed = newStack.length > maxDepth
+        ? newStack.slice(newStack.length - maxDepth)
+        : newStack;
+    return {
+        undoStack: trimmed,
+        redoStack: history.redoStack,
+    };
+}
+//# sourceMappingURL=history.js.map

package/dist/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","sourceRoot":"","sources":["../src/history.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,6BAA6B;AAC7B,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAC;AAqBrC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;AAC1C,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAqB,EACrB,KAAmB,EACnB,WAAmB,iBAAiB;IAEpC,MAAM,QAAQ,GAAG,CAAC,GAAG,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAC/C,+BAA+B;IAC/B,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,GAAG,QAAQ;QACxC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC;QAC5C,CAAC,CAAC,QAAQ,CAAC;IAEb,OAAO;QACL,SAAS,EAAE,OAAO;QAClB,SAAS,EAAE,EAAE;KACd,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,OAAO,CACrB,OAAqB;IAErB,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACnC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC;IAC/D,OAAO;QACL,KAAK;QACL,OAAO,EAAE;YACP,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACzC,SAAS,EAAE,OAAO,CAAC,SAAS;SAC7B;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,OAAO,CACrB,OAAqB;IAErB,IAAI,OAAO,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACnC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAE,CAAC;IAC/D,OAAO;QACL,KAAK;QACL,OAAO,EAAE;YACP,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;SAC1C;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAqB,EACrB,KAAmB;IAEnB,OAAO;QACL,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,SAAS,EAAE,CAAC,GAAG,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC;KACzC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAAqB,EACrB,KAAmB,EACnB,WAAmB,iBAAiB;IAEpC,MAAM,QAAQ,GAAG,CAAC,GAAG,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;IAC/C,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,GAAG,QAAQ;QACxC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC;QAC5C,CAAC,CAAC,QAAQ,CAAC;IAEb,OAAO;QACL,SAAS,EAAE,OAAO;QAClB,SAAS,EAAE,OAAO,CAAC,SAAS;KAC7B,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { createEngine } from './engine.js';
+export type { EditorState, IEditorEngine } from './engine.js';
+export { EngineCommands } from './commands.js';
+export type { Plugin, PluginContext } from './plugin-host.js';
+export { createHistory, pushUndoGroup, popUndo, popRedo, pushRedoGroup, pushUndoGroupKeepRedo, DEFAULT_MAX_DEPTH, } from './history.js';
+export type { HistoryState, HistoryEntry } from './history.js';
+export { EngineError } from './errors.js';
+export type { EngineErrorCode, PluginError } from './errors.js';
+export { transformSelection } from './selection-transform.js';
+export { normalizeCommandHandler } from './registries.js';
+export type { PluginRegistries, BlockTypeConfig, MarkTypeConfig, InputRule, CommandHandler, CommandDescriptor, ShortcutDescriptor, ShortcutBinding, } from './registries.js';
+export type { RangeMarksResult } from '@rtif-sdk/core';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE9D,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE9D,OAAO,EACL,aAAa,EACb,aAAa,EACb,OAAO,EACP,OAAO,EACP,aAAa,EACb,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE/D,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,cAAc,EACd,SAAS,EACT,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,GAChB,MAAM,iBAAiB,CAAC;AAGzB,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { createEngine } from './engine.js';
+export { EngineCommands } from './commands.js';
+export { createHistory, pushUndoGroup, popUndo, popRedo, pushRedoGroup, pushUndoGroupKeepRedo, DEFAULT_MAX_DEPTH, } from './history.js';
+export { EngineError } from './errors.js';
+export { transformSelection } from './selection-transform.js';
+export { normalizeCommandHandler } from './registries.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAI/C,OAAO,EACL,aAAa,EACb,aAAa,EACb,OAAO,EACP,OAAO,EACP,aAAa,EACb,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/plugin-host.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Plugin interface and lifecycle management.
+ * See docs/spec/plugin-contract.md for specification.
+ */
+import type { Operation } from '@rtif-sdk/core';
+import type { EditorState, IEditorEngine } from './engine.js';
+import type { PluginRegistries } from './registries.js';
+/**
+ * Context passed to `Plugin.init()`.
+ * Extends the engine interface with registry methods available during init only.
+ * Registry calls outside of init throw `EngineError('REGISTRY_CLOSED')`.
+ */
+export type PluginContext = IEditorEngine & PluginRegistries;
+/** Plugin interface — extensions that observe, intercept, and transform editor operations */
+export interface Plugin {
+    /** Unique identifier */
+    readonly id: string;
+    /** Called once when the plugin is registered via `engine.use(plugin)` */
+    init?(ctx: PluginContext): void;
+    /**
+     * Called before operations are applied.
+     * Can inspect, modify, or cancel operations.
+     * Return empty array to cancel all ops.
+     */
+    beforeApply?(ops: Operation[], state: EditorState): Operation[];
+    /**
+     * Called after operations are applied, before onChange fires.
+     * Cannot modify the operations, but can dispatch new ones.
+     */
+    afterApply?(ops: Operation[], prevState: EditorState, nextState: EditorState): void;
+    /** Called when the plugin is removed */
+    destroy?(): void;
+}
+//# sourceMappingURL=plugin-host.d.ts.map

package/dist/plugin-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-host.d.ts","sourceRoot":"","sources":["../src/plugin-host.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,gBAAgB,CAAC;AAE7D,6FAA6F;AAC7F,MAAM,WAAW,MAAM;IACrB,wBAAwB;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,yEAAyE;IACzE,IAAI,CAAC,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI,CAAC;IAEhC;;;;OAIG;IACH,WAAW,CAAC,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,WAAW,GAAG,SAAS,EAAE,CAAC;IAEhE;;;OAGG;IACH,UAAU,CAAC,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,GAAG,IAAI,CAAC;IAEpF,wCAAwC;IACxC,OAAO,CAAC,IAAI,IAAI,CAAC;CAClB"}

package/dist/plugin-host.js

@@ -0,0 +1,6 @@
+/**
+ * Plugin interface and lifecycle management.
+ * See docs/spec/plugin-contract.md for specification.
+ */
+export {};
+//# sourceMappingURL=plugin-host.js.map

package/dist/plugin-host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-host.js","sourceRoot":"","sources":["../src/plugin-host.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/registries.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Plugin registries — block types, mark types, commands, input rules, and shortcuts.
+ * See SPEC.md §5.2 and docs/spec/plugin-contract.md for specification.
+ */
+import type { IEditorEngine } from './engine.js';
+/** Configuration for a registered block type */
+export interface BlockTypeConfig {
+    defaultAttrs?: Record<string, unknown>;
+    validate?: (attrs: Record<string, unknown>) => boolean;
+}
+/** Configuration for a registered mark type */
+export interface MarkTypeConfig {
+    validate?: (value: unknown) => boolean;
+}
+/** An input rule that transforms text on insert */
+export interface InputRule {
+    /** Regex tested against the block text after the insert */
+    pattern: RegExp;
+    /** Handler called when pattern matches */
+    handler: (engine: IEditorEngine, match: RegExpMatchArray, blockId: string) => void;
+    /** If true, no further rules are tested after this one matches. Default: false. */
+    exclusive?: boolean;
+}
+/**
+ * Full command descriptor with optional `canExecute` and `isActive` queries.
+ *
+ * @example
+ * ```ts
+ * const toggleBold: CommandDescriptor = {
+ *   execute: (engine) => { engine.dispatch({ ... }); },
+ *   canExecute: (engine) => {
+ *     const sel = engine.state.selection;
+ *     return sel.anchor.offset !== sel.focus.offset;
+ *   },
+ *   isActive: (engine) => {
+ *     const marks = engine.getMarksAtOffset(engine.state.selection.focus.offset);
+ *     return marks.bold === true;
+ *   },
+ * };
+ * ```
+ */
+export interface CommandDescriptor {
+    /** Execute the command */
+    readonly execute: (engine: IEditorEngine, payload?: unknown) => void;
+    /** Whether the command can execute in the current state. Default: true. */
+    readonly canExecute?: (engine: IEditorEngine, payload?: unknown) => boolean;
+    /** Whether the command's effect is currently active. Default: false. */
+    readonly isActive?: (engine: IEditorEngine, payload?: unknown) => boolean;
+}
+/**
+ * Command handler — either a plain function or a full descriptor with queries.
+ *
+ * Plain functions are normalized to `{ execute: fn }` internally.
+ *
+ * @example
+ * ```ts
+ * // Simple function handler
+ * registerCommand('myCommand', (engine) => { ... });
+ *
+ * // Full descriptor
+ * registerCommand('toggleBold', {
+ *   execute: (engine) => { ... },
+ *   canExecute: (engine) => true,
+ *   isActive: (engine) => false,
+ * });
+ * ```
+ */
+export type CommandHandler = ((engine: IEditorEngine, payload?: unknown) => void) | CommandDescriptor;
+/**
+ * Describes a keyboard shortcut in a platform-agnostic way.
+ *
+ * The `mod` key maps to Cmd on macOS/iOS and Ctrl on Windows/Linux.
+ *
+ * @example
+ * ```ts
+ * const boldShortcut: ShortcutDescriptor = { key: 'b', mod: true };
+ * const strikeShortcut: ShortcutDescriptor = { key: 'x', mod: true, shift: true };
+ * ```
+ */
+export interface ShortcutDescriptor {
+    /** The key identifier (e.g., "b", "k", "Enter", "Backspace") */
+    readonly key: string;
+    /** Whether the platform modifier (Cmd/Ctrl) must be held */
+    readonly mod?: boolean;
+    /** Whether Shift must be held */
+    readonly shift?: boolean;
+    /** Whether Alt/Option must be held */
+    readonly alt?: boolean;
+}
+/**
+ * A binding from a keyboard shortcut to a command name and optional payload.
+ *
+ * @example
+ * ```ts
+ * const binding: ShortcutBinding = {
+ *   descriptor: { key: 'b', mod: true },
+ *   command: 'toggleMark:bold',
+ * };
+ * ```
+ */
+export interface ShortcutBinding {
+    /** The shortcut key combination */
+    readonly descriptor: ShortcutDescriptor;
+    /** The command name to execute when this shortcut is triggered */
+    readonly command: string;
+    /** Optional payload to pass to the command handler */
+    readonly payload?: unknown;
+}
+/** Registry interface available to plugins during init */
+export interface PluginRegistries {
+    registerBlockType(type: string, config: BlockTypeConfig): void;
+    registerMarkType(type: string, config: MarkTypeConfig): void;
+    registerCommand(name: string, handler: CommandHandler): void;
+    registerInputRule(rule: InputRule): void;
+    registerShortcut(descriptor: ShortcutDescriptor, command: string, payload?: unknown): void;
+}
+/**
+ * Normalize a CommandHandler (function or descriptor) to a CommandDescriptor.
+ *
+ * @param handler - A plain function or a CommandDescriptor
+ * @returns A normalized CommandDescriptor
+ *
+ * @example
+ * ```ts
+ * const desc = normalizeCommandHandler((engine) => engine.undo());
+ * // => { execute: (engine) => engine.undo() }
+ * ```
+ */
+export declare function normalizeCommandHandler(handler: CommandHandler): CommandDescriptor;
+//# sourceMappingURL=registries.d.ts.map

package/dist/registries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registries.d.ts","sourceRoot":"","sources":["../src/registries.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;CACxD;AAED,+CAA+C;AAC/C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CACxC;AAED,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACxB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,OAAO,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACnF,mFAAmF;IACnF,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,iBAAiB;IAChC,0BAA0B;IAC1B,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACrE,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAC5E,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,cAAc,GACtB,CAAC,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC,GACpD,iBAAiB,CAAC;AAEtB;;;;;;;;;;GAUG;AACH,MAAM,WAAW,kBAAkB;IACjC,gEAAgE;IAChE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;IACvB,iCAAiC;IACjC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,sCAAsC;IACtC,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;IACxC,kEAAkE;IAClE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,sDAAsD;IACtD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,0DAA0D;AAC1D,MAAM,WAAW,gBAAgB;IAC/B,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC;IAC/D,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IAC7D,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IAC7D,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IACzC,gBAAgB,CAAC,UAAU,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC5F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,cAAc,GAAG,iBAAiB,CAKlF"}

package/dist/registries.js

@@ -0,0 +1,23 @@
+/**
+ * Plugin registries — block types, mark types, commands, input rules, and shortcuts.
+ * See SPEC.md §5.2 and docs/spec/plugin-contract.md for specification.
+ */
+/**
+ * Normalize a CommandHandler (function or descriptor) to a CommandDescriptor.
+ *
+ * @param handler - A plain function or a CommandDescriptor
+ * @returns A normalized CommandDescriptor
+ *
+ * @example
+ * ```ts
+ * const desc = normalizeCommandHandler((engine) => engine.undo());
+ * // => { execute: (engine) => engine.undo() }
+ * ```
+ */
+export function normalizeCommandHandler(handler) {
+    if (typeof handler === 'function') {
+        return { execute: handler };
+    }
+    return handler;
+}
+//# sourceMappingURL=registries.js.map

package/dist/registries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registries.js","sourceRoot":"","sources":["../src/registries.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA6HH;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAuB;IAC7D,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;QAClC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;IAC9B,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/selection-transform.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pure selection transform functions.
+ * Adjusts cursor/selection positions in response to document operations.
+ */
+import type { Selection, Operation } from '@rtif-sdk/core';
+/**
+ * Transform a selection in response to an operation.
+ * Both anchor and focus are independently adjusted.
+ *
+ * @param selection - The current selection
+ * @param op - The operation that was applied
+ * @param mergePointOffset - For merge_block ops, the absolute offset where the merge happened
+ * @returns The transformed selection
+ *
+ * @example
+ * ```ts
+ * const sel = { anchor: { offset: 0 }, focus: { offset: 5 } };
+ * const newSel = transformSelection(sel, { type: 'insert_text', offset: 0, text: 'hi' });
+ * // newSel = { anchor: { offset: 2 }, focus: { offset: 7 } }
+ * ```
+ */
+export declare function transformSelection(selection: Selection, op: Operation, mergePointOffset?: number): Selection;
+//# sourceMappingURL=selection-transform.d.ts.map

package/dist/selection-transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-transform.d.ts","sourceRoot":"","sources":["../src/selection-transform.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AA6D3D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,EACpB,EAAE,EAAE,SAAS,EACb,gBAAgB,CAAC,EAAE,MAAM,GACxB,SAAS,CAaX"}

package/dist/selection-transform.js

@@ -0,0 +1,87 @@
+/**
+ * Pure selection transform functions.
+ * Adjusts cursor/selection positions in response to document operations.
+ */
+/**
+ * Transform a single offset in response to an operation.
+ * Returns the adjusted offset.
+ *
+ * @param offset - The absolute document offset to transform
+ * @param op - The operation that was applied
+ * @param mergePointOffset - For merge_block ops, the absolute offset of the merge point
+ * @returns The transformed offset
+ */
+function transformOffset(offset, op, mergePointOffset) {
+    switch (op.type) {
+        case 'insert_text': {
+            // Text inserted at op.offset pushes everything at or after forward
+            if (offset >= op.offset) {
+                return offset + op.text.length;
+            }
+            return offset;
+        }
+        case 'delete_text': {
+            const deleteEnd = op.offset + op.count;
+            if (offset <= op.offset) {
+                return offset;
+            }
+            if (offset <= deleteEnd) {
+                // Cursor was inside deleted range — collapse to delete start
+                return op.offset;
+            }
+            // Cursor was after deleted range
+            return offset - op.count;
+        }
+        case 'split_block': {
+            // A virtual \n is inserted at the split point.
+            // Positions AT the split point shift forward so the cursor lands
+            // at the start of the new block (standard Enter-key behaviour).
+            if (offset >= op.offset) {
+                return offset + 1;
+            }
+            return offset;
+        }
+        case 'merge_block': {
+            // A virtual \n is removed at the merge point
+            if (mergePointOffset !== undefined && offset > mergePointOffset) {
+                return offset - 1;
+            }
+            return offset;
+        }
+        // These operations don't change offsets
+        case 'set_span_marks':
+        case 'set_block_attrs':
+        case 'set_block_type':
+        case 'set_meta':
+            return offset;
+    }
+}
+/**
+ * Transform a selection in response to an operation.
+ * Both anchor and focus are independently adjusted.
+ *
+ * @param selection - The current selection
+ * @param op - The operation that was applied
+ * @param mergePointOffset - For merge_block ops, the absolute offset where the merge happened
+ * @returns The transformed selection
+ *
+ * @example
+ * ```ts
+ * const sel = { anchor: { offset: 0 }, focus: { offset: 5 } };
+ * const newSel = transformSelection(sel, { type: 'insert_text', offset: 0, text: 'hi' });
+ * // newSel = { anchor: { offset: 2 }, focus: { offset: 7 } }
+ * ```
+ */
+export function transformSelection(selection, op, mergePointOffset) {
+    const newAnchor = transformOffset(selection.anchor.offset, op, mergePointOffset);
+    const newFocus = transformOffset(selection.focus.offset, op, mergePointOffset);
+    // Avoid creating a new object if nothing changed
+    if (newAnchor === selection.anchor.offset && newFocus === selection.focus.offset) {
+        return selection;
+    }
+    return {
+        anchor: { offset: newAnchor },
+        focus: { offset: newFocus },
+    };
+}
+//# sourceMappingURL=selection-transform.js.map

package/dist/selection-transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-transform.js","sourceRoot":"","sources":["../src/selection-transform.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;GAQG;AACH,SAAS,eAAe,CAAC,MAAc,EAAE,EAAa,EAAE,gBAAyB;IAC/E,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;QAChB,KAAK,aAAa,CAAC,CAAC,CAAC;YACnB,mEAAmE;YACnE,IAAI,MAAM,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;gBACxB,OAAO,MAAM,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC;YACjC,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,KAAK,aAAa,CAAC,CAAC,CAAC;YACnB,MAAM,SAAS,GAAG,EAAE,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC;YACvC,IAAI,MAAM,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;gBACxB,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,IAAI,MAAM,IAAI,SAAS,EAAE,CAAC;gBACxB,6DAA6D;gBAC7D,OAAO,EAAE,CAAC,MAAM,CAAC;YACnB,CAAC;YACD,iCAAiC;YACjC,OAAO,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC;QAC3B,CAAC;QAED,KAAK,aAAa,CAAC,CAAC,CAAC;YACnB,+CAA+C;YAC/C,iEAAiE;YACjE,gEAAgE;YAChE,IAAI,MAAM,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;gBACxB,OAAO,MAAM,GAAG,CAAC,CAAC;YACpB,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,KAAK,aAAa,CAAC,CAAC,CAAC;YACnB,6CAA6C;YAC7C,IAAI,gBAAgB,KAAK,SAAS,IAAI,MAAM,GAAG,gBAAgB,EAAE,CAAC;gBAChE,OAAO,MAAM,GAAG,CAAC,CAAC;YACpB,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,wCAAwC;QACxC,KAAK,gBAAgB,CAAC;QACtB,KAAK,iBAAiB,CAAC;QACvB,KAAK,gBAAgB,CAAC;QACtB,KAAK,UAAU;YACb,OAAO,MAAM,CAAC;IAClB,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,kBAAkB,CAChC,SAAoB,EACpB,EAAa,EACb,gBAAyB;IAEzB,MAAM,SAAS,GAAG,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,gBAAgB,CAAC,CAAC;IACjF,MAAM,QAAQ,GAAG,eAAe,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAE/E,iDAAiD;IACjD,IAAI,SAAS,KAAK,SAAS,CAAC,MAAM,CAAC,MAAM,IAAI,QAAQ,KAAK,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QACjF,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO;QACL,MAAM,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE;QAC7B,KAAK,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE;KAC5B,CAAC;AACJ,CAAC"}