edytor 4.0.0 → 5.0.0

package/dist/session/handles.d.ts

@@ -15,28 +15,15 @@
 import { Block } from '../block/block.svelte.js';
 import { InlineBlock } from '../block/inlineBlock.svelte.js';
 import { Text } from '../text/text.svelte.js';
-import type { ContentItem, Destination, DocChange } from '../crdt/index.js';
+import type { Destination, DocChange } from '../crdt/index.js';
+import { type Part } from '../crdt/parts.js';
 import type { Edytor } from '../edytor.svelte.js';
 import type { JSONText } from '../utils/json.js';
 export type TextRunItem = {
     text: string;
     marks?: Record<string, unknown>;
 };
-/** A block's content as the index shows it: text segments between atoms, each at its display start. */
-export type ContentPart = {
-    kind: 'text';
-    start: number;
-    items: TextRunItem[];
-    length: number;
-} | {
-    kind: 'inline';
-    start: number;
-    item: ContentItem & {
-        kind: 'inline';
-    };
-};
-/** Segments and atoms, alternating, starting and ending with a segment. */
-export declare const contentParts: (items: readonly ContentItem[]) => ContentPart[];
+export type { Part as ContentPart } from '../crdt/parts.js';
 /**
  * A text segment's items as `JSONText` runs (`text.value`): empty items
  * dropped, adjacent runs with the same marks joined, each run's marks a
@@ -65,7 +52,7 @@ export declare class Handles {
      * Block `id`'s content parts — from its runs, which the index keeps per
      * block and reads-your-writes (a write elsewhere re-derives nothing here).
      */
-    parts: (id: string) => ContentPart[];
+    parts: (id: string) => readonly Part[];
     /** Forget the handles of the blocks a commit removed. */
     prune: (change: DocChange) => void;
     clear: () => void;

package/dist/session/handles.js

@@ -15,29 +15,7 @@
 import { Block } from '../block/block.svelte.js';
 import { InlineBlock } from '../block/inlineBlock.svelte.js';
 import { Text } from '../text/text.svelte.js';
