creo-edit 0.1.0

package/dist/input/keymap.d.ts

@@ -0,0 +1,47 @@
+import type { Mark } from "../model/types";
+import type { SetBlockTypePayload } from "../commands/structuralCommands";
+/**
+ * Cross-platform "mod" key — ⌘ on macOS, Ctrl elsewhere.
+ *
+ * The detection is conservative: we look at navigator.platform first; in
+ * test / SSR environments (no navigator) we default to non-mac.
+ */
+export declare function isMac(): boolean;
+export type KeymapHit = {
+    kind: "toggleMark";
+    mark: Mark;
+} | {
+    kind: "setBlockType";
+    payload: SetBlockTypePayload;
+} | {
+    kind: "indent";
+} | {
+    kind: "outdent";
+} | {
+    kind: "undo";
+} | {
+    kind: "redo";
+} | {
+    kind: "selectAll";
+} | {
+    kind: "moveWord";
+    direction: -1 | 1;
+    extend: boolean;
+} | {
+    kind: "moveLineEdge";
+    direction: -1 | 1;
+    extend: boolean;
+} | {
+    kind: "moveDocEdge";
+    direction: -1 | 1;
+    extend: boolean;
+};
+/**
+ * Match a keyboard event against the default chord table. Returns the hit if
+ * the key is a known chord, else `null` so the caller can fall through to
+ * navigation / text editing.
+ *
+ * The matcher is intentionally event-oriented rather than string-oriented;
+ * it sidesteps the "Ctrl+Shift+K" parsing rabbit-hole.
+ */
+export declare function matchKeymap(e: KeyboardEvent): KeymapHit | null;

package/dist/input/mobile.d.ts

@@ -0,0 +1,13 @@
+import type { Store } from "creo";
+import type { DocState, Selection } from "../model/types";
+export declare function isCoarsePointer(): boolean;
+/** Test-only override (clears the cache so the next read re-detects). */
+export declare function __resetCoarsePointerCache(): void;
+export type ViewportStores = {
+    selStore: Store<Selection>;
+    docStore: Store<DocState>;
+};
+export type ViewportHandle = {
+    destroy: () => void;
+};
+export declare function attachVisualViewport(root: HTMLElement, stores: ViewportStores): ViewportHandle;

package/dist/input/nativeInput.d.ts

@@ -0,0 +1,27 @@
+import type { Store } from "creo";
+import type { DocState, Selection } from "../model/types";
+import type { DispatchableCommand } from "../createEditor";
+import { type UploadFn } from "../commands/imageCommands";
+import type { Registry } from "../plugin/registry";
+import type { TriggerManager } from "../plugin/triggers";
+export type NativeInputStores = {
+    docStore: Store<DocState>;
+    selStore: Store<Selection>;
+};
+export type NativeInputOptions = {
+    dispatch: (cmd: DispatchableCommand) => void;
+    undo: () => void;
+    redo: () => void;
+    selectAll: () => void;
+    /** Optional upload hook for pasted / dropped image files. */
+    uploadImage?: UploadFn;
+    /** Plugin registry — keymap matching, command dispatch for plugin chords. */
+    registry: Registry;
+    /** Trigger manager — watches text insertion + key events for plugin
+     *  triggers (slash commands, mentions, etc.). */
+    triggers: TriggerManager;
+};
+export type NativeInputHandle = {
+    destroy: () => void;
+};
+export declare function attachNativeInput(root: HTMLElement, stores: NativeInputStores, options: NativeInputOptions): NativeInputHandle;

package/dist/markdown/serialize.d.ts

@@ -0,0 +1,2 @@
+import type { SerializedDoc } from "../createEditor";
+export declare function docToMarkdown(doc: SerializedDoc): string;

package/dist/model/blockText.d.ts

