edytor 4.0.0 → 6.0.0

package/dist/cloudflare/room/suggest.js

@@ -0,0 +1,143 @@
+/**
+ * The suggest-only rule (`room.access.suggest`, `sugg.room.suggest`): what a
+ * frame of a socket whose user may only suggest may write. Every struct must
+ * be a suggestion's, under a client id of that user that is not the socket's
+ * own replica (its writes are suggestion writers'):
+ *
+ * - a suggestion record (an attr of the root `suggest`), and what a record
+ *   of its user holds (its attrs, its writer's id lists and operations);
+ * - its own binding and profile (the attribution root: the trust rules
+ *   check them);
+ * - text in a block's backing text (an insertion; a split's boundary; a
+ *   merge's claim of a block its user made; a mark next to its user's own
+ *   text), and an atom's attrs of an atom its user made;
+ * - a block its user made (its registry entry, attrs, children's slots) and
+ *   a home slot naming such a block in any block's sequence;
+ * - a hold record naming only its user's units (deleting its own text).
+ *
+ * Anything else strips the client from the frame, as a forged mark does, and
+ * a delete of an item another user wrote is dropped. Residuals: a mark both of
+ * whose ends touch its user's text covers what lies between them, and its user
+ * may delete its own accepted text directly (the room reads no record's
+ * decisions). Pure reads of the room document and the frame.
+ */
+import { Y } from '../../crdt/engine.js';
+import { ATTRIBUTION_ROOT, BLOCK_NODE, CONTENT_NODE, INLINE_NODE, REGISTRY_KEY, SUGGEST_ROOT, TEXT_DELETES_ROOT } from '../../crdt/schema.js';
+import { isId } from './forged.js';
+import { heldClock, runsOf, storedStruct, structAt } from './updates.js';
+/** What a frame of a suggest-only socket may not write: the clients to strip, the deletes to drop. */
+export const suggestOnly = (doc, { structs, ds }, skip, owns, replica) => {
+    const frame = runsOf(structs);
+    const strip = new Set();
+    /** The struct at `id`, the room's or the frame's. */
+    const at = (id) => (storedStruct(doc, id.client, id.clock) ?? structAt(frame.get(id.client) ?? [], id.clock));
+    /**
+     * Where the item at `id` sits: its map key (`null` in a sequence) and its
+     * parent, read from the item or, for an encoded one that names neither,
+     * from an origin of it (left, else right: one sequence, or one key).
+     */
+    const placeIn = (id) => {
+        const seen = new Set();
+        for (let next = id; next !== null;) {
+            const held = storedStruct(doc, next.client, next.clock);
+            if (held)
+                return held instanceof Y.Item ? { key: held.parentSub, parent: held.parent } : null;
+            const item = structAt(frame.get(next.client) ?? [], next.clock);
+            if (!(item instanceof Y.Item) || seen.has(item))
+                return null;
+            seen.add(item);
+            if (item.parent !== null || item.parentSub !== null)
+                return { key: item.parentSub, parent: item.parent };
+            next = item.origin ?? item.rightOrigin;
+        }
+        return null;
+    };
+    /** The node (and its item) a place's parent names: a root's name, or a nested node's. */
+    const nodeOf = (parent) => {
+        if (typeof parent === 'string')
+            return { root: parent };
+        if (isId(parent)) {
+            const item = at(parent);
+            return { name: item?.content?.type?.name, item: item?.id };
+        }
+        const node = parent;
+        if (!node)
+            return {};
+        if (!node._item) {
+            const root = [...doc.share].find(([, type]) => type === parent)?.[0];
+            return { root };
+        }
+        return { name: node.name, item: node._item.id };
+    };
+    const registry = () => doc.share.get(REGISTRY_KEY)?._map;
+    /** A block `id` whose node a client of this user made (in the room or the frame). */
+    const ownBlock = (id) => {
+        if (typeof id !== 'string')
+            return false;
+        const stored = registry()?.get(id);
+        if (stored)
+            return owns(stored.id.client);
+        return structs.some((s) => s instanceof Y.Item &&
+            owns(s.id.client) &&
+            placeIn(s.id)?.key === id &&
+            nodeOf(placeIn(s.id)?.parent).root === REGISTRY_KEY);
+    };
+    const allowed = (s) => {
+        const place = placeIn(s.id);
+        if (place === null)
+            return false;
+        const parent = nodeOf(place.parent);
+        const value = s.content.getContent?.()[0];
+        if (parent.root === SUGGEST_ROOT || parent.root === ATTRIBUTION_ROOT)
+            return true;
+        if (parent.name === 'suggestion')
+            return !!parent.item && owns(parent.item.client);
+        if (parent.root === TEXT_DELETES_ROOT) {
+            const ids = s.content.ids ?? [];
+            return ids.every((v, i) => i % 3 !== 0 || owns(v));
+        }
+        if (parent.name === CONTENT_NODE) {
+            // A mark (a format item: its key and value).
+            if (s.content.key !== undefined) {
+                const { origin, rightOrigin } = s;
+                const near = [origin, rightOrigin];
+                return near.some((id) => isId(id) && owns(id.client));
+            }
+            return value?.m === undefined || ownBlock(value.m);
+        }
+        if (parent.name === INLINE_NODE)
+            return !!parent.item && owns(parent.item.client);
+        if (parent.root === REGISTRY_KEY) {
+            // A top-level home slot of its own block, or its own block's entry (never another's).
+            if (place.key === null)
+                return ownBlock(value?.b);
+            const stored = registry()?.get(place.key);
+            return !stored || owns(stored.id.client);
+        }
+        if (parent.name === BLOCK_NODE) {
+            if (s.content.priority !== undefined)
+                return false;
+            if (place.key === null && value?.b !== undefined)
+                return ownBlock(value.b);
+            return !!parent.item && owns(parent.item.client);
+        }
+        return false;
+    };
+    for (const s of structs) {
+        const { client, clock } = s.id;
+        if (!(s instanceof Y.Item) || skip.has(client) || strip.has(client))
+            continue;
+        if (storedStruct(doc, client, clock) !== null)
+            continue;
+        if (client === replica || !owns(client) || !allowed(s))
+            strip.add(client);
+    }
+    // Deletes of what another user wrote are dropped.
+    const deletes = Y.createIdSet();
+    for (const [client, ranges] of ds.clients)
+        if (!owns(client))
+            for (const { clock, len } of ranges.getIds())
+                if (clock < heldClock(doc, client))
+                    deletes.add(client, clock, len);
+    return { strip, deletes };
+};

