edytor 2.0.0 → 4.0.0

package/dist/crdt/doc/funnel.js

@@ -1,26 +1,21 @@
-/**
- * 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';
 /**
- * Raised when a mutating facade op runs after `dispose()` — disposal is
- * terminal for writes (reads stay dead-safe: a stale handle may still be
- * inspected while its document outlives the facade). The facade-level
- * counterpart of `DocumentDestroyedError` — kept in this module because a
- * bare `bindEdytorDoc` facade has no document layer above it.
+ * Raised when an operation runs against a torn-down document: every attach
+ * reference released, or its facade disposed (terminal for writes; reads
+ * stay dead-safe: a stale handle may still be inspected). Distinct from
+ * `DocumentNotReadyError`: destroyed is terminal, pending may still resolve.
+ * Kept in this module because a bare `bindEdytorDoc` facade has no document
+ * layer above it.
  */
-export class EdytorDocDisposedError extends Error {
+export class DocumentDestroyedError extends Error {
     constructor(service) {
-        super(`EdytorDoc${service ? `.${service}` : ''}: facade is disposed.`);
-        this.name = 'EdytorDocDisposedError';
+        super(`${service ?? 'document'}: the document is destroyed`);
+        this.name = 'DocumentDestroyedError';
     }
 }
 /** The write funnel of one facade. */
@@ -37,7 +32,7 @@ export const writeFunnel = (c) => {
     /** Mutation boundary — every facade write funnels through `write`. */
     const write = (fn) => {
         if (disposed) {
-            throw new EdytorDocDisposedError();
+            throw new DocumentDestroyedError();
         }
         config.assertWritable?.();
         return fn();
@@ -54,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.
@@ -73,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)
@@ -92,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':
@@ -149,7 +155,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);

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: 10;
 export declare const SCHEMA_NAME: "edytor-doc";
 export declare const META_KEY: "meta";
 /**
@@ -86,20 +86,3 @@ export declare class SchemaMismatchError extends Error {
  * mutating a synced document.
  */
 export declare const assertSchema: (doc: EngineDoc, docName?: string) => void;
-/**
- * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade:
- * a foreign engine object (a v13 `yjs` Doc — a different CRDT implementation
- * entirely).
- */
-export declare class UnsupportedDocError extends Error {
-    readonly kind: 'foreign';
-    constructor(kind: 'foreign');
-}
-/**
- * Document-boundary guard run by {@link EdytorDocBinding.create} before the
- * runs view attaches. The facade only speaks the v14 unified-node surface —
- * without this gate a foreign doc dies obscurely inside `buildView`
- * (`registry.forEachAttr is not a function`); it fails fast with an
- * actionable error instead.
- */
-export declare const assertUsableDoc: (doc: EngineDoc) => void;

package/dist/crdt/doc/gate.js

@@ -1,4 +1,4 @@
-import { isNodeLike, SCHEMA } from '../schema.js';
+import { SCHEMA } from '../schema.js';
 export const SCHEMA_VERSION = SCHEMA.version;
 export const SCHEMA_NAME = SCHEMA.name;
 export const META_KEY = SCHEMA.roots.meta;
@@ -51,13 +51,7 @@ export class SchemaMismatchError extends Error {
     docName;
     problem;
     constructor(docName, problem) {
-        super(problem.kind === 'unversioned'
-            ? `Document "${docName}" carries replicated registry state but no meta.v schema version — refusing to treat it as initialized.`
-            : problem.kind === 'unsupported'
-                ? `Document "${docName}" claims unsupported schema version ${problem.version} (this build speaks ${SCHEMA_VERSION}).`
-                : problem.schema === undefined
-                    ? `Document "${docName}" carries meta.v=${problem.version} but no meta.schema manifest name — refusing it as an "${SCHEMA_NAME}" document.`
-                    : `Document "${docName}" claims foreign schema "${String(problem.schema)}" (this build speaks "${SCHEMA_NAME}").`);
+        super(`${docName}: ${problem.kind} schema version ${problem.version} "${String(problem.schema)}" (this build speaks ${SCHEMA_VERSION} "${SCHEMA_NAME}")`);
         this.docName = docName;
         this.problem = problem;
         this.name = 'SchemaMismatchError';
@@ -73,36 +67,3 @@ export const assertSchema = (doc, docName = 'doc') => {
     if (problem !== null)
         throw new SchemaMismatchError(docName, problem);
 };
-/**
- * Error raised by {@link assertUsableDoc} — the doc cannot host a v14 facade:
- * a foreign engine object (a v13 `yjs` Doc — a different CRDT implementation
- * entirely).
- */
-export class UnsupportedDocError extends Error {
-    kind;
-    constructor(kind) {
-        super('Document is not a v14 engine doc — the `blocks` registry is not a ' +
-            'unified Y.Node. Use `crdt.createDoc()` (or `new Y.Doc()` from `edytor/crdt`).');
-        this.kind = kind;
-        this.name = 'UnsupportedDocError';
-    }
-}
-/**
- * Document-boundary guard run by {@link EdytorDocBinding.create} before the
- * runs view attaches. The facade only speaks the v14 unified-node surface —
- * without this gate a foreign doc dies obscurely inside `buildView`
- * (`registry.forEachAttr is not a function`); it fails fast with an
- * actionable error instead.
- */
-export const assertUsableDoc = (doc) => {
-    let registry;
-    try {
-        registry = typeof doc?.get === 'function' ? doc.get(SCHEMA.roots.registry) : undefined;
-    }
-    catch {
-        registry = undefined;
-    }
-    if (!isNodeLike(registry) || typeof registry.forEachAttr !== 'function') {
-        throw new UnsupportedDocError('foreign');
-    }
-};

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';
@@ -33,15 +32,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 +81,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,21 +1,24 @@
 /**
  * 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, 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 { EdytorDocDisposedError } from './funnel.js';
+import { DocumentDestroyedError } from './funnel.js';
 import { registryOf, withdrawOnUndo } from '../placement/model.js';
 /** The undo steps a document's history keeps by default: older ones are released. */
 export const DEFAULT_HISTORY_LIMIT = 200;
@@ -37,6 +40,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 +74,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 +92,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 +144,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,6 +221,14 @@ 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))
@@ -190,13 +255,14 @@ 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;
@@ -204,11 +270,18 @@ export class UndoManager {
                 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);
                 });
@@ -218,25 +291,27 @@ export class UndoManager {
                     // 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
-                        restore.add(struct);
+                    // 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]);
+                    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) {
-                    marks.onApply(tr, step);
+                if (changed)
                     repair(step);
-                }
             }
             tr.changed.forEach((keys, node) => {
                 if (keys.has(null))
@@ -250,8 +325,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 +344,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 +356,32 @@ 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)
+                        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 +413,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 +457,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)],
+        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,
@@ -367,26 +490,13 @@ export const docHistory = (c) => {
      */
     const createUndoManager = (options = {}) => {
         if (disposed()) {
-            throw new EdytorDocDisposedError('createUndoManager');
+            throw new DocumentDestroyedError('createUndoManager');
         }
         write(() => {
             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 };
 };