edytor 4.0.0 → 6.0.0

package/dist/crdt/doc/moves.js

@@ -1,274 +0,0 @@
-/**
- * Block placement ops: insert (`insertBlocks`, `duplicateBlock`), move
- * (`moveBlocks`), outdent (`unNestBlocks`) and the lift out of the
- * containers a kind does not fit (`landingOf`, `splitOut`, `liftOut`).
- */
-import { id as newId } from '../../utils.js';
-import { asBlockSpec, sanitizeSpec } from '../../utils/json.js';
-import { collides } from '../placement/model.js';
-import { ref } from './plan.js';
-import { PART } from './steps.js';
-/** The moves ops of one facade, prepared. */
-export const moveOps = (c) => {
-    const { doc, blockTypeOf, blockDataOf, childrenIds, positionOf, isVoid, isIsland, isLine, contentItems, live, canPlace, isContainer, fits, kindToCopy, REFUSED, plan, moveTo, move, leaving, settledKind, settle, landing, emptying, emptied } = c;
-    /**
-     * Insert blocks (specs may carry children/content/data; the batch is
-     * all-or-nothing). A spec is a `BlockSpec` or the `JSONBlock` that
-     * `toJSON` and the view's `value` speak (`{ type, content: [{ text }] }`):
-     * its ids are kept, minted where missing (`asBlockSpec`). Ids must be fresh.
-     * Refused when the parent is not live, is `void` or is an island's
-     * line (it holds no children), or any id collides.
-     * Inserting INSIDE an island is allowed — island interiors are built
-     * this way. `ids`: the inserted roots.
-     */
-    const insertBlocks = (dest, specs) => {
-        const parent = ref(dest.parent);
-        const clean = specs.map((spec) => sanitizeSpec(asBlockSpec(spec)));
-        if (parent !== null && (isVoid(parent) || isLine(parent)))
-            return REFUSED;
-        if (clean.length === 0)
-            return plan([], []);
-        if ((parent !== null && !live(parent)) || collides(doc, clean))
-            return REFUSED;
-        return plan(clean.map((s) => s.id), [{ op: 'insertBlocks', parent, index: dest.index, specs: clean }]);
-    };
-    /**
-     * Grouped move — one step, per-member conflict resolution; refused
-     * exactly when `canPlace` refuses the group. `ids`: the moved blocks,
-     * in request order.
-     */
-    const moveBlocks = (ids, dest) => {
-        const moved = ids.map(ref);
-        const parent = ref(dest.parent);
-        if (moved.length === 0)
-            return plan([], []);
-        if (!canPlace(moved, parent))
-            return REFUSED;
-        // A list the move leaves with no item goes (not one it moves or lands in).
-        const into = new Set([...moved, ...landing(parent)]);
-        return plan(moved, emptied(moved, move(moved, parent, dest.index), into));
-    };
-    /**
-     * Outdent: move sibling blocks `ids` (document order) right
-     * after their parent, and hand the siblings that followed the last of
-     * them to it as its last children — every outliner's Shift+Tab. A last
-     * block that cannot adopt them (void, island, a container they do not
-     * fit) leaves them with the parent. The blocks take the kind they show
-     * in their new slot (`settledKind`: a list's item becomes a paragraph,
-     * a paragraph outdented into a list its item); refused where one would
-     * not fit (a paragraph out of a column into its columns layout).
-     * Items leaving a container never take the items after them:
-     * the list splits around them, Notion's way — outdented first items go
-     * before it, last ones after it; from the middle, the list keeps the
-     * items after them and a new list of its kind takes the ones before
-     * them, so an item a peer appends meanwhile stays with the items it
-     * follows (`splitOut`, the split Turn into's `liftOut` makes). A
-     * container left with no child goes. One plan; refused as the
-     * move is. `ids`: the moved blocks.
-     */
-    const unNestBlocks = (ids) => {
-        const moved = ids.map(ref);
-        const last = moved.at(-1);
-        const pos = last === undefined ? null : positionOf(last);
-        const ppos = pos?.parent != null ? positionOf(pos.parent) : null;
-        if (!ppos || moved.some((id) => positionOf(id)?.parent !== pos.parent))
-            return REFUSED;
-        const from = pos.parent;
-        if (!canPlace(moved, ppos.parent, (id) => settledKind(from, id, ppos.parent)))
-            return REFUSED;
-        const after = childrenIds(from).slice(pos.index + 1);
-        const retype = settle(from, moved, ppos.parent);
-        if (isContainer(from))
-            return splitOut(moved, [from], [], false, retype);
-        const writes = [...moveTo(moved, ppos.parent, ppos.index + 1, leaving(true)), ...retype];
-        const adopts = after.length > 0 &&
-            !isVoid(last) &&
-            !isIsland(last) &&
-            after.every((id) => fits(last, blockTypeOf(id)));
-        if (adopts)
-            writes.push(...move(after, last, Infinity));
-        return plan(moved, writes);
-    };
-    /** Outdent one block (`unNestBlocks`). */
-    const unNestBlock = (id) => unNestBlocks([id]);
-    /**
-     * Where a block of `kind` at `id`'s place lands: `id`'s parent, or the
-     * first one up that `kind` fits (`fits`: a list holds only its items),
-     * and the containers it leaves on the way, innermost first (`levels`).
-     * Its own kind keeps a block where it is, as a reorder
-     * does (`canPlace`); a block inserted after it (`after`) has no place
-     * yet.
-     */
-    const landingOf = (id, kind, after = false) => {
-        const levels = [];
-        let parent = positionOf(id)?.parent ?? null;
-        const own = !after && blockTypeOf(id) === kind;
-        for (; !own && parent !== null && !fits(parent, kind); parent = positionOf(parent).parent)
-            levels.push(parent);
-        return { parent, levels };
-    };
-    /**
-     * Lift sibling blocks `ids` (document order) out of `levels`, the
-     * containers around them, innermost first: each level
-     * splits around them as an outdent splits one list — the blocks
-     * before them go to a new container of its kind, which the level above
-     * holds the same way, and the level keeps the ones after them, so an
-     * item a peer appends meanwhile stays with the items it follows; one
-     * left with no child goes. `specs` (new blocks) land right after them.
-     * With `keep`, `ids` stay before the split and only `specs` go out.
-     * `retype` (the caller's kind steps) joins the plan. The one split
-     * `unNestBlocks` and `liftOut` share. `ids`: the placed blocks.
-     */
-    const splitOut = (ids, levels, specs, keep, retype = []) => {
-        const moved = keep ? [] : [...ids];
-        const placed = [...moved, ...specs.map((s) => s.id)];
-        const insert = (at, index, s) => s.length ? [{ op: 'insertBlocks', parent: at, index, specs: s }] : [];
-        const last = ids.at(-1);
-        const { parent, index } = positionOf(levels.at(-1) ?? last);
-        if (levels.length === 0)
-            return plan(placed, [...insert(parent, index + 1, specs), ...retype]);
-        // Bottom up: what stays before the split at each level (the level
-        // itself, or a new head holding it), and whether anything follows it.
-        const heads = [];
-        let before = null;
-        let follows = false;
-        // The block right after `last` (what the split ends at when `keep`).
-        let next;
-        let child = last;
-        for (const level of levels) {
-            const kids = childrenIds(level);
-            const at = kids.indexOf(child);
-            const stays = (keep && child === last) || (before !== null && !before.head);
-            const lead = kids.slice(0, at + (stays ? 1 : 0)).filter((k) => !moved.includes(k));
-            if (!follows && at + 1 < kids.length)
-                [follows, next] = [true, kids[at + 1]];
-            if ((lead.length > 0 || before?.head) && follows) {
-                const spec = sanitizeSpec({
-                    id: newId('b'),
-                    type: kindToCopy(level),
-                    data: blockDataOf(level) ?? {}
-                });
-                heads.push({ spec, kids: lead, inner: before?.head });
-                before = { id: spec.id, head: spec };
-            }
-            else
-                before = lead.length > 0 ? { id: level } : null;
-            child = level;
-        }
-        // Written in one gap, each right after the block before it, as an
-        // after-record out of the level's slot or a before-record into the gap
-        // before it (`leaving`): the engine's sort decides their order against
-        // a peer's records there (fork patch YP22, `sourceOrder`: the block a
-        // record stands at, then its part), so a peer's heads, pieces, lifts
-        // and new blocks in the same gap keep the serial order whatever the
-        // client ids (`del.merge.container`). The head stands at the first block
-        // (with `keep`, at it: `with`), the blocks at themselves, the new
-        // blocks after the last (`after`) — or, kept before the block that
-        // follows, at that block (`kept`). The records are written last first,
-        // so each stands before the one written before it, in the order the
-        // sort gives them; the head and the new blocks are created in the
-        // innermost level right after the block they stand at (their home,
-        // hidden while their records show them) and moved out by them.
-        const outside = before !== null && !before.head;
-        const side = leaving(outside);
-        const gap = index + (outside ? 1 : 0);
-        const at = moved[0] ?? last;
-        const kids0 = childrenIds(levels[0]);
-        const home = kids0.indexOf(last) + 1;
-        const specIds = specs.map((sp) => sp.id);
-        const [stands, part] = keep && !outside ? [next, PART.kept] : [last, PART.after];
-        // One record per run of adjacent blocks, each standing at its first: a
-        // block a peer's move takes out of a run leaves the others at their own place.
-        const runs = [];
-        for (const id of moved) {
-            const run = runs.at(-1);
-            if (run !== undefined && kids0.indexOf(run.at(-1)) + 1 === kids0.indexOf(id))
-                run.push(id);
-            else
-                runs.push([id]);
-        }
-        const writes = [
-            ...insert(levels[0], home, specs),
-            ...(before?.head ? insert(levels[0], home, [before.head]) : []),
-            ...moveTo(specIds, parent, gap, side, stands, part),
-            ...runs.reverse().flatMap((run) => moveTo(run, parent, gap, side, run[0], PART.self)),
-            ...(before?.head
-                ? moveTo([before.head.id], parent, gap, side, at, keep ? PART.with : PART.head)
-                : [])
-        ];
-        for (const { spec, kids, inner } of heads.reverse()) {
-            writes.push(...moveTo(kids, spec.id, 0), ...(inner ? insert(spec.id, kids.length, [inner]) : []));
-        }
-        writes.push(...retype);
-        void next;
-        return plan(placed, emptying(levels[0], moved, writes, landing(parent)));
-    };
-    /**
-     * Place `id` where a block of `kind` fits, in one plan:
-     * out of every container around it that `kind` does not fit
-     * (`landingOf`: a list, and a list holding that list directly, for a
-     * heading or a divider), each split around it (`splitOut`). `after`
-     * (new blocks) lands right after it. With `keep`, `id` stays and only
-     * `after` goes out, the split right after `id` (a divider inserted
-     * after an item). Its own kind never moves it. The kinds are the
-     * caller's: it composes the retype (`setBlock`). Refused where `id`
-     * may not move there (`canPlace`). `ids`: the placed blocks.
-     */
-    const liftOut = (id, kind, { keep = false, after = [] } = {}) => {
-        id = ref(id);
-        kind = ref(kind);
-        const specs = after.map(sanitizeSpec);
-        const { parent, levels } = landingOf(id, kind, keep);
-        if (!positionOf(id) || collides(doc, specs) || !canPlace([id], parent, () => kind))
-            return REFUSED;
-        return splitOut([id], levels, specs, keep);
-    };
-    /**
-     * Explicit fresh-identity copy of a subtree (paste / drag-clone):
-     * serializes `id`, remaps every block and inline atom id through
-     * `freshId`, inserts the copy right after `id`. Text atoms get new
-     * identity too — duplication is a creation op, not a relocation. An
-     * inline id `freshId` does not answer (a block-only callback) is
-     * minted; a block id it does not answer refuses the copy. `ids`: the
-     * copy's root.
-     */
-    const duplicateBlock = (id, freshId = (_, kind) => newId(kind === 'block' ? 'b' : 'i')) => {
-        id = ref(id);
-        const pos = positionOf(id);
-        if (pos === null)
-            return REFUSED;
-        const spec = (b) => {
-            const fresh = freshId(b, 'block');
-            if (typeof fresh !== 'string')
-                return null;
-            const content = contentItems(b).map((item) => {
-                if (item.kind !== 'inline')
-                    return item;
-                const atom = freshId(item.id, 'inline');
-                return { ...item, id: typeof atom === 'string' ? atom : newId('i') };
-            });
-            const children = childrenIds(b).map(spec);
-            if (children.includes(null))
-                return null;
-            const data = blockDataOf(b);
-            return {
-                id: fresh,
-                type: kindToCopy(b),
-                ...(data !== undefined && { data }),
-                content,
-                children: children
-            };
-        };
-        const copy = spec(id);
-        return copy ? insertBlocks({ parent: pos.parent, index: pos.index + 1 }, [copy]) : REFUSED;
-    };
-    return {
-        insertBlocks,
-        moveBlocks,
-        unNestBlocks,
-        unNestBlock,
-        landingOf,
-        liftOut,
-        duplicateBlock
-    };
-};

