edytor 3.0.0 → 5.0.0

package/dist/crdt/doc/funnel.js

@@ -1,13 +1,7 @@
-/**
- * The write funnel: every facade write goes through `write` (disposal and the
- * document's writable guard), and every prepared plan through `apply` — one
- * transaction, its result read from what the transaction wrote, and the
- * frame's one attribution pass.
- */
-import { blockNodeOf, buildInline, materializeSpec, ownText, view as modelView, writePlacement, writeSplit } from '../placement/model.js';
-import { ENTRY_FACET } from '../text/runs.js';
-import { AT, DEL_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
-import { writeLeaves } from '../data.js';
+import { blockNodeOf, buildInline, insertSpecsAt, moveBlocksTo, ownText, view as modelView, writeSplit } from '../placement/model.js';
+import { ENTRY_FACET, SEQ_FACET } from '../text/runs.js';
+import { DEL_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../schema.js';
+import { writeData } from '../data.js';
 import { NOOP } from './plan.js';
 import { claimInto, deleteRange, formatRangeIn, insertIntoText } from '../text/model.js';
 /**
@@ -55,8 +49,8 @@ export const writeFunnel = (c) => {
     // Each apply opens a frame that tracks the index's folds. When it
     // closes, ONE pass over the facets the fold saw stamps attribution: a
     // block whose registry entry was created gets its `createdBy` record; a block whose content, claims, type or data
-    // changed gets a contributor stamp; moves and delete marks stamp
-    // nothing. Two intents the effects cannot name are recorded by their
+    // changed gets a contributor stamp; moves (a record or a slot in a
+    // block's sequence) and delete marks stamp nothing. Two intents the effects cannot name are recorded by their
     // steps: a split-born block inherits its source's contributors, and a
     // merge survivor unions the absorbed block's. With no configured
     // `actor` the funnel writes no attribution at all.
@@ -74,9 +68,12 @@ export const writeFunnel = (c) => {
             else
                 for (const facet of facets)
                     if (!facet.startsWith(DEL_PREFIX) &&
-                        ![ENTRY_FACET, AT, ID, LAST_CHANGED_ATTR].includes(facet))
+                        ![ENTRY_FACET, SEQ_FACET, ID, LAST_CHANGED_ATTR].includes(facet))
                         changed.add(id);
         }
+        // A merge changed its survivor (its claim item, written quietly, is no edit of the text holding it).
+        for (const [into] of f.unions)
+            changed.add(into);
         for (const id of created) {
             const node = blockNodeOf(doc, id);
             if (node !== null)
@@ -93,38 +90,46 @@ export const writeFunnel = (c) => {
     /**
      * A streamless block gets its own text before the first write that
      * needs a stream (`ownText`: a writer derived from its dead
-     * incarnation); its attribution record follows the re-minted nonce.
+     * incarnation); its attribution record follows the re-minted nonce. A
+     * claim item needs the block's own stream (`claim`); text, any piece of
+     * its display.
      */
-    const needStream = (id) => {
-        if ((modelView(doc).own.display(id) ?? []).length > 0)
+    const needStream = (id, claim = false) => {
+        const { own } = modelView(doc);
+        if (claim ? own.streamOf(id) !== undefined : (own.display(id) ?? []).length > 0)
             return;
         const { from, to } = ownText(doc, id);
         BA.retarget(doc, id, from, to);
     };
     /** One planned step, written (the plan decided it; writers never refuse). */
     const writeStep = (w, f) => {
-        // Structural steps need no view: delete marks and placements write one node.
+        // Delete marks need no view: they write one node.
         if (w.op === 'deleteBlock')
             return w.marks.forEach((id) => blockNodeOf(doc, id).setAttr(DEL_PREFIX + doc.clientID, true));
         if (w.op === 'splitBlock' || w.op === 'insertText' || w.op === 'insertInline')
             needStream(w.id);
-        const { blocks, own } = modelView(doc);
+        // A claim item goes at the end of the stream of the block merged into.
+        if (w.op === 'mergeBlocks')
+            needStream(w.into, true);
+        const v = modelView(doc);
+        const { blocks, own } = v;
         const node = (id) => blockNodeOf(doc, id);
         switch (w.op) {
             case 'insertBlocks':
-                return w.specs.forEach((sp, i) => materializeSpec(doc, sp, w.parent, w.ranks[i]));
+                return insertSpecsAt(doc, v, w.parent, w.index, w.specs, w.split === undefined ? null : (f.bounds.get(w.split) ?? null));
             case 'moveBlocks':
-                return w.ids.forEach((id, i) => writePlacement(doc, node(id), w.parent, w.ranks[i]));
+                return moveBlocksTo(doc, v, w.ids, w.parent, w.index, w.side ?? 0, w.part ?? 0, w.at ?? null);
             case 'splitBlock':
                 f.inherit.set(w.newId, w.id);
-                return writeSplit(doc, w.id, w.offset, w.newId, w.tail, { p: w.parent, r: w.rank });
+                f.bounds.set(w.newId, writeSplit(doc, w.id, w.offset, w.newId, w.tail, w.parent, w.index));
+                return;
             case 'mergeBlocks':
                 f.unions.push([w.into, w.from]);
-                return claimInto(blocks, own, w.from, w.into);
+                return f.quiet(() => claimInto(own, w.from, w.into));
             case 'setBlockType':
                 return void node(w.id).setAttr(TYPE, w.type);
             case 'patchData':
-                return writeLeaves(dataNode(w.id, w.inlineId), w.leaves);
+                return writeData(dataNode(w.id, w.inlineId), w.writes);
             case 'insertText':
                 return insertIntoText(doc, blocks, own, w.id, w.offset, w.text, w.marks);
             case 'insertInline':
@@ -141,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()) {
@@ -150,7 +157,7 @@ export const writeFunnel = (c) => {
         }
         return write(() => doc.transact(() => {
             const frame = runsView.track();
-            const f = { inherit: new Map(), unions: [] };
+            const f = { inherit: new Map(), bounds: new Map(), unions: [], quiet: frame.quiet };
             try {
                 for (const w of p.writes)
                     writeStep(w, f);
@@ -161,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

@@ -17,15 +17,15 @@
  *
  * ```
  * doc.get('blocks')                      registry — flat map, blockId → node('block')
- *   └ <blockId>                           id/n/type/data/del + content/claims/at
- *                                         (n: incarnation nonce)
+ *   └ <blockId>                           n/type/d/…/del./wd./l + content
+ *                                         (n: incarnation nonce; the id is the key)
  * doc.get('meta')                        version record root
  *   ├ v : number                          SCHEMA_VERSION (LWW attr — concurrent init converges)
  *   └ schema : 'edytor-doc'               SCHEMA_NAME
  * ```
  */
 import type { EngineDoc } from '../engine-api.js';
-export declare const SCHEMA_VERSION: 6;
+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

@@ -1,5 +1,4 @@
 import type { EngineApi, EngineDoc, EngineNode } from '../engine-api.js';
-import type { TextDeletes } from '../text/deletes.js';
 import { type IdSetOf, type StoreStruct } from '../structs.js';
 import { type WriteFunnel } from './funnel.js';
 import type { DocBase } from './reads.js';
@@ -11,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). */
@@ -33,15 +38,12 @@ export type HistoryOptions = {
     }) => boolean;
 };
 /** What a history is made over: the document and the rules of its replay. */
-type Rules = {
+export type Rules = {
     Y: EngineApi;
     doc: EngineDoc;
     scope: EngineNode[];
-    /** The text delete marks' restore and apply rules (`text/deletes.ts`). */
-    marks: {
-        restoreFilter(item: unknown): boolean;
-        onApply(tr: unknown, step: StackItem): void;
-    };
+    /** The records list a replay's text holds go to (fork patch YP20). */
+    records: EngineNode;
     /** Whether an item a replay would delete is withdrawn instead (`hist.undo.withdraw`). */
     withdraw(item: StoreStruct, step: StackItem): boolean;
     /** Repair the attrs a replay left undefined. */
@@ -85,16 +87,36 @@ export declare class UndoManager {
     redo(): StackItem | null;
     /** Drop every step (undo and redo) and release what they kept for their replay. */
     clear(): void;
+    /**
+     * The session ends: its page left for good (`hist.release.end`). Every
+     * step is dropped and released as a dropped step is (`#release`: what
+     * they kept is collected, the text this writer's records hold is
+     * deleted for good), in one transaction that, when a step marked a block
+     * deleted or withdrawn, also appends one release record (the
+     * {@link RELEASE_ROOT} list): its id names this writer and the clock the
+     * history ended at, so the room's purge removes what those marks hide at
+     * its next tick, past the horizon or not. Then the manager stops
+     * capturing (it is destroyed; the document attaches a fresh one if asked).
+     * A history that captured nothing writes nothing. Only for a page that
+     * cannot come back: a page the back/forward cache keeps, or one that
+     * only lost its connection, keeps its history.
+     */
+    end(): void;
     destroy: () => void;
 }
 /** What a facade's history is made over: its doc, the write funnel and the bound engine layers. */
 export type HistoryContext = DocBase & Pick<WriteFunnel, 'write' | 'disposed'> & {
-    D: TextDeletes;
     /** Stamp the version record before the history attaches. */
     init: (doc: EngineDoc) => void;
 };
+/**
+ * The document's history rules over `doc` (the one set every history of an
+ * edytor document runs): its scope (the block registry, the text hold
+ * records, the document's data), the records a replay's text holds go to,
+ * the withdraw rule (`hist.undo.withdraw`) and the attr repair below.
+ */
+export declare const historyRules: (Y: EngineApi, doc: EngineDoc) => Rules;
 /** The history factory of one facade. */
 export declare const docHistory: (c: HistoryContext) => {
     createUndoManager: (options?: HistoryOptions) => UndoManager;
 };
-export {};

package/dist/crdt/doc/history.js

@@ -1,18 +1,21 @@
 /**
  * The document's history: the one undo manager (fork patch YP18 removed the
  * engine's). It captures the tracked local transactions that write in its
- * scope (the block registry, the text delete marks, the document's data)
+ * scope (the block registry, the text hold records, the document's data)
  * into steps, and an undo or a redo replays a step in one transaction over
- * the engine's struct primitives (`redoItem`, `keepItem`). Its rules: text
- * comes back as the delete marks allow (`hist.undo.restore`), an undone
+ * the engine's struct primitives (`redoItem`, `keepItem`). Its rules: a text
+ * delete is a hold record (fork patch YP20), so undoing it deletes the record
+ * and the text shows again unless another writer's record holds it
+ * (`hist.undo.restore`); undoing typing holds the typed text; an undone
  * creation is withdrawn (`hist.undo.withdraw`), an overwritten attr is
- * repaired, the stack keeps `limit` steps, and the purge horizon drops the
- * steps below it (`hist.purge.horizon`).
+ * repaired, the stack keeps `limit` steps, the purge horizon drops the
+ * steps below it (`hist.purge.horizon`), and a session's end releases them
+ * all (`hist.release.end`).
  */
 import { getUnixTime } from 'lib0-v14/time';
-import { ownTextIds } from '../text/model.js';
+import { openSteps, ownTextIds } from '../text/model.js';
 import { readHorizon } from '../purge.js';
-import { BLOCK_NODE, DATA_LEAF_PREFIX, DOC_DATA_ROOT, HORIZON_ROOT, INLINE_NODE, LAST_CHANGED_ATTR, TYPE } 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';
@@ -27,6 +30,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;
@@ -37,6 +46,13 @@ const REPAIRED = {
     [BLOCK_NODE]: [TYPE, LAST_CHANGED_ATTR],
     [INLINE_NODE]: [TYPE]
 };
+/** A unit of a block's text: a character or an inline atom (what a hold record holds). */
+const isUnit = (it) => {
+    const content = it.content;
+    return (it.parentSub === null &&
+        it.parent?.name === CONTENT_NODE &&
+        (typeof content?.str === 'string' || content?.type?.name === INLINE_NODE));
+};
 /**
  * A document's undo manager: the undo and redo stacks of the tracked local
  * transactions in its scope. `undo()`/`redo()` replay the top step and
@@ -64,6 +80,10 @@ export class UndoManager {
     /** What dropped steps released (an item is released once every step that deleted it is gone). */
     #released;
     #horizon;
+    /** A captured step wrote a block's delete or withdraw mark: the session's end records its release. */
+    #marked = false;
+    /** The session ended (`end()`): nothing more is released. */
+    #ended = false;
     constructor(rules, options = {}) {
         this.#rules = rules;
         this.#ops = engineOps(rules.Y);
@@ -78,7 +98,19 @@ export class UndoManager {
         this.trackedOrigins.add(this);
         this.#ops.on(rules.doc, 'afterTransaction', this.#afterTransaction);
         this.#ops.on(rules.doc, 'destroy', this.destroy);
+        const open = openSteps.get(rules.doc) ?? new Set();
+        openSteps.set(rules.doc, open.add(this.#open));
     }
+    /** What the step still capturing inserted (`null`: none is open): a text delete there removes. */
+    #open = () => {
+        const top = this.undoStack.at(-1);
+        const open = top !== undefined &&
+            !this.undoing &&
+            !this.redoing &&
+            this.lastChange > 0 &&
+            getUnixTime() - this.lastChange < this.captureTimeout;
+        return open ? top.inserts : null;
+    };
     /** Be told of every step taken into a stack (added, or the open one updated). Returns the unsubscribe. */
     observe(f) {
         this.#observers.add(f);
@@ -118,8 +150,39 @@ export class UndoManager {
     clear() {
         this.#release([...this.undoStack.splice(0), ...this.redoStack.splice(0)]);
     }
+    /**
+     * The session ends: its page left for good (`hist.release.end`). Every
+     * step is dropped and released as a dropped step is (`#release`: what
+     * they kept is collected, the text this writer's records hold is
+     * deleted for good), in one transaction that, when a step marked a block
+     * deleted or withdrawn, also appends one release record (the
+     * {@link RELEASE_ROOT} list): its id names this writer and the clock the
+     * history ended at, so the room's purge removes what those marks hide at
+     * its next tick, past the horizon or not. Then the manager stops
+     * capturing (it is destroyed; the document attaches a fresh one if asked).
+     * A history that captured nothing writes nothing. Only for a page that
+     * cannot come back: a page the back/forward cache keeps, or one that
+     * only lost its connection, keeps its history.
+     */
+    end() {
+        if (this.#ended)
+            return;
+        this.#ended = true;
+        const dropped = [...this.undoStack.splice(0), ...this.redoStack.splice(0)];
+        const marked = this.#marked;
+        if (dropped.length > 0 || marked)
+            this.doc.transact(() => {
+                this.#release(dropped);
+                if (marked) {
+                    const records = this.doc.get(RELEASE_ROOT);
+                    records.insert(records.length, [true]);
+                }
+            }, HISTORY_TRIM);
+        this.destroy();
+    }
     destroy = () => {
         this.trackedOrigins.delete(this);
+        openSteps.get(this.doc)?.delete(this.#open);
         this.#ops.off(this.doc, 'afterTransaction', this.#afterTransaction);
         this.#ops.off(this.doc, 'destroy', this.destroy);
         this.#observers.clear();
@@ -164,12 +227,22 @@ export class UndoManager {
             stack.push(new StackItem(tr.insertSet, tr.deleteSet));
         if (!undoing && !redoing)
             this.lastChange = now;
+        // A block's delete or withdraw mark: what it hides waits for this
+        // history (its end releases it to the purge, `end()`).
+        if (!this.#marked)
+            for (const keys of tr.changed.values())
+                for (const key of keys)
+                    if (typeof key === 'string' &&
+                        (key.startsWith(DEL_PREFIX) || key.startsWith(WITHDRAW_PREFIX)))
+                        this.#marked = true;
         // What the step deleted is kept from collection while a step may bring it back.
         ops.iterate(tr, tr.deleteSet, (item) => {
             if (ops.isItem(item) && this.#inScope(item))
                 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).
@@ -190,59 +263,80 @@ export class UndoManager {
     }
     /**
      * Replay the top step of `stack` in one transaction (origin: this
-     * manager): what it inserted is deleted (or withdrawn), what it deleted
-     * comes back (text as its delete marks allow), the overwritten attrs are
+     * manager): what it inserted is deleted (text: held by a record of this
+     * writer; a block: withdrawn), what it deleted comes back (a text delete
+     * was a record: deleting it shows the text), the overwritten attrs are
      * repaired. A step that changes nothing is skipped for the one below.
      */
     #pop(stack) {
         const ops = this.#ops;
-        const { marks, withdraw, repair } = this.#rules;
+        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 = [];
-                let changed = false;
-                ops.iterate(tr, step.inserts, (struct) => {
-                    if (!ops.isItem(struct))
-                        return;
-                    const item = ops.latest(tr, struct);
-                    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 comes back through the delete marks (`onApply`): withheld here.
-                    if (!marks.restoreFilter(struct))
-                        changed = true;
-                    else
+        // 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--) {
-                    if (!withdraw(remove[i], step))
-                        ops.remove(tr, remove[i]);
-                    changed = true;
-                }
-                this.currStackItem = changed ? step : null;
-                if (changed) {
-                    marks.onApply(tr, step);
-                    repair(step);
+                    });
+                    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);
                 }
-            }
-            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;
@@ -250,8 +344,8 @@ export class UndoManager {
     /**
      * Release what dropped steps kept for their replay: the engine collects
      * that content now, as it would have at the delete without a history
-     * (the doc's `gcFilter` still decides: a text copy another replica may
-     * have to copy again stays, `text/deletes.ts`). An item is released only
+     * (the doc's `gcFilter` still decides), and the text their hold records
+     * hold is deleted for good. An item is released only
      * once every step that deleted part of it was dropped (the engine merges
      * deleted items across steps): never split, so the store keeps its
      * merged items. Only the items themselves are released: a kept
@@ -269,6 +363,8 @@ export class UndoManager {
             return (released.clients.get(st.id.client)?.getIds() ?? []).some((r) => r.clock <= st.id.clock && end <= r.clock + r.len);
         };
         const gc = collects(doc);
+        const ops = this.#ops;
+        const { records } = this.#rules;
         doc.transact((tr) => {
             for (const step of dropped)
                 walkIdSet(Y, doc, step.deletes, (st) => {
@@ -279,6 +375,34 @@ export class UndoManager {
                     if (gc && it.deleted && collectable(doc, it))
                         collectNow(it, tr);
                 });
+            // A dropped step's text deletes can never be undone here: what this
+            // writer's live records hold is deleted for good, as the purge does,
+            // and the engine collects it (`hist.delete-marks.release`). A record
+            // a captured remote frame wrote (the room's validation) is its
+            // writer's to take back.
+            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 || st.id.client === step.writer))
+                        own.add(st.id.client, from, to - from);
+                });
+            const held = ops.idSet();
+            ops.iterate(tr, own, (st) => {
+                const ids = st.content?.ids;
+                if (st.deleted || ids === undefined)
+                    return;
+                for (let i = 0; i < ids.length; i += 3)
+                    held.add(ids[i], ids[i + 1], ids[i + 2]);
+                ops.remove(tr, st);
+            });
+            ops.iterate(tr, held, (it) => {
+                if (it.removed !== false)
+                    return;
+                ops.remove(tr, it);
+                dropSearchMarkers(it.parent);
+            });
         }, HISTORY_TRIM);
     }
     /**
@@ -310,9 +434,13 @@ export class UndoManager {
         this.#release(dropped);
     }
 }
-/** The history factory of one facade. */
-export const docHistory = (c) => {
-    const { Y, doc, D, init, write, disposed } = c;
+/**
+ * The document's history rules over `doc` (the one set every history of an
+ * edytor document runs): its scope (the block registry, the text hold
+ * records, the document's data), the records a replay's text holds go to,
+ * the withdraw rule (`hist.undo.withdraw`) and the attr repair below.
+ */
+export const historyRules = (Y, doc) => {
     /**
      * Undo repair, inside the replay's transaction. A replayed step
      * deletes its own attr write and re-creates the value that write
@@ -350,9 +478,25 @@ export const docHistory = (c) => {
                     node.setAttr(key, value);
         }
     };
+    // The text hold records are in scope (an undo deletes the undoer's
+    // own, fork patch YP20). An undone creation withdraws the block instead
+    // of deleting it (`hist.undo.withdraw`).
+    const records = doc.get(TEXT_DELETES_ROOT);
+    return {
+        Y,
+        doc,
+        scope: [registryOf(doc), records, doc.get(DOC_DATA_ROOT), doc.get(SUGGEST_ROOT)],
+        records,
+        withdraw: withdrawOnUndo(doc),
+        repair: repairAttrs
+    };
+};
+/** The history factory of one facade. */
+export const docHistory = (c) => {
+    const { Y, doc, init, write, disposed } = c;
     /**
      * The document's undo manager, SCOPED TO THE BLOCK REGISTRY (with the
-     * text delete marks and the document's data), attached only after the
+     * text hold records and the document's data), attached only after the
      * doc carries the schema version record:
      *
      * - the `meta` root (version stamp, schema name) is outside the scope,
@@ -373,20 +517,7 @@ export const docHistory = (c) => {
             if (!isInitialized(doc))
                 init(doc);
         });
-        // Text delete marks (`text/deletes.ts`): the marks are in scope (an undo
-        // removes the undoer's own), and the history restores text only as the
-        // marks allow. An undone creation withdraws the block instead of
-        // deleting it (`hist.undo.withdraw`).
-        const marks = D.history(doc, () => um);
-        const um = new UndoManager({
-            Y,
-            doc,
-            scope: [registryOf(doc), D.scope(doc), doc.get(DOC_DATA_ROOT)],
-            marks,
-            withdraw: withdrawOnUndo(doc),
-            repair: repairAttrs
-        }, options);
-        return um;
+        return new UndoManager(historyRules(Y, doc), options);
     };
     return { createUndoManager };
 };