@@ -0,0 +1,42 @@
+import type { Block, InlineRun, Mark } from "./types";
+/** Blocks whose content is a single InlineRun[] (paragraphs, headings, list items). */
+export type TextBearingBlock = Extract<Block, {
+    runs: InlineRun[];
+}>;
+export declare function isTextBearing(block: Block): block is TextBearingBlock;
+/** Total length of plain text across all runs of a text-bearing block. */
+export declare function runsLength(runs: InlineRun[]): number;
+export declare function blockTextLength(block: TextBearingBlock): number;
+/**
+ * Normalize: drop empty runs and merge adjacent runs with identical marks.
+ * Always returns a fresh array.
+ */
+export declare function normalizeRuns(runs: InlineRun[]): InlineRun[];
+/**
+ * Find the run + local offset that owns the given character position.
+ * `offset` is clamped to [0, runsLength].
+ *
+ * The "boundary" rule: if `offset` lands exactly between two runs, we report
+ * `runIndex` = the index of the run that *ends* at that boundary (so callers
+ * inserting text inherit the LEFT run's marks by default).
+ */
+export type RunPos = {
+    runIndex: number;
+    localOffset: number;
+    /** Aggregate length of all runs strictly before runIndex. */
+    prefixLen: number;
+};
+export declare function locateRun(runs: InlineRun[], offset: number): RunPos;
+/** Marks the next inserted character should inherit at `offset`. */
+export declare function marksAt(runs: InlineRun[], offset: number): ReadonlySet<Mark> | undefined;
+/**
+ * Insert `text` (with optional `marks`) at character `offset`.
+ * Returns a new runs array.
+ */
+export declare function insertText(runs: InlineRun[], offset: number, text: string, marks?: ReadonlySet<Mark>): InlineRun[];
+/** Delete characters in [start, end). Returns a new runs array. */
+export declare function deleteRange(runs: InlineRun[], start: number, end: number): InlineRun[];
+/** Split runs at offset into [left, right] arrays. */
+export declare function splitRunsAt(runs: InlineRun[], offset: number): [InlineRun[], InlineRun[]];
+/** Concatenate two runs arrays, normalizing the seam. */
+export declare function concatRuns(a: InlineRun[], b: InlineRun[]): InlineRun[];

package/dist/model/cellAccess.d.ts

@@ -0,0 +1,2 @@
+export type { RunsCtx } from "../plugin/types";
+export { runsAt, runsLengthAt } from "../plugin/runsAt";

package/dist/model/doc.d.ts

@@ -0,0 +1,45 @@
+import type { Block, BlockId, BlockSpec, DocState, FracIndex } from "./types";
+/** Cheap, monotonically increasing block id with a per-session prefix. */
+export declare function newBlockId(): BlockId;
+export declare function emptyDoc(): DocState;
+/** Build a DocState from a list of blocks (will assign indices if missing). */
+export declare function docFromBlocks(blocks: BlockSpec[]): DocState;
+/**
+ * Returns the insertion index in `order` such that the new key sorts at that
+ * position. Pure binary search by `Block.index`.
+ */
+export declare function findInsertionPos(doc: DocState, index: FracIndex): number;
+/** Returns the position of `id` in `order`, or -1 if not found. */
+export declare function findPos(doc: DocState, id: BlockId): number;
+/**
+ * Insert `block` between the blocks at positions [pos-1] and [pos].
+ * The new block's `index` is overwritten with a fractional key in that gap.
+ */
+export declare function insertAt(doc: DocState, pos: number, block: BlockSpec): DocState;
+/** Insert a block whose `index` has already been assigned. */
+export declare function insertWithIndex(doc: DocState, block: Block): DocState;
+/** Insert `block` immediately after `afterId` (or at the start if null). */
+export declare function insertAfter(doc: DocState, afterId: BlockId | null, block: BlockSpec): DocState;
+/** Replace the block with the same id. */
+export declare function updateBlock(doc: DocState, block: Block): DocState;
+/** Remove a block. */
+export declare function removeBlock(doc: DocState, id: BlockId): DocState;
+/**
+ * Remove multiple blocks in one pass. Single allocation of the new order
+ * array — avoids the O(M*N) cost of calling removeBlock M times in a loop.
+ */
+export declare function removeBlocks(doc: DocState, ids: Iterable<BlockId>): DocState;
+/**
+ * Bulk-insert: drop `n` new blocks evenly spaced into the gap before `pos`.
+ * Faster than calling insertAt repeatedly because we compute all keys at once.
+ *
+ * Builds the new `order` array in a single pass (O(N + M) where N = current
+ * doc size, M = inserted block count) instead of splicing in a loop. Splicing
+ * inside a loop is O(N) per call → O(M*N) overall, which hurts catastrophically
+ * for large pastes (e.g. ~10k paragraphs from a long document).
+ */
+export declare function insertManyAt(doc: DocState, pos: number, blocks: BlockSpec[]): DocState;
+export declare function maybeRebalance(doc: DocState): DocState;
+export declare function iterBlocks(doc: DocState): IterableIterator<Block>;
+export declare function getBlock(doc: DocState, id: BlockId): Block | undefined;
+export declare function blockAt(doc: DocState, pos: number): Block | undefined;

