@sobree/core 0.1.23 → 0.1.24

package/dist/editor/index.d.ts

@@ -20,22 +20,6 @@ export type { ApiRangeType, BlockInfo, ChangePayload, CommandBus, CommandDefinit
 export type { CellRef, InsertAt, InsertColumnOpts, InsertRowOpts, MergeCellsOpts, } from './types';
 export { runsLength } from '../doc/runs';
 export type { RunPropertiesPatch };
-/**
- * Public editor surface.
- *
- * Two entry points for every operation:
- *   - Core methods take `BlockRef` / `InlinePosition` / `Range` and
- *     return `EditResult`. These are the wire-callable API — same
- *     contract for in-process toolbars, headless Y peers (HeadlessSobree),
- *     and future MCP wrappers.
- *   - "AtSelection" sugar reads the live DOM selection, builds the
- *     position/range for you, and delegates to the core. Use these in
- *     in-process UI code.
- *
- * Mutations enforce optimistic locking via block `version` numbers.
- * Conflicts return `{ ok: false, error: { code: "optimistic-lock", … } }`
- * rather than throwing.
- */
 export declare class Editor {
     readonly host: HTMLElement;
     readonly selection: EditorSelection;
@@ -160,6 +144,21 @@ export declare class Editor {
      * and `emitChangeNow` sync only when this flag is set.
      */
     private domDirty;
+    /**
+     * Ids of editable textbox frames whose DOM the user has edited since
+     * the last sync. Frames live in the floating overlay (outside the
+     * body content hosts), so they need their own read-back path —
+     * `syncFromDom` re-serialises each dirty frame into
+     * `anchoredFrames[id].content.body`.
+     */
+    private readonly dirtyFrameIds;
+    /**
+     * Set by `syncFromDom` when the pending change was a pure live frame
+     * keystroke; read (and reset) by `emitChangeNow` into the change
+     * payload's `liveFrameEdit`. Lets the host skip the overlay repaint
+     * that would clobber the caret, while still repainting on undo/remote.
+     */
+    private pendingLiveFrameEdit;
     /**
      * Kernel seam handed to the behaviour modules (`ops/*`, `query`). Built
      * once in the constructor; closes over this instance's privates so the
@@ -482,6 +481,32 @@ export declare class Editor {
      */
     private ensureCurrent;
     private syncFromDom;
+    /**
+     * Re-read the DOM of each dirty editable textbox frame into the AST.
+     * The frame element IS the serialization host (the block renderer paints
+     * its body directly into it), so `serializeHostsToDocument([el])` yields
+     * the same `Block[]` shape as a body host. Matched to the AST frame by
+     * its stable `data-anchor-id`. Pure body swap — geometry/anchor untouched.
+     */
+    private syncFramesFromDom;
+    /**
+     * The id of the editable textbox frame the caret currently sits in, or
+     * null when the selection is in ordinary body flow. Used to route an
+     * `input` event to the frame read-back instead of the body read-back.
+     */
+    private editedFrameId;
+    /**
+     * Toggle a mark on the caret inside an editable textbox frame, natively
+     * (`document.execCommand`), so the body-selection mark path doesn't have
+     * to understand frame coordinates. The resulting `<b>`/`<i>`/`<u>` tags
+     * round-trip through the frame read-back (the inline serializer maps them
+     * to run properties). Returns false when the caret isn't in a frame, so
+     * the mark command falls back to the body path.
+     */
+    applyFrameMark(tag: string): boolean;
+    /** Active state of `tag` at a frame caret (toolbar highlight), or null
+     *  when the caret isn't in a frame. */
+    frameMarkActive(tag: string): boolean | null;
     /**
      * Schedule a DOM-driven change emit. Called from the `input` listener
      * when the user types — the DOM is the source of truth and we sync the

package/dist/editor/types.d.ts

@@ -94,6 +94,15 @@ export interface ChangePayload {
     document: SobreeDocument;
     revision: number;
     documentVersion: number;
+    /**
+     * True when this change came from a live keystroke inside an editable
+     * textbox frame — the frame's DOM already holds the edit, so the host
+     * can skip repainting the floating overlay (which would clobber the
+     * caret). Absent / false for body edits, API mutations, undo/redo, and
+     * remote (Y.Doc-driven) changes — those re-render from the AST, so the
+     * overlay IS stale and must repaint.
+     */
+    liveFrameEdit?: boolean;
 }
 /** Summary of a top-level block, for `getBlocks()` and list-style UIs. */
 export interface BlockInfo {
@@ -171,6 +180,18 @@ export interface EditorLike {
         expect?: Record<string, number>;
     }): EditResult<void>;
     readonly selection: EditorSelectionLike;
+    /**
+     * When the caret sits in an editable textbox frame, toggle a mark
+     * (`"strong"`/`"em"`/`"u"`/`"s"`/`"sup"`/`"sub"`) natively on that
+     * frame's selection — the frame read-back captures the result. Returns
+     * `true` when handled (caret was in a frame), `false` otherwise so the
+     * caller falls back to the body mark path. Optional: implemented by the
+     * DOM Editor, absent on headless peers (which have no frame DOM).
+     */
+    applyFrameMark?(tag: string): boolean;
+    /** Active state of `tag` at the frame caret, or `null` when the caret
+     *  isn't in a frame (caller uses the body `isMarkActive`). */
+    frameMarkActive?(tag: string): boolean | null;
 }
 export type EditorEvent = "change" | "selection" | "keydown" | "track-changes-change";
 export type EditorEventPayload = {

package/dist/editor/view/docRenderer/anchorLayer.d.ts

@@ -16,6 +16,16 @@ export interface AnchorLayerContext {
      * stacked text (test/headless fallback).
      */
     renderBody?: (blocks: Block[], host: HTMLElement) => void;
+    /**
+     * When true, textbox frames become editable islands: the frame turns
+     * into its own `contentEditable` host (`pointer-events:auto`) so the
+     * user can click in and type. The editor wires the read-back that
+     * serialises the frame's DOM into `anchoredFrames[id].content.body`.
+     * False / absent → display-only overlay (read-only mode, decorations,
+     * headless). Pictures, shapes, and groups stay non-interactive
+     * regardless — only textbox prose is editable.
+     */
+    editable?: boolean;
 }
 /**
  * Build the per-page anchor layer. Returns a single `<div>` whose