-/** Segments and atoms, alternating, starting and ending with a segment. */
-export const contentParts = (items) => {
-    const parts = [];
-    let segment = [];
-    let start = 0;
-    let at = 0;
-    const close = () => {
-        parts.push({ kind: 'text', start, items: segment, length: at - start });
-        segment = [];
-    };
-    for (const item of items) {
-        if (item.kind === 'text') {
-            segment.push({ text: item.text, ...(item.marks ? { marks: item.marks } : {}) });
-            at += item.text.length;
-            continue;
-        }
-        close();
-        parts.push({ kind: 'inline', start: at, item });
-        start = ++at;
-    }
-    close();
-    return parts;
-};
+import { partsOf } from '../crdt/parts.js';
 /**
  * A text segment's items as `JSONText` runs (`text.value`): empty items
  * dropped, adjacent runs with the same marks joined, each run's marks a
@@ -58,7 +36,7 @@ export const segmentJSON = (items) => {
     }
     return out;
 };
-const ROOT = contentParts([]);
+const ROOT = partsOf([]);
 /** The destination right after `block` among its siblings (`after: false`, right before it). */
 export const siblingSlot = (block, after = true) => {
     const parent = block.parent;
@@ -73,7 +51,7 @@ export class Handles {
     #blocks = new Map();
     #texts = new Map();
     #atoms = new Map();
-    /** Each block's parts at the index version they were read (the last read of a dead block). */
+    /** Each block's parts as last read (a dead block's: what it last showed). */
     #parts = new Map();
     constructor(edytor) {
         this.edytor = edytor;
@@ -119,24 +97,20 @@ export class Handles {
     parts = (id) => {
         if (id === 'root')
             return ROOT;
-        const { facade } = this.edytor;
-        const memo = this.#parts.get(id);
-        const runs = facade.runs(id);
-        if (memo?.runs === runs)
-            return memo.parts;
+        const parts = partsOf(this.edytor.facade.runs(id));
+        const last = this.#parts.get(id);
         // A dead block keeps what it last showed (a write's intent is minted from it).
-        if (memo && !facade.isVisibleBlock(id))
-            return memo.parts;
-        const parts = contentParts(runs);
-        this.#parts.set(id, { runs, parts });
+        if (last && last !== parts && !this.edytor.facade.isVisibleBlock(id))
+            return last;
+        this.#parts.set(id, parts);
         return parts;
     };
     /** Forget the handles of the blocks a commit removed. */
     prune = (change) => {
         for (const id of change.removed) {
-            for (const part of this.#parts.get(id)?.parts ?? [])
-                if (part.kind === 'inline' && this.#atoms.get(part.item.id)?.blockId === id)
-                    this.#atoms.delete(part.item.id);
+            for (const part of this.#parts.get(id) ?? [])
+                if (part.kind === 'inline' && this.#atoms.get(part.id)?.blockId === id)
+                    this.#atoms.delete(part.id);
             this.#blocks.delete(id);
             this.#texts.delete(id);
             this.#parts.delete(id);

package/dist/session/navigation.js

@@ -1,8 +1,9 @@
 import { getNextGraphemeEnd, getNextWordEndOffset, getPreviousGraphemeStart, getPreviousWordStartOffset } from '../text/wordBoundary.js';
 import { getSelectedBlocksInDocumentOrder, shownText } from '../selection/replaceSelection.js';
-import { atomSelection, segmentsOf } from './selection.js';
+import { atomSelection, pointOf, segmentsOf } from './selection.js';
 import { untargeted } from './attempt.js';
 import { siblingSlot } from './handles.js';
+import { partsOf } from '../crdt/parts.js';
 /**
  * With no target (`untargeted`: the value is `none`, no gesture placed the
  * host's caret), a navigation key does nothing (Notion): it is claimed, so
@@ -16,9 +17,8 @@ export const stayWithoutTarget = (edytor, prevent) => {
 /** An inline atom in a block's string. */
 const ATOM = '';
 /** A block's content as one string, each inline atom one `ATOM`. */
-const stringOf = (edytor, block) => edytor.facade
-    .contentItems(block)
-    .map((item) => (item.kind === 'text' ? item.text : ATOM))
+const stringOf = (edytor, block) => partsOf(edytor.facade.runs(block))
+    .map((part) => (part.kind === 'text' ? part.text : ATOM))
     .join('');
 /** A block's stop at its edge in `dir` (its end going forward, its start going backward). */
 const edge = (edytor, block, dir) => ({
@@ -68,9 +68,7 @@ const select = (edytor, anchor, focus) => {
         : null;
     if (atom?.kind === 'inline')
         return selection.select(atomSelection(start.block, atom.id, order > 0 ? 'after' : 'before'));
-    const [from, to] = [selection.textAt(start), selection.textAt(end)];
-    if (from && to)
-        selection.selectText(from.text, from.offset, to.text, to.offset, order > 0);
+    selection.selectAt(start, end, order > 0);
 };
 /**
  * One apply step for `unit` in `dir` (`left`/`right`: visual). Answers whether
@@ -94,8 +92,7 @@ export const move = (edytor, unit, key, extend) => {
         const first = blocks.map((block) => shownText(block, 'first')).find(Boolean);
         const last = blocks.map((block) => shownText(block, 'last')).findLast(Boolean);
         if (first && last) {
-            start = { block: first.blockId, offset: first.segStart };
-            end = { block: last.blockId, offset: last.segStart + last.length };
+            [start, end] = [pointOf(first, 0), pointOf(last, last.length)];
         }
         // Voids alone show no line: the blocks stay selected, except for the
         // document keys, whose target is the document's edge (`select` moves

package/dist/session/selection.d.ts

@@ -13,8 +13,9 @@
  * The view's `commit(value, cause)` (public: `select(value)`) is the only writer; the
  * presence payload is `serialize(value)`.
  */
-import type { BlockId, ContentItem } from '../crdt/index.js';
+import type { BlockId, ContentRun } from '../crdt/index.js';
 import type { DocAnchor, EdytorDoc } from '../crdt/edytor-doc.js';
+import type { Text } from '../text/text.svelte.js';
 export type Marks = Record<string, unknown>;
 export type SelectionValue = {
     readonly kind: 'none';
@@ -45,7 +46,9 @@ export type SelectionPoint = {
     block: BlockId;
     offset: number;
 };
-type TextRun = Extract<ContentItem, {
+/** A point inside a text segment (its block's `ordinal`-th) as a block-offset point. */
+export declare const pointOf: (text: Text, offset: number) => SelectionPoint;
+type TextRun = Extract<ContentRun, {
     kind: 'text';
 }>;
 /** One content part of a block: a text segment (between atoms, possibly empty) or an inline atom. */
@@ -55,7 +58,7 @@ export type SelectionSegment = {
     segOrd: number;
     start: number;
     end: number;
-    runs: TextRun[];
+    runs: readonly TextRun[];
 } | {
     block: BlockId;
     kind: 'inline';
@@ -88,7 +91,7 @@ export type SelectionProjection = {
     readonly content: string;
 };
 /** The document reads a projection needs (the facade satisfies it). */
-export type ProjectionDoc = Pick<EdytorDoc, 'version' | 'resolveAnchor' | 'compare' | 'order' | 'contentItems' | 'ancestorsOf' | 'isIsland' | 'isVoid' | 'isVisibleBlock'>;
+export type ProjectionDoc = Pick<EdytorDoc, 'version' | 'resolveAnchor' | 'compare' | 'order' | 'runs' | 'ancestorsOf' | 'isIsland' | 'isVoid' | 'isVisibleBlock'>;
 /** A block's content parts; always text first and last, one text segment between two atoms. */
 export declare const segmentsOf: (doc: ProjectionDoc, block: BlockId) => SelectionSegment[];
 /** The projection of `value` at the document's current version, memoized per (value, version). */
@@ -97,7 +100,10 @@ export declare const project: (value: SelectionValue, doc: ProjectionDoc) => Sel
 export declare const sameEnds: (a: SelectionProjection, b: SelectionProjection) => boolean;
 /** Why a selection was written. */
 export type SelectCause = 'dom' | 'model' | 'repair' | 'history';
-/** Value equality: kind, anchors (item + side), ids, pending marks. */
+/**
+ * Value equality: kind, anchors (item + side), ids, pending marks. A value
+ * is plain JSON (anchors, ids, marks), so it is the JSON equality.
+ */
 export declare const sameValue: (a: SelectionValue, b: SelectionValue) => boolean;
 /**
  * The presence payload: anchors only. A text range publishes its

package/dist/session/selection.js

@@ -1,36 +1,16 @@
+import { partsOf, segmentAt } from '../crdt/parts.js';
 import { jsonEquals } from '../utils/json.js';
 export const noSelection = Object.freeze({ kind: 'none' });
 export const textSelection = (anchor, focus = anchor, pending) => Object.freeze({ kind: 'text', anchor, focus, ...(pending ? { pending } : {}) });
 export const atomSelection = (blockId, atomId, from = 'before') => Object.freeze({ kind: 'atom', blockId, atomId, from });
 export const blockSelection = (ids) => Object.freeze({ kind: 'blocks', ids: Object.freeze([...ids]) });
+/** A point inside a text segment (its block's `ordinal`-th) as a block-offset point. */
+export const pointOf = (text, offset) => ({
+    block: text.blockId,
+    offset: text.segStart + offset
+});
 /** A block's content parts; always text first and last, one text segment between two atoms. */
-export const segmentsOf = (doc, block) => {
-    const out = [];
-    let text = { block, kind: 'text', segOrd: 0, start: 0, end: 0, runs: [] };
-    for (const item of doc.contentItems(block)) {
-        if (item.kind === 'text') {
-            text.runs.push(item);
-            text.end += item.text.length;
-            continue;
-        }
-        out.push(text, { block, kind: 'inline', id: item.id, start: text.end, end: text.end + 1 });
-        text = {
-            block,
-            kind: 'text',
-            segOrd: text.segOrd + 1,
-            start: text.end + 1,
-            end: text.end + 1,
-            runs: []
-        };
-    }
-    out.push(text);
-    return out;
-};
-/** The text segment displaying `offset`: the first one ending at or after it (a seam belongs to the left text). */
-const textSegmentAt = (segments, offset) => {
-    const texts = segments.filter((s) => s.kind === 'text');
-    return texts.find((s) => offset <= s.end) ?? texts[texts.length - 1];
-};
+export const segmentsOf = (doc, block) => partsOf(doc.runs(block)).map((part) => ({ ...part, block }));
 const EMPTY = {
     start: null,
     end: null,
@@ -95,8 +75,8 @@ const projectRange = (doc, kind, anchor, focus, atomic) => {
     const partsOf = new Map(blocks.map((id) => [id, segmentsOf(doc, id)]));
     const startSegments = partsOf.get(start.block) ?? segmentsOf(doc, start.block);
     const endSegments = partsOf.get(end.block) ?? segmentsOf(doc, end.block);
-    const first = textSegmentAt(startSegments, start.offset);
-    const last = textSegmentAt(endSegments, end.offset);
+    const first = segmentAt(startSegments, start.offset);
+    const last = segmentAt(endSegments, end.offset);
     const all = blocks.flatMap((id) => partsOf.get(id));
     const from = all.indexOf(first);
     const to = all.indexOf(last);
@@ -191,25 +171,11 @@ export const sameEnds = (a, b) => [a.start, a.end].every((p, i) => {
     const q = i ? b.end : b.start;
     return p?.block === q?.block && p?.offset === q?.offset;
 });
-const sameAnchor = (a, b) => a === b ||
-    (a.b === b.b &&
-        a.a.a === b.a.a &&
-        (a.a.i === b.a.i || (a.a.i?.c === b.a.i?.c && a.a.i?.k === b.a.i?.k)));
-const sameMarks = (a, b) => jsonEquals(a ?? null, b ?? null);
-/** Value equality: kind, anchors (item + side), ids, pending marks. */
-export const sameValue = (a, b) => {
-    if (a === b)
-        return true;
-    if (a.kind === 'text' && b.kind === 'text')
-        return (sameAnchor(a.anchor, b.anchor) &&
-            sameAnchor(a.focus, b.focus) &&
-            sameMarks(a.pending, b.pending));
-    if (a.kind === 'blocks' && b.kind === 'blocks')
-        return a.ids.length === b.ids.length && a.ids.every((id, i) => id === b.ids[i]);
-    if (a.kind === 'atom' && b.kind === 'atom')
-        return a.blockId === b.blockId && a.atomId === b.atomId && a.from === b.from;
-    return a.kind === b.kind && a.kind === 'none';
-};
+/**
+ * Value equality: kind, anchors (item + side), ids, pending marks. A value
+ * is plain JSON (anchors, ids, marks), so it is the JSON equality.
+ */
+export const sameValue = jsonEquals;
 /**
  * A text value's anchors as (start, end). A range an edit collapsed has no
  * order left; its anchors keep the roles they were minted with (a start

package/dist/session/suggestions.svelte.d.ts

@@ -1,4 +1,5 @@
 import type { BlockId, DocAnchor, OpResult } from '../crdt/index.js';
+import type { SuggestedChange } from '../crdt/doc/suggest.js';
 import type { Edytor } from '../edytor.svelte.js';
 import { type JSONBlock } from '../utils/json.js';
 /** A text range, by its anchors (a text selection's). */
@@ -48,12 +49,15 @@ export type SuggestionsAt = {
 };
 /** The block's `data-edytor-suggestion-replaced` (`empty`: folded, the preview stands in its place). */
 export declare const replacedMark: ({ replaced, inPlace }: SuggestionsAt) => "" | "empty" | null;
+/** A view-local suggestion: shown in this view only, until it is accepted. */
 export declare class Suggestion {
     #private;
     readonly id: string;
     /** The position, resolved: `replace: 'selection'` is the selection's blocks or text range. */
     readonly at: ResolvedAt;
     readonly label: string | undefined;
+    /** View-local: a {@link SharedSuggestion} is in the document. */
+    readonly shared: false;
     constructor(layer: Suggestions, at: ResolvedAt, kind: string, options: SuggestionOptions, status: SuggestionStatus);
     /** The proposed blocks (reactive). */
     get content(): readonly JSONBlock[];
@@ -71,25 +75,50 @@ export declare class Suggestion {
     append: (text: string) => void;
     /** The stream ended: `status` is `ready`. */
     done: () => void;
-    /** Place the content in the document: one command, one undo step (see {@link Suggestions}). */
+    /** Accept it: one command, one undo step, placing it in the document (see {@link Suggestions}). */
     accept: () => OpResult;
-    /** Drop it; writes nothing. */
+    /** Drop it (writes nothing). */
     discard: () => void;
     /** Empty it, stream again, and ask the app for another answer (`onRetry`). */
     retry: () => void;
 }
+/**
+ * A shared suggestion (`createSharedSuggestionsPlugin`): in the document,
+ * so every collaborator sees it with its author and reviews it. Its
+ * `accept()` and `reject()` are one command each (`acceptSuggestion`,
+ * `rejectSuggestion`) of a view that may decide; `discard()` rejects it
+ * (its author's withdrawal too).
+ */
+export interface SharedSuggestion extends Omit<Suggestion, 'shared' | 'at'> {
+    readonly shared: true;
+    /** Its position as this view added it; `null` for one another view made (its `changes` say where it is). */
+    readonly at: ResolvedAt | null;
+    /** Its author (an actor id). */
+    readonly by: string | undefined;
+    /** Who wrote it for its author (`'ai'`): a reviewer sees "Ada (AI)". */
+    readonly via: string | undefined;
+    /** Its pending changes, in document order (reactive). */
+    readonly changes: readonly SuggestedChange[];
+    /** This view may accept or reject it. */
+    readonly canDecide: boolean;
+    /** Its author is this view's actor (it may reject it). */
+    readonly mine: boolean;
+    /** Reject its changes: one command (`rejectSuggestion`). */
+    reject(): OpResult;
+}
+/** A suggestion of the list: view-local, or shared (with the shared suggestions plugin). */
+export type AnySuggestion = Suggestion | SharedSuggestion;
 /** The view's suggestions (`edytor.suggestions`). */
 export declare class Suggestions {
     #private;
-    private edytor;
-    /** Bumped by every change of a suggestion: the surface's passes re-run. */
+    readonly edytor: Edytor;
+    /** Bumped by every change of a suggestion (and of the document's): the surface's passes re-run. */
     revision: number;
-    constructor(edytor: Edytor);
-    /** Every live suggestion, oldest first (reactive). */
-    get list(): readonly Suggestion[];
-    /** The newest one: what the keys act on. */
+    /** Every suggestion, view-local and shared, oldest first (reactive). */
+    get list(): readonly AnySuggestion[];
+    /** The newest view-local one: what the keys act on. */
     get latest(): Suggestion | undefined;
-    get: (id: string) => Suggestion | undefined;
+    get: (id: string) => AnySuggestion | undefined;
     /**
      * Propose `content` at `at`. Throws when the position names no shown
      * block, a block that holds no children (`inside` a void or a code line),

package/dist/session/suggestions.svelte.js

@@ -1,13 +1,22 @@
 /**
- * Suggestions (site `editor/suggestions`): content one view proposes at a
- * position — AI output, a completion — shown only in that view until it is
- * accepted. Session state: nothing reaches the document, its history,
- * presence, `onChange` or another view before `accept()`, which is one
- * command (`acceptSuggestion`: admission, hooks, one transaction, one undo
- * step) placing the content as a paste places it (`flow.place`, `flow.slot`,
- * `flow.inline`). A suggestion is anchored by block ids (a text range by its
- * anchors): it survives selection changes and edits elsewhere, and is dropped
- * when its block dies. The layer owns the list; the surface renders it.
+ * Suggestions (site `editor/suggestions`): content proposed at a position —
+ * AI output, a completion, a collaborator's edit to review — in one list,
+ * each one view-local or shared (`shared`).
+ *
+ * - **View-local** (the default): shown only in this view until accepted.
+ *   Session state: nothing reaches the document, its history, presence,
+ *   `onChange` or another view before `accept()`, one command
+ *   (`acceptSuggestion`: admission, hooks, one transaction, one undo step)
+ *   placing the content as a paste places it (`flow.place`, `flow.slot`,
+ *   `flow.inline`). Anchored by block ids (a text range by its anchors): it
+ *   survives selection changes and edits elsewhere, and is dropped when its
+ *   block dies.
+ * - **Shared** (with the shared suggestions plugin,
+ *   `plugins/suggestions/shared.svelte.ts`, `sugg.*`): in the document, so
+ *   every replica sees it and its author is known. The plugin adds them and
+ *   lists them here (`shared`, the port it sets).
+ *
+ * The layer owns the list; the surface renders it.
  */
 import { DEV } from 'esm-env';
 import { REFUSED } from '../crdt/doc/plan.js';
@@ -34,11 +43,14 @@ const sideOf = (at) => {
     const side = SIDES.find((side) => side in at);
     return side && [side, at[side]];
 };
+/** A view-local suggestion: shown in this view only, until it is accepted. */
 export class Suggestion {
     id;
     /** The position, resolved: `replace: 'selection'` is the selection's blocks or text range. */
     at;
     label;
+    /** View-local: a {@link SharedSuggestion} is in the document. */
+    shared = false;
     #content = $state.raw([]);
     #status = $state('ready');
     #layer;
@@ -109,9 +121,9 @@ export class Suggestion {
         if (this.live)
             this.#status = 'ready';
     };
-    /** Place the content in the document: one command, one undo step (see {@link Suggestions}). */
+    /** Accept it: one command, one undo step, placing it in the document (see {@link Suggestions}). */
     accept = () => this.#layer.accept(this);
-    /** Drop it; writes nothing. */
+    /** Drop it (writes nothing). */
     discard = () => this.#layer.drop(this);
     /** Empty it, stream again, and ask the app for another answer (`onRetry`). */
     retry = () => {
@@ -127,27 +139,33 @@ export class Suggestion {
 export class Suggestions {
     edytor;
     #list = $state.raw([]);
-    /** Bumped by every change of a suggestion: the surface's passes re-run. */
+    /** Bumped by every change of a suggestion (and of the document's): the surface's passes re-run. */
     revision = $state(0);
+    /**
+     * @internal The shared suggestions plugin's part (`createSharedSuggestionsPlugin`):
+     * the list with the shared ones after this view's own.
+     */
+    shared;
+    /** @internal */
     constructor(edytor) {
         this.edytor = edytor;
     }
-    /** Every live suggestion, oldest first (reactive). */
+    /** Every suggestion, view-local and shared, oldest first (reactive). */
     get list() {
-        return this.#list;
+        return this.shared?.(this.#list) ?? this.#list;
     }
-    /** The newest one: what the keys act on. */
+    /** The newest view-local one: what the keys act on. */
     get latest() {
         return this.#list.at(-1);
     }
-    get = (id) => this.#list.find((s) => s.id === id);
+    get = (id) => this.list.find((s) => s.id === id);
     /**
      * Propose `content` at `at`. Throws when the position names no shown
      * block, a block that holds no children (`inside` a void or a code line),
      * or no selection (`replace: 'selection'` with none).
      */
     add = (at, content, options = {}) => {
-        const resolved = this.#resolve(at);
+        const resolved = this.resolve(at);
         const { facade, document } = this.edytor;
         const anchor = this.#blocks(resolved)[0];
         const parent = 'inside' in resolved ? anchor : (facade.parentOf(anchor) ?? null);
@@ -327,7 +345,8 @@ export class Suggestions {
         const blocks = this.#blocks(at);
         return blocks.length > 0 && blocks.every((id) => this.edytor.facade.isVisibleBlock(id));
     };
-    #resolve = (at) => {
+    /** @internal `at` resolved: a selection read, a position checked (throws when it names nothing shown). */
+    resolve = (at) => {
         const { edytor } = this;
         const fail = (why) => {
             throw new RangeError(`[edytor] suggestions.add: ${why}`);

package/dist/session/virtual.d.ts

@@ -28,6 +28,6 @@ ready: () => boolean,
 type: () => string, 
 /** A kind's roles, for where a paste's caret ends (`placedEnd`). */
 roleOf: (kind: string) => {
-    void: boolean;
+    childless: boolean;
     rendersContent: boolean;
 }) => ViewDoc;

package/dist/surface/attributes.d.ts

@@ -42,6 +42,11 @@ export declare const ownedOf: (edytor: Edytor, element: Element, entry: {
     block: string;
     name?: string;
     owned?: () => Owned;
+    handle?: {
+        id: string;
+        type?: string;
+        isEmpty?: boolean;
+    };
 } | null) => Owned | null;
 /** Heal `element` against `table`; answers whether anything was written. */
 export declare const heal: (element: HTMLElement, table: Owned) => boolean;

package/dist/surface/attributes.js

@@ -63,7 +63,7 @@ export const ownedOf = (edytor, element, entry) => {
             style: { display: 'none' }
         };
     if (entry.kind === 'atom') {
-        const atom = edytor.nodeToInlineBlock.get(element);
+        const atom = entry.handle;
         return {
             strict: true,
             owned: {
@@ -74,7 +74,7 @@ export const ownedOf = (edytor, element, entry) => {
             style: {}
         };
     }
-    const text = edytor.nodeToText.get(element);
+    const text = entry.handle;
     const voided = insideVoid(edytor, block);
     return {
         strict: true,

package/dist/surface/cells.d.ts

@@ -39,37 +39,14 @@ export type Cells = {
  * reports (`onPatch` is told which cells each report replaced).
  */
 export declare const createCells: (source: CellSource, onPatch?: (patched: Patched, before: Replaced) => void) => Cells;
-export declare const START = "start";
-type TextRun = Extract<ContentRun, {
-    kind: 'text';
-}>;
-/** The text between two inline atoms (or a content edge), keyed causally. */
-export type Segment = {
-    readonly kind: 'text';
-    /** The id of the atom before this segment, or {@link START}. */
-    readonly key: string;
-    readonly text: string;
-    readonly runs: readonly TextRun[];
-};
+export { START, partsOf, type Segment, type AtomPart, type Part } from '../crdt/parts.js';
+import { type Segment } from '../crdt/parts.js';
 /** A suggestion's block as a cell (`components/Suggestion`): rendered like one, never registered. */
 export type PreviewCell = Omit<Cell, 'childIds'> & {
     readonly children: readonly PreviewCell[];
 };
 /** `blocks` as preview cells, keyed by position under `key` (stable while a stream grows). */
 export declare const previewCells: (blocks: readonly JSONBlock[], key: string) => PreviewCell[];
-export type AtomPart = {
-    readonly kind: 'inline';
-    readonly key: string;
-    readonly id: string;
-    readonly type: string;
-    readonly data: Data;
-};
-export type Part = Segment | AtomPart;
-/**
- * A cell's content as segments and atoms, alternating, starting and ending
- * with a segment (an empty content is one empty `start` segment).
- */
-export declare const partsOf: (runs: readonly ContentRun[]) => readonly Part[];
 /** Whether a view renders mark `name` (its record has a tag or a snippet): an unknown mark renders its text only. */
 export declare const rendersMark: (marks: ReadonlyMap<string, {
     tag?: unknown;
@@ -105,4 +82,3 @@ export declare const segmentDeltas: (cell: Cell, segment: Segment, transform?: T
  * composition is in it.
  */
 export declare const placeholderOf: (cell: Cell, composing: boolean) => boolean;
-export {};

package/dist/surface/cells.js

@@ -125,7 +125,8 @@ export const createCells = (source, onPatch) => {
     };
 };
 // ── segments and render deltas ──────────────────────────────────────────
-export const START = 'start';
+export { START, partsOf } from '../crdt/parts.js';
+import { partsOf } from '../crdt/parts.js';
 /** `blocks` as preview cells, keyed by position under `key` (stable while a stream grows). */
 export const previewCells = (blocks, key) => blocks.map((block, index) => {
     const id = `${key}.${index}`;
@@ -139,38 +140,6 @@ export const previewCells = (blocks, key) => blocks.map((block, index) => {
         children: Object.freeze(previewCells(block.children ?? [], id))
     });
 });
-const partsMemo = new WeakMap();
-/**
- * A cell's content as segments and atoms, alternating, starting and ending
- * with a segment (an empty content is one empty `start` segment).
- */
-export const partsOf = (runs) => {
-    const memo = partsMemo.get(runs);
-    if (memo)
-        return memo;
-    const parts = [];
-    let key = START;
-    let segment = [];
-    const close = () => parts.push(Object.freeze({
-        kind: 'text',
-        key,
-        text: segment.map((run) => run.text).join(''),
-        runs: Object.freeze(segment)
-    }));
-    for (const run of runs) {
-        if (run.kind === 'text') {
-            segment.push(run);
-            continue;
-        }
-        close();
-        parts.push(Object.freeze({ kind: 'inline', key: run.id, id: run.id, type: run.type, data: run.data }));
-        key = run.id;
-        segment = [];
-    }
-    close();
-    partsMemo.set(runs, Object.freeze(parts));
-    return parts;
-};
 /** Whether a view renders mark `name` (its record has a tag or a snippet): an unknown mark renders its text only. */
 export const rendersMark = (marks, name) => {
     const mark = marks.get(name);