package/dist/model/fractional.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Fractional indexing over a base-62 alphabet.
+ *
+ * Alphabet ordering (string compare matches numeric order):
+ *   '0'..'9' < 'A'..'Z' < 'a'..'z'  →  62 symbols.
+ *
+ * A key is a non-empty string of alphabet characters; lexicographic comparison
+ * yields the same ordering as the rationals they represent. The first symbol's
+ * value is the most-significant fractional digit.
+ *
+ * `generateBetween(a, b)` returns a key strictly between `a` and `b`. `null`
+ * means "no bound" — use it for the document's first or last position.
+ *
+ * `generateN(a, b, n)` produces `n` evenly-spaced keys between `a` and `b` in
+ * O(n + log span); used by bulk-paste so we don't pay O(n²) re-midpointing.
+ */
+declare function ord(c: string): number;
+declare function chr(n: number): string;
+/** Random base-62 character — used as a tail to keep keys distinct. */
+declare function randomChar(): string;
+/** Strip trailing MIN_CHAR ('0') noise from a key (those bits are zeros). */
+declare function trimZeros(s: string): string;
+/**
+ * Generate a key strictly between `a` and `b`.
+ *  - If a==null, the new key is < b.
+ *  - If b==null, the new key is > a.
+ *  - Both null → returns "U" (mid-range).
+ */
+export declare function generateBetween(a: string | null, b: string | null): string;
+/**
+ * Generate `n` evenly-spaced keys strictly between `a` and `b`.
+ * Returns them in ascending order.
+ *
+ * O(n) total — far cheaper than calling generateBetween repeatedly with
+ * a moving cursor (which would degrade by binary descent each step).
+ */
+export declare function generateN(a: string | null, b: string | null, n: number): string[];
+/** Soft cap; once any key exceeds this length, schedule a rebalance. */
+export declare const REBALANCE_THRESHOLD = 32;
+/** Returns true if any key in the sorted list exceeds REBALANCE_THRESHOLD. */
+export declare function needsRebalance(keys: string[]): boolean;
+/**
+ * Produce a fresh, evenly-spaced sequence of N keys, replacing an existing
+ * sorted sequence. Used by the doc layer when keys grow past threshold.
+ */
+export declare function rebalance(count: number): string[];
+export declare const __internal: {
+    ALPHABET: string;
+    BASE: number;
+    MIN_CHAR: string;
+    MAX_CHAR: string;
+    ord: typeof ord;
+    chr: typeof chr;
+    randomChar: typeof randomChar;
+    trimZeros: typeof trimZeros;
+};
+export {};

package/dist/model/rebalance.d.ts

@@ -0,0 +1,12 @@
+import type { Store } from "creo";
+import type { DocState } from "./types";
+/**
+ * Watch a docStore and schedule a microtask rebalance whenever any
+ * fractional index grows past the soft threshold.
+ *
+ * Rebalance assigns fresh, evenly-spaced indices to every block (preserving
+ * order). It's O(n) and runs at most once per microtask, so worst-case a
+ * 600k-block doc rebalances in ~50ms — and only ever triggers under
+ * adversarial insertion patterns.
+ */
+export declare function attachAutoRebalance(docStore: Store<DocState>): () => void;