package/dist/cloudflare/routeDocumentSocket.d.ts

@@ -4,15 +4,24 @@ export type DocumentNamespace = {
         fetch(request: Request): Promise<Response>;
     };
 };
+/**
+ * What a user may do in a document: `read`; `comment` (read, and comment:
+ * the room writes a thread's anchor); `suggest` (read, comment, and write
+ * suggestions, which a writer accepts or rejects); `write` (everything,
+ * deciding suggestions included).
+ */
+export type DocumentAccessLevel = 'read' | 'comment' | 'suggest' | 'write';
 /**
  * What the host verified. `userId` owns every Yjs client id the socket
  * writes under; `replica` is the client's `doc.clientID` (read it from a
  * query parameter with {@link requestedReplica}; omitted, the socket's
- * first presence entry binds it); `readOnly` refuses every write.
+ * first presence entry binds it); `access` what the user may do (default
+ * `write`; `readOnly: true` is `access: 'read'`).
  */
 export type DocumentIdentity = {
     userId: string;
     replica?: number | null;
+    access?: DocumentAccessLevel;
     readOnly?: boolean;
     /**
      * When the credential expires, ms since the epoch (a token's `exp` ×

package/dist/cloudflare/routeDocumentSocket.js

@@ -119,13 +119,15 @@ const authorized = async (request, documentId, authorize, refuse, options) => {
         return refuse(CLOSE.expired, 'expired');
     return identity;
 };
+/** What `identity` may do: its `access`, else `read` for `readOnly`, else `write`. */
+const accessOf = (identity) => identity.access ?? (identity.readOnly ? 'read' : 'write');
 /** A refusal as an HTTP status (a probe, a history request). */
 const statusOf = (code, reason) => new Response(reason, { status: PROBE_STATUS[code] ?? 403 });
 /** The verified identity as the headers the room trusts. */
 const identityHeaders = (identity) => {
     const headers = new Headers({
         [IDENTITY_HEADERS.user]: encodeURIComponent(identity.userId),
-        [IDENTITY_HEADERS.access]: identity.readOnly ? 'read' : 'write'
+        [IDENTITY_HEADERS.access]: accessOf(identity)
     });
     const replica = identity.replica ?? null;
     if (replica !== null)
@@ -173,7 +175,7 @@ async function routeHistory(request, rooms, documentId, authorize, options) {
     const identity = await authorized(request, documentId, authorize, statusOf, options);
     if (identity instanceof Response)
         return identity;
-    if ((op === 'restore' || op === 'undo') && identity.readOnly) {
+    if ((op === 'restore' || op === 'undo') && accessOf(identity) !== 'write') {
         return new Response('read-only', { status: 403 });
     }
     const headers = identityHeaders(identity);
@@ -247,7 +249,7 @@ async function routeComments(request, rooms, documentId, authorize, options) {
     const identity = await authorized(request, documentId, authorize, statusOf, options);
     if (identity instanceof Response)
         return identity;
-    if (op === 'post' && identity.readOnly)
+    if (op === 'post' && accessOf(identity) === 'read')
         return new Response('read-only', { status: 403 });
     let body = null;
     if (op === 'post') {

package/dist/components/Content.svelte

@@ -43,7 +43,15 @@
 	const placeholder = $derived(edytor.placeholderAt(id));
 
 	/** An empty content's one text (`partsOf`: a content starts with a text). */
-	const EMPTY: Segment = { kind: 'text', key: START, text: '', runs: [] };
+	const EMPTY: Segment = {
+		kind: 'text',
+		key: START,
+		text: '',
+		runs: [],
+		segOrd: 0,
+		start: 0,
+		end: 0
+	};
 
 	/** Whether this view renders an atom of `part`'s kind (its record has a snippet). */
 	const rendersAtom = (part: AtomPart) => Boolean(edytor.inlineBlocks.get(part.type)?.snippet);

package/dist/crdt/anchors.js

@@ -1,5 +1,6 @@
-/** The children index order (`childrenIndex`): rank, then id. */
-const before = (a, b) => (a.rank === b.rank ? a.id < b.id : a.rank < b.rank);
+import { bySlot } from './placement/display.js';
+/** The children list's own order (`bySlot`): rank, then id. */
+const before = (a, b) => bySlot(a, b) < 0;
 /**
  * Where an endpoint whose block `dead` vanished lands: a displayable stop next
  * to the slot `dead` (or its topmost dead ancestor) occupied. `dead === null`

package/dist/crdt/attribution/attribution.d.ts

@@ -44,6 +44,8 @@ export { ATTRIBUTION_ROOT };
  * it as bookkeeping.
  */
 export declare const ATTRIBUTION_ORIGIN: unique symbol;
+export declare const ACTOR_PREFIX = "u/";
+export declare const CLIENT_PREFIX = "c/";
 /** The stable application-level author identity (mirrors `DocumentActor`). */
 export type AttributionActor = {
     id: string;
@@ -113,6 +115,7 @@ type AttachOptions = {
  * attached with (`undefined`: a raw doc). The provider's `saved` reads it.
  */
 export declare const writerOf: (doc: EngineDoc) => string | undefined;
+export declare const sanitizeProfile: (value: unknown) => ActorProfile;
 /** The display profile of `actor`: its name and color, those it has. */
 export declare const profileOf: (actor: AttributionActor) => ActorProfile;
 /**

package/dist/crdt/attribution/attribution.js

@@ -9,8 +9,8 @@ export { ATTRIBUTION_ROOT };
  * it as bookkeeping.
  */
 export const ATTRIBUTION_ORIGIN = Symbol('edytor.attribution');
-const ACTOR_PREFIX = 'u/'; // actorId → profile records
-const CLIENT_PREFIX = 'c/'; // replica clientID → actorId records
+export const ACTOR_PREFIX = 'u/'; // actorId → profile records
+export const CLIENT_PREFIX = 'c/'; // replica clientID → actorId records
 /** The actor each attached document's replica writes for (its attribution controller's). */
 const localActors = new WeakMap();
 /**
@@ -25,7 +25,7 @@ export const writerOf = (doc) => {
         : undefined;
     return typeof bound === 'string' && bound.length > 0 ? bound : localActors.get(doc);
 };
-const sanitizeProfile = (value) => {
+export const sanitizeProfile = (value) => {
     const v = (value ?? undefined);
     const out = {};
     if (typeof v?.name === 'string')

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

@@ -20,7 +20,7 @@ export type FunnelContext = DocBase & DocReads & {
 /** The write funnel of one facade. */
 export declare const writeFunnel: (c: FunnelContext) => {
     write: <R>(fn: () => R) => R;
-    apply: (p: Prepared) => OpResult;
+    apply: (p: Prepared, quiet?: boolean) => OpResult;
     /** Disposal is terminal for writes. */
     dispose: () => void;
     disposed: () => boolean;

package/dist/crdt/doc/funnel.js

@@ -146,8 +146,10 @@ export const writeFunnel = (c) => {
      * and fold the result from what that transaction did. A refusal writes
      * nothing. A plan is valid only at the version it was prepared against,
      * in the same synchronous turn: applying it anywhere else throws.
+     * `quiet`: it stamps no attribution (a suggestion's writer: its content
+     * is not the block's until accepted).
      */
-    const apply = (p) => {
+    const apply = (p, quiet) => {
         if (!('writes' in p))
             return write(() => p);
         if (p.version !== runsView.version()) {
@@ -166,7 +168,8 @@ export const writeFunnel = (c) => {
                 throw error;
             }
             const folded = frame.end();
-            close(f, folded);
+            if (!quiet)
+                close(f, folded);
             return folded.wrote ? { status: 'applied', ids: p.ids } : NOOP;
         }));
     };

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

@@ -25,7 +25,7 @@
  * ```
  */
 import type { EngineDoc } from '../engine-api.js';
-export declare const SCHEMA_VERSION: 10;
+export declare const SCHEMA_VERSION: 11;
 export declare const SCHEMA_NAME: "edytor-doc";
 export declare const META_KEY: "meta";
 /**

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

@@ -10,6 +10,12 @@ export declare class StackItem {
     deletes: IdSetOf;
     /** Per-view metadata (`session/history.ts`: the selections around the step). */
     readonly meta: Map<string, unknown>;
+    /**
+     * The client it was written under when that is not the replica's own (a
+     * suggestion's writer: its transaction's `writer`): it replays under it,
+     * and its records release with the history's.
+     */
+    writer?: number;
     constructor(inserts: IdSetOf, deletes: IdSetOf);
 }
 /** A step taken into a stack: added (a new step) or updated (the open one took a transaction). */

package/dist/crdt/doc/history.js

@@ -15,11 +15,12 @@
 import { getUnixTime } from 'lib0-v14/time';
 import { openSteps, ownTextIds } from '../text/model.js';
 import { readHorizon } from '../purge.js';
-import { BLOCK_NODE, CONTENT_NODE, DATA_LEAF_PREFIX, DEL_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, RELEASE_ROOT, TEXT_DELETES_ROOT, TYPE, WITHDRAW_PREFIX } from '../schema.js';
+import { BLOCK_NODE, CONTENT_NODE, DATA_LEAF_PREFIX, DEL_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, RELEASE_ROOT, SUGGEST_ROOT, TEXT_DELETES_ROOT, TYPE, WITHDRAW_PREFIX } from '../schema.js';
 import { changedUnder, collectable, collectNow, collects, dropSearchMarkers, engineOps, walkIdSet } from '../structs.js';
 import { isInitialized } from './gate.js';
 import { DocumentDestroyedError } from './funnel.js';
 import { registryOf, withdrawOnUndo } from '../placement/model.js';
+import { getOr } from '../../utils.js';
 /** The undo steps a document's history keeps by default: older ones are released. */
 export const DEFAULT_HISTORY_LIMIT = 200;
 /** The origin of the transaction that releases a dropped history step's content. */
@@ -30,6 +31,12 @@ export class StackItem {
     deletes;
     /** Per-view metadata (`session/history.ts`: the selections around the step). */
     meta = new Map();
+    /**
+     * The client it was written under when that is not the replica's own (a
+     * suggestion's writer: its transaction's `writer`): it replays under it,
+     * and its records release with the history's.
+     */
+    writer;
     constructor(inserts, deletes) {
         this.inserts = inserts;
         this.deletes = deletes;
@@ -235,6 +242,8 @@ export class UndoManager {
                 ops.keep(item);
         });
         const step = stack.at(-1);
+        if (tr.writer)
+            step.writer = tr.writer;
         // A streamless block's own text is shared by every replica that
         // typed into it first: no step captures it, so undoing the first
         // typing removes the typing and keeps the text (and nonce).
@@ -264,60 +273,71 @@ export class UndoManager {
         const ops = this.#ops;
         const { records, withdraw, repair } = this.#rules;
         const deletedByHistory = (id) => [this.undoStack, this.redoStack].some((s) => s.some((step) => step.deletes.has(id.client, id.clock)));
-        this.doc.transact((transaction) => {
-            const tr = transaction;
-            while (stack.length > 0 && this.currStackItem === null) {
-                const step = stack.pop();
-                const restore = new Set();
-                const remove = [];
-                const held = [];
-                let changed = false;
-                ops.iterate(tr, step.inserts, (struct) => {
-                    if (!ops.isItem(struct))
-                        return;
-                    const item = ops.latest(tr, struct);
-                    // An atom the step inserted is held whole: its attrs stay with it.
-                    const atom = item.parent?._item;
-                    if (atom?.id &&
-                        isUnit(atom) &&
-                        step.inserts.has(atom.id.client, atom.id.clock))
-                        return;
-                    if (!item.deleted && this.#inScope(item))
-                        remove.push(item);
-                });
-                ops.iterate(tr, step.deletes, (struct) => {
-                    if (!ops.isItem(struct) || !this.#inScope(struct))
-                        return;
-                    // Created and deleted within the step: nothing to bring back.
-                    if (step.inserts.has(struct.id.client, struct.id.clock))
-                        return;
-                    // Text a record holds stays hidden: the record decides (removed with its node).
-                    if ((struct.holds ?? 0) > 0)
-                        return;
-                    restore.add(struct);
-                });
-                for (const item of restore)
-                    changed = ops.redo(tr, item, restore, step.inserts, deletedByHistory) !== null || changed;
-                // Children before parents: more is known when an item is judged.
-                for (let i = remove.length - 1; i >= 0; i--) {
-                    const item = remove[i];
-                    // Text the step wrote is held, never removed: a redo shows it again where it was.
-                    if (isUnit(item))
-                        held.push(item.id.client, item.id.clock, item.length);
-                    else if (!withdraw(item, step))
-                        ops.remove(tr, item);
-                    changed = true;
+        // A step written under another client replays under it, and so does its replay's step.
+        const local = this.doc.clientID;
+        const writer = stack.at(-1)?.writer;
+        this.doc.clientID = writer ?? local;
+        try {
+            this.doc.transact((transaction) => {
+                const tr = transaction;
+                tr.writer = writer;
+                while (stack.length > 0 && this.currStackItem === null) {
+                    const step = stack.pop();
+                    const restore = new Set();
+                    const remove = [];
+                    const held = [];
+                    let changed = false;
+                    ops.iterate(tr, step.inserts, (struct) => {
+                        if (!ops.isItem(struct))
+                            return;
+                        const item = ops.latest(tr, struct);
+                        // An atom the step inserted is held whole: its attrs stay with it.
+                        const atom = item.parent?._item;
+                        if (atom?.id &&
+                            isUnit(atom) &&
+                            step.inserts.has(atom.id.client, atom.id.clock))
+                            return;
+                        if (!item.deleted && this.#inScope(item))
+                            remove.push(item);
+                    });
+                    ops.iterate(tr, step.deletes, (struct) => {
+                        if (!ops.isItem(struct) || !this.#inScope(struct))
+                            return;
+                        // Created and deleted within the step: nothing to bring back.
+                        if (step.inserts.has(struct.id.client, struct.id.clock))
+                            return;
+                        // Text a record holds stays hidden: the record decides (removed with its node).
+                        if ((struct.holds ?? 0) > 0)
+                            return;
+                        restore.add(struct);
+                    });
+                    for (const item of restore)
+                        changed =
+                            ops.redo(tr, item, restore, step.inserts, deletedByHistory) !== null || changed;
+                    // Children before parents: more is known when an item is judged.
+                    for (let i = remove.length - 1; i >= 0; i--) {
+                        const item = remove[i];
+                        // Text the step wrote is held, never removed: a redo shows it again where it was.
+                        if (isUnit(item))
+                            held.push(item.id.client, item.id.clock, item.length);
+                        else if (!withdraw(item, step))
+                            ops.remove(tr, item);
+                        changed = true;
+                    }
+                    records.hold(held);
+                    this.currStackItem = changed ? step : null;
+                    if (changed)
+                        repair(step);
                 }
-                records.hold(held);
-                this.currStackItem = changed ? step : null;
-                if (changed)
-                    repair(step);
-            }
-            tr.changed.forEach((keys, node) => {
-                if (keys.has(null))
-                    dropSearchMarkers(node);
-            });
-        }, this);
+                tr.changed.forEach((keys, node) => {
+                    if (keys.has(null))
+                        dropSearchMarkers(node);
+                });
+            }, this);
+        }
+        finally {
+            this.doc.clientID = local;
+        }
         const step = this.currStackItem;
         this.currStackItem = null;
         return step;
@@ -364,7 +384,9 @@ export class UndoManager {
             const own = ops.idSet();
             for (const step of dropped)
                 walkIdSet(Y, doc, step.inserts, (st, from, to) => {
-                    if (st.parent === records && !st.deleted && st.id.client === doc.clientID)
+                    if (st.parent === records &&
+                        !st.deleted &&
+                        (st.id.client === doc.clientID || st.id.client === step.writer))
                         own.add(st.id.client, from, to - from);
                 });
             const held = ops.idSet();
@@ -444,9 +466,7 @@ export const historyRules = (Y, doc) => {
             if (step.inserts.has(s.id.client, s.id.clock))
                 return;
             const values = s.content;
-            let attrs = lost.get(node);
-            if (attrs === undefined)
-                lost.set(node, (attrs = new Map()));
+            const attrs = getOr(lost, node, () => new Map());
             attrs.set(key, values.getContent().at(-1));
         });
         for (const [node, attrs] of lost) {
@@ -464,7 +484,7 @@ export const historyRules = (Y, doc) => {
     return {
         Y,
         doc,
-        scope: [registryOf(doc), records, doc.get(DOC_DATA_ROOT)],
+        scope: [registryOf(doc), records, doc.get(DOC_DATA_ROOT), doc.get(SUGGEST_ROOT)],
         records,
         withdraw: withdrawOnUndo(doc),
         repair: repairAttrs

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

@@ -0,0 +1,81 @@
+import { type JSONBlock, type JSONInlineBlock, type JSONText } from '../../utils/json.js';
+import { type DataPatch } from '../data.js';
+import { type BlockId, type BlockSpec, type ContentItem, type Destination, type InlineSpec, type SplitTail } from '../placement/model.js';
+import type { DataTarget, Plan, PlanStep, Prepared } from './types.js';
+import type { DocBase, DocReads } from './reads.js';
+import type { DocPosition, RangeView } from '../rangeDelete.js';
+import { type Flow, type FlowTarget, type FlowView } from '../flow.js';
+/**
+ * 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;
+};
+/** An inline atom to insert: its id is minted when it names none. */
+export type NewInline = Omit<InlineSpec, 'id'> & {
+    id?: string;
+};
+/** The prepared ops of one facade over its reads. */
+export declare const docOps: (c: DocBase & DocReads) => {
+    plan: (ids: readonly BlockId[], writes: PlanStep[], at?: DocPosition) => Plan;
+    canPlace: (ids: readonly BlockId[], parent?: BlockId | null, kindOf?: (id: BlockId) => string | undefined) => boolean;
+    fits: (parent: BlockId | null, kind: string | undefined) => boolean;
+    nestParent: (ids: readonly BlockId[], parent: BlockId) => BlockId;
+    canMerge: (fromId: BlockId, intoId: BlockId) => boolean;
+    defaultChild: (parent: BlockId | null) => string;
+    landingOf: (id: BlockId, kind: string, after?: boolean) => {
+        parent: string | null;
+        levels: string[];
+    };
+    besideAt: (target: BlockId, kind?: string) => BlockId;
+    /** Every op of the families, prepared. */
+    prepare: {
+        insertBlocks: (dest: Destination, specs: readonly (BlockSpec | JSONBlock)[]) => Prepared;
+        moveBlocks: (ids: readonly BlockId[], dest: Destination) => Prepared;
+        unNestBlocks: (ids: readonly BlockId[]) => Prepared;
+        unNestBlock: (id: BlockId) => Prepared;
+        liftOut: (id: BlockId, kind: string, { keep, after }?: {
+            keep?: boolean;
+            after?: readonly BlockSpec[];
+        }) => Prepared;
+        duplicateBlock: (id: BlockId, freshId?: (oldId: string, kind: "block" | "inline") => string) => Prepared;
+        placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
+        wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;
+        splitBlock: (id: BlockId, offset: number, newId: BlockId, tail?: SplitTail) => Prepared;
+        mergeBlocks: (fromId: BlockId, intoId: BlockId) => Prepared;
+        mergeBackward: (id: BlockId) => Prepared;
+        mergeForward: (id: BlockId) => Prepared;
+        deleteBlocks: (ids: readonly BlockId[], subtree?: boolean, filled?: BlockId | null) => Prepared;
+        deleteBlock: (id: BlockId, opts?: {
+            keepChildren?: boolean;
+        }) => Prepared;
+        setBlockType: (id: BlockId, type: string) => Prepared;
+        patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
+        setBlock: (id: BlockId, value: {
+            type?: string;
+            data?: Record<string, unknown>;
+            content?: (ContentItem | JSONText | JSONInlineBlock)[];
+            children?: (BlockSpec | JSONBlock)[];
+        }) => Prepared;
+        insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
+        deleteText: (id: BlockId, offset: number, length: number) => Prepared;
+        formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
+        clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
+        insertInline: (id: BlockId, offset: number, atom: NewInline) => Prepared;
+        removeInline: (id: BlockId, inlineId: string) => Prepared;
+        insertFlow: (target: FlowTarget, flow: Flow, view?: FlowView) => Prepared;
+        deleteRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
+        replaceRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
+    };
+};
+export type DocOps = ReturnType<typeof docOps>;