package/dist/crdt/doc/split-merge.d.ts

@@ -1,10 +0,0 @@
-import { type BlockId, type SplitTail } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The split-merge ops of one facade, prepared. */
-export declare const splitMergeOps: (c: OpsContext) => {
-    splitBlock: (id: BlockId, offset: number, newId: BlockId, tail?: SplitTail) => Prepared;
-    mergeBlocks: (fromId: BlockId, intoId: BlockId) => Prepared;
-    mergeBackward: (id: BlockId) => Prepared;
-    mergeForward: (id: BlockId) => Prepared;
-};

package/dist/crdt/doc/split-merge.js

@@ -1,179 +0,0 @@
-/**
- * Split and merge ops: `splitBlock` (one boundary item, no text copied),
- * the engine merge primitive `mergeBlocks`, and the baseline-shaped
- * `mergeBackward`/`mergeForward` (a first item lifts out of its container,
- * a layout item's first block merges across items).
- */
-import { isIncarnationId } from '../incarnations.js';
-import { sanitizeWireJson } from '../../utils/json.js';
-import { readData } from '../data.js';
-import { blockNodeOf, isSelfOrDescendant } from '../placement/model.js';
-import { ref } from './plan.js';
-/** The split-merge ops of one facade, prepared. */
-export const splitMergeOps = (c) => {
-    const { doc, view, childrenIds, positionOf, isVoid, isCellKind, blockTypeOf, insideIsland, isLayoutItem, next, previous, displayLength, contentTarget, isContainer, fits, canMerge, rendersContent, kindToCopy, REFUSED, plan, moveTo, move, leaving, settledKind, settle, landing, emptying, emptied, merge, clamp } = c;
-    /**
-     * Split `id` at content `offset` into a new sibling `newId` (one boundary
-     * item and the claims that follow it, no text copied; children follow).
-     * `tail` decides the sibling's type/data once (default: the source's —
-     * the kind it displays; an empty `tail.type` is the default too).
-     * Refused on `void` blocks and on blocks that render no content (a
-     * list, a code block: nothing to split). `ids`: the new
-     * block.
-     */
-    const splitBlock = (id, offset, newId, tail) => {
-        id = ref(id);
-        const born = ref(newId);
-        const pos = positionOf(id);
-        const rec = view().blocks.get(id);
-        if (pos === null || isVoid(id) || !rendersContent(id) || rec === undefined)
-            return REFUSED;
-        // A table's cell holds its lines as line breaks: it never splits (`table.split`).
-        if (isCellKind(blockTypeOf(id)))
-            return REFUSED;
-        if (isIncarnationId(born) || blockNodeOf(doc, born) !== null)
-            return REFUSED;
-        const [at] = clamp(id, offset, 0);
-        // An empty tail type is the one a view reads mid-retype: copy the kind.
-        const type = tail?.type ? ref(tail.type) : kindToCopy(id);
-        const t = tail
-            ? { type, data: tail.data && sanitizeWireJson(tail.data) }
-            : { type, data: readData(rec.node) };
-        const length = displayLength(id) - at;
-        const split = {
-            op: 'splitBlock',
-            id,
-            offset: at,
-            length,
-            newId: born,
-            tail: t,
-            parent: pos.parent,
-            index: pos.index + 1
-        };
-        return plan([born], [split, ...move(childrenIds(id), born, 0)]);
-    };
-    /**
-     * Engine merge primitive: `from`'s content is claimed by `into`, its
-     * children ADOPTED as `into`'s last children — an island's take
-     * `into`'s default child, like a baseline merge's — and `from` is
-     * hidden via the claim (undo restores it). The children stay under
-     * `from` and display under `into` through the claim, after `into`'s
-     * own children (the display's claim order): a concurrent delete of
-     * `into` voids the claim and `from` comes back with its children,
-     * never below them. Role rules are `canMerge`'s; a merge that would
-     * close a display cycle is refused. `ids`: `into`.
-     */
-    const mergeBlocks = (fromId, intoId) => {
-        const from = ref(fromId);
-        const into = ref(intoId);
-        const v = view();
-        if (!canMerge(from, into) || !contentTarget(into))
-            return REFUSED;
-        if (isSelfOrDescendant(v.placements, v.own, into, from))
-            return REFUSED;
-        const kids = childrenIds(from);
-        const retype = settle(from, kids, into);
-        // A list its only item leaves goes, as with every sibling op.
-        return plan([into], emptied([from], [merge(from, into), ...retype], landing(into)));
-    };
-    /**
-     * Baseline-shaped merge (both `mergeBackward` and `mergeForward`):
-     * `from`'s children unnest right after `from`'s vacated sibling slot —
-     * NOT adopted into `into` — and take the kind they show there
-     * (`settledKind`: an island's children its parent's default child, a
-     * paragraph in a list its item); then `from`'s content claims
-     * into `into`. Placed after `from`, not at it: a concurrent delete of
-     * `into` revives `from` above its former children.
-     */
-    const mergeUnnesting = (from, into) => {
-        const pos = canMerge(from, into) ? positionOf(from) : null;
-        if (pos === null || !contentTarget(into))
-            return REFUSED;
-        const kids = childrenIds(from);
-        const retype = settle(from, kids, pos.parent);
-        return plan([into], [...moveTo(kids, pos.parent, pos.index + 1, leaving(true)), ...retype, merge(from, into)]);
-    };
-    /** Remove `container`, left empty, for the key at `id` (refused if it holds text). */
-    const gone = (id, container) => {
-        const writes = emptying(container, [], []);
-        return writes.length > 0 ? plan([id], writes) : REFUSED;
-    };
-    /**
-     * Baseline `mergeBlockBackward`: merge `id` into the previous block in
-     * document order. No previous block → an empty block merges forward,
-     * else refused. The first item of a container (`isContainer`) outside
-     * any island lifts out of it instead (Notion): it takes the
-     * container's slot, as its new parent's default child, with its
-     * children (a first cell stays: nothing leaves an island; a block that
-     * would land directly in a container it is no item of stays too).
-     * The first block of a layout item merges across items
-     * instead, in reading order (`layout.merge`, Notion): into the
-     * previous item's last line, or, in the first item, the line before
-     * the layout; an item it empties goes and the layout dissolves.
-     * `ids`: the surviving block.
-     */
-    const mergeBackward = (id) => {
-        id = ref(id);
-        const prev = previous(id);
-        if (prev === null && childrenIds(id).length === 0 && displayLength(id) === 0) {
-            return mergeForward(id);
-        }
-        // A container a concurrent edit left empty shows nothing: the key removes it.
-        if (prev !== null && isContainer(prev) && childrenIds(prev).length === 0)
-            return gone(id, prev);
-        if (prev !== null && prev === positionOf(id)?.parent && isLayoutItem(prev)) {
-            const layout = positionOf(prev).parent;
-            let into = previous(prev);
-            if (into === layout)
-                into = previous(layout);
-            const merged = into === null ? REFUSED : mergeUnnesting(id, into);
-            if (!('writes' in merged) || childrenIds(id).length > 0)
-                return merged;
-            return plan(merged.ids, emptying(prev, [id], merged.writes));
-        }
-        if (prev !== null &&
-            prev === positionOf(id)?.parent &&
-            isContainer(prev) &&
-            !insideIsland(prev)) {
-            // It lands only where it fits: never directly in a container it is no item of.
-            const slot = positionOf(prev);
-            if (!fits(slot.parent, settledKind(prev, id, slot.parent)))
-                return REFUSED;
-            const lift = [
-                ...moveTo([id], slot.parent, slot.index, leaving(false)),
-                ...settle(prev, [id], slot.parent)
-            ];
-            return plan([id], emptying(prev, [id], lift, landing(slot.parent)));
-        }
-        return prev ? mergeUnnesting(id, prev) : REFUSED;
-    };
-    /**
-     * Baseline `mergeBlockForward`: pull the next block in document order
-     * into `id`. A container passes the merge to its first item (`del.merge.container`:
-     * Delete above a list pulls the item's text up and the list keeps the
-     * rest, or goes when that was its only item). A container left
-     * empty (by concurrent edits) is removed instead, by either key.
-     */
-    const mergeForward = (id) => {
-        id = ref(id);
-        let after = next(id);
-        while (after !== null && isContainer(after)) {
-            const first = childrenIds(after)[0];
-            // A container a concurrent edit left empty shows nothing: the key removes it.
-            if (first === undefined)
-                return gone(id, after);
-            after = first;
-        }
-        const out = after ? mergeUnnesting(after, id) : REFUSED;
-        const parent = after && positionOf(after)?.parent;
-        if (!('writes' in out) || !parent || childrenIds(after).length > 0)
-            return out;
-        return plan(out.ids, emptying(parent, [after], out.writes));
-    };
-    return {
-        splitBlock,
-        mergeBlocks,
-        mergeBackward,
-        mergeForward
-    };
-};