package/dist/model/types.d.ts

@@ -0,0 +1,133 @@
+export type BlockId = string;
+export type FracIndex = string;
+export type Mark = "b" | "i" | "u" | "s" | "code";
+export type InlineRun = {
+    text: string;
+    marks?: ReadonlySet<Mark>;
+};
+export type ParagraphBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "p";
+    runs: InlineRun[];
+};
+/**
+ * Code-block — like a paragraph, but rendered monospaced inside a <pre>.
+ * Enter inside the block inserts a newline character (it does NOT split
+ * the block) — the editor treats the whole code block as a single
+ * multi-line region. `lang` is an optional language hint preserved across
+ * markdown / HTML round-trips; the editor itself doesn't syntax-highlight.
+ */
+export type CodeBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "code";
+    runs: InlineRun[];
+    lang?: string;
+};
+export type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+export type HeadingBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+    runs: InlineRun[];
+};
+export type ListItemBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "li";
+    ordered: boolean;
+    depth: 0 | 1 | 2 | 3;
+    runs: InlineRun[];
+};
+export type ImageBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "img";
+    src: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+};
+export type TableBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "table";
+    rows: number;
+    cols: number;
+    cells: InlineRun[][][];
+};
+/**
+ * Multi-column layout — N side-by-side columns of inline runs. Internal
+ * cursor path = [colIndex, charOffset]. Same model shape as a 1-row
+ * table but rendered as flex columns instead of an HTML <table>.
+ */
+export type ColumnsBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "columns";
+    cols: number;
+    /** cells[c] is the inline-runs sequence for column c. */
+    cells: InlineRun[][];
+};
+/**
+ * Calendar — non-editable atomic block. Renders one row per day starting
+ * at `date` for `days` consecutive days. Path encoding: `[side]` (0
+ * = before, 1 = after) like image. Built as a first-party demo of the
+ * `isAtomic` plugin contract — third-party plugins follow the same shape.
+ */
+export type CalendarBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "calendar";
+    /** Anchor date in ISO YYYY-MM-DD form. */
+    date: string;
+    /** Number of consecutive days to render starting at `date`. */
+    days: number;
+};
+/**
+ * DateMarker — slim non-editable atomic block. One line, e.g.
+ * "Wednesday, 2 Sep." Used to break up a journal-style document into
+ * day sections that the user can write between.
+ */
+export type DateMarkerBlock = {
+    id: BlockId;
+    index: FracIndex;
+    type: "date-marker";
+    /** Anchor date in ISO YYYY-MM-DD form. */
+    date: string;
+};
+export type Block = ParagraphBlock | HeadingBlock | ListItemBlock | CodeBlock | ImageBlock | TableBlock | ColumnsBlock | CalendarBlock | DateMarkerBlock;
+export type BlockType = Block["type"];
+/**
+ * Distributive `Omit` — applies Omit to each member of a union.
+ * Plain `Omit<Union, K>` collapses the union into its intersection of fields,
+ * which loses the discriminated-union shape.
+ */
+export type DistOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/** A block missing its fractional `index` — used by callers that hand the doc
+ *  layer un-indexed blocks for insertion. */
+export type BlockSpec = DistOmit<Block, "index">;
+export type DocState = {
+    byId: Map<BlockId, Block>;
+    order: BlockId[];
+};
+/**
+ * Anchor — points to a position inside a block.
+ *  - For text-bearing blocks (p / h1..h6 / li): path = [charOffset]
+ *  - For tables:                           path = [row, col, charOffset]
+ *  - For images:                           path = [side]   side: 0 = before, 1 = after
+ */
+export type Anchor = {
+    blockId: BlockId;
+    path: number[];
+    offset: number;
+};
+export type Selection = {
+    kind: "caret";
+    at: Anchor;
+} | {
+    kind: "range";
+    anchor: Anchor;
+    focus: Anchor;
+};

package/dist/plugin/anchorCodec.d.ts

@@ -0,0 +1,18 @@
+import type { AnchorCodec, DomPoint } from "./types";
+export declare function registerAnchorCodec(type: string, codec: AnchorCodec): void;
+export declare function getAnchorCodec(type: string): AnchorCodec | null;
+/** Visible-character offset from start of `scopeEl` to (hitNode, localOffset). */
+export declare function offsetWithinScope(scopeEl: HTMLElement, hitNode: Node, localOffset: number): number;
+/** Walk descendant text nodes to find the (node, offset) at `charOffset`. */
+export declare function findTextPoint(scopeEl: HTMLElement, charOffset: number): DomPoint;
+/** Default codec — text-bearing blocks land here when they don't register
+ *  their own. Path encoding: [charOffset]. */
+export declare const defaultTextCodec: AnchorCodec;
+export declare const codeBlockCodec: AnchorCodec;
+export declare const atomicCodec: AnchorCodec;
+export declare const imageCodec: AnchorCodec;
+export declare function findOwningBlockEl(node: Node): HTMLElement | null;
+/** Pluggable anchor → which is just looking up the registered codec.
+ *  Centralized here so anchorMap.ts and other consumers share one path. */
+export declare function lookupAnchorCodec(kind: string): AnchorCodec | null;
+export type { DomPoint };

package/dist/plugin/atomic.d.ts

@@ -0,0 +1,2 @@
+export declare function registerAtomic(type: string): void;
+export declare function isAtomicBlockType(type: string): boolean;

package/dist/plugin/builtin.d.ts

@@ -0,0 +1,10 @@
+import type { EditorPlugin } from "./types";
+import { cellsPlugin } from "../plugins/cells";
+export declare const paragraphPlugin: EditorPlugin;
+export declare const headingPlugin: EditorPlugin;
+export declare const listPlugin: EditorPlugin;
+export declare const codeBlockPlugin: EditorPlugin;
+export declare const imagePlugin: EditorPlugin;
+export { cellsPlugin };
+/** All built-in plugins, in registration order. */
+export declare const defaultPlugins: EditorPlugin[];

package/dist/plugin/decorations.d.ts

@@ -0,0 +1,35 @@
+import type { Store } from "creo";
+import type { BlockId, DocState } from "../model/types";
+import type { Registry } from "./registry";
+export type DecorationManagerOptions = {
+    registry: Registry;
+    docStore: Store<DocState>;
+    /** Editor root (the contentEditable div). The decoration layer mounts as
+     *  a sibling, positioned to overlay the same screen rect. */
+    editorRoot: HTMLElement;
+};
+export declare class DecorationManager {
+    private opts;
+    private layer;
+    private mounted;
+    private rafQueued;
+    private rafSyncRequested;
+    private unsub;
+    private resizeObserver;
+    /** Hovered block id — surfaced to decorations via dataset on the layer
+     *  so they can style themselves with sibling CSS or read it directly. */
+    private hoveredBlockId;
+    constructor(opts: DecorationManagerOptions);
+    destroy(): void;
+    /** Currently hovered block id (or null). Decorations read this via
+     *  `manager.hoveredBlock()` to decide their own visibility. */
+    hoveredBlock(): BlockId | null;
+    private scheduleSync;
+    private schedulePosition;
+    private queueFlush;
+    private sync;
+    private mountDecoration;
+    private position;
+    private onPointerMove;
+    private onPointerLeave;
+}

package/dist/plugin/htmlCodec.d.ts

@@ -0,0 +1,8 @@
+import type { Block, BlockSpec } from "../model/types";
+import type { HtmlBlockCodec, HtmlParseCtx } from "./types";
+type ParserFn = (el: HTMLElement, ctx: HtmlParseCtx) => BlockSpec | null;
+type SerializerFn = (b: Block) => string;
+export declare function registerHtmlBlockCodec(type: string, codec: HtmlBlockCodec): void;
+export declare function getHtmlParserForTag(tag: string): ParserFn | null;
+export declare function getHtmlSerializer(type: string): SerializerFn | null;
+export {};

package/dist/plugin/keymapMatch.d.ts