package/dist/crdt/doc/steps.d.ts

@@ -1,65 +0,0 @@
-/**
- * The step writers every prepared op composes: the plan itself, moves (a
- * move's place and side), type steps and the kind a block shows where it
- * lands (`settle`), the containers and layouts a write leaves empty
- * (`emptying`, `dissolving`), delete and merge steps, and display spans of a
- * block's content.
- */
-import { TYPE } from '../schema.js';
-import { type BlockId, type ContentItem } from '../placement/model.js';
-import type { Plan, PlanStep } from './types.js';
-import type { DocBase, DocReads } from './reads.js';
-import type { DocCapability } from './capability.js';
-/** What the step writers read: the reads and the structural capability. */
-/**
- * A record's order among the records standing at one block, for the
- * engine's sort of two records at one origin (fork patch YP22): what a split
- * of a list around a block writes there — a new head list holding the items
- * before it (`head`), new blocks placed after the items before it, which
- * stay (`kept`), a head holding those items and the block (`with`), the
- * block itself leaving (`self`), new blocks after it (`after`) — in the
- * order every serial run of the gestures gives (`del.merge.container`).
- */
-export declare const PART: {
-    readonly head: 0;
-    readonly kept: 1;
-    readonly with: 2;
-    readonly self: 3;
-    readonly after: 4;
-};
-export type StepsContext = DocBase & DocReads & DocCapability;
-/** The step writers of one facade. */
-export declare const planSteps: (c: StepsContext) => {
-    REFUSED: import("./types.js").OpResult;
-    plan: (ids: readonly BlockId[], writes: PlanStep[]) => Plan;
-    moveTo: (ids: BlockId[], parent: BlockId | null, index: number, side?: 0 | 1, at?: BlockId, part?: number) => PlanStep[];
-    move: (ids: BlockId[], parent: BlockId | null, index: number) => PlanStep[];
-    leaving: (after: boolean) => 0 | 1;
-    attr: (id: BlockId, key: typeof TYPE, value: string) => PlanStep[];
-    leavingIsland: (island: BlockId, kind: string | undefined, to: string) => string | undefined;
-    settledKind: (from: BlockId | null, kid: BlockId, parent: BlockId | null) => string | undefined;
-    settle: (from: BlockId | null, kids: readonly BlockId[], parent: BlockId | null) => PlanStep[];
-    landing: (parent: BlockId | null) => Set<BlockId | null>;
-    emptyingAll: (from: readonly (BlockId | null)[], leaving: readonly BlockId[], writes: readonly PlanStep[], kept?: ReadonlySet<BlockId | null>, removed?: readonly BlockId[]) => PlanStep[];
-    dissolving: (gone: ReadonlySet<BlockId>, leaving: readonly BlockId[], writes: readonly PlanStep[]) => PlanStep[];
-    emptying: (container: BlockId, leaving: readonly BlockId[], writes: readonly PlanStep[], kept?: ReadonlySet<BlockId | null>) => PlanStep[];
-    emptied: (leaving: readonly BlockId[], writes: PlanStep[], kept?: ReadonlySet<BlockId | null>) => PlanStep[];
-    deleting: (id: BlockId, removes: BlockId[]) => PlanStep;
-    remove: (id: BlockId, kept?: readonly BlockId[]) => PlanStep;
-    merge: (from: BlockId, into: BlockId) => PlanStep;
-    clamp: (id: BlockId, offset: number, length: number) => [number, number];
-    atomOf: (id: BlockId, atom: string) => {
-        item: ContentItem;
-        at: number;
-        end: number;
-    } | undefined;
-    textIn: (id: BlockId, at: number, end: number) => {
-        kind: "text";
-        text: string;
-        marks?: Record<string, unknown>;
-    }[];
-    writeContent: (writes: PlanStep[], id: BlockId, at: number, items?: readonly ContentItem[]) => number;
-};
-export type PlanSteps = ReturnType<typeof planSteps>;
-/** What every op family is prepared over: the reads, the capability and the step writers. */
-export type OpsContext = StepsContext & PlanSteps;