@@ -0,0 +1,2 @@
+import type { CommandCtx, KeymapDef } from "./types";
+export declare function matchPluginKeymap(e: KeyboardEvent, entries: KeymapDef[], ctx: CommandCtx): KeymapDef | null;

package/dist/plugin/registry.d.ts

@@ -0,0 +1,29 @@
+import type { CommandCtx, CommandDef, DecorationDef, EditorPlugin, KeymapDef, TriggerDef } from "./types";
+export declare class Registry {
+    readonly commands: Map<string, CommandDef<unknown>>;
+    readonly keymap: KeymapDef[];
+    readonly triggers: TriggerDef[];
+    readonly decorations: DecorationDef[];
+    readonly coalescePrefixes: Set<string>;
+    /** Set of all known block type discriminators (for fast existence checks). */
+    readonly knownBlockTypes: Set<string>;
+    install(plugin: EditorPlugin): void;
+    /**
+     * Look up a command by t and run it; returns false if the command is
+     * unknown OR if the command itself returned false (signaling "did not
+     * apply"). Used by both the editor dispatch path and the keymap matcher.
+     */
+    runCommand(t: string, payload: unknown, ctx: CommandCtx): boolean;
+    /** Should the given history tag coalesce with prior matching tags? */
+    shouldCoalesce(tag: string): boolean;
+}
+import type { PublicView } from "creo";
+import type { Block } from "../model/types";
+export declare function registerView(type: string, v: PublicView<{
+    block: Block;
+    key?: string;
+}, void>): void;
+export declare function getView(type: string): PublicView<{
+    block: Block;
+    key?: string;
+}, void> | null;

package/dist/plugin/runsAt.d.ts

@@ -0,0 +1,9 @@
+import type { Anchor, Block } from "../model/types";
+import type { RunsCtx } from "./types";
+type RunsAtFn = (b: Block, a: Anchor) => RunsCtx | null;
+export declare function registerRunsAt(type: string, fn: RunsAtFn): void;
+export declare function runsAt(block: Block, anchor: Anchor): RunsCtx | null;
+/** Total length of the runs container at `anchor` — convenience helper used
+ *  by both text commands and the IME composition diff. */
+export declare function runsLengthAt(block: Block, anchor: Anchor): number;
+export {};

package/dist/plugin/serializeCodec.d.ts

@@ -0,0 +1,6 @@
+import type { Block, BlockId, BlockSpec } from "../model/types";
+import type { SerializeCodec } from "./types";
+export declare function registerSerializeCodec(type: string, codec: SerializeCodec): void;
+export declare function getSerializeCodec(type: string): SerializeCodec | null;
+export declare function serializeBlock(b: Block): unknown | null;
+export declare function deserializeBlock(type: string, s: unknown, id: BlockId): BlockSpec | null;

package/dist/plugin/triggers.d.ts

@@ -0,0 +1,33 @@
+import type { Store } from "creo";
+import type { DocState, Selection } from "../model/types";
+import type { DispatchableCommand } from "../createEditor";
+import type { Registry } from "./registry";
+export type TriggerManagerOptions = {
+    registry: Registry;
+    docStore: Store<DocState>;
+    selStore: Store<Selection>;
+    dispatch: (cmd: DispatchableCommand) => void;
+};
+export declare class TriggerManager {
+    private opts;
+    private active;
+    private unsubSel;
+    private unsubDoc;
+    constructor(opts: TriggerManagerOptions);
+    destroy(): void;
+    /**
+     * Re-derive the active trigger's state from the current doc + selection.
+     * Closes the menu if any of:
+     *   - caret left the trigger's block
+     *   - caret moved before the trigger char position
+     *   - the trigger char at the start position is no longer there
+     * Otherwise, recomputes the live query string and notifies the controller.
+     */
+    private reconcile;
+    /** Called by nativeInput AFTER a successful insertText dispatch. */
+    onTextInserted(text: string): void;
+    /** Called by nativeInput at the top of onKeyDown. Returns true if consumed. */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    isActive(): boolean;
+    close(): void;
+}