edytor 4.0.0 → 6.0.0

package/dist/crdt/text/index/shared.d.ts

@@ -1,7 +1,7 @@
 import type { EngineNode } from '../../engine-api.js';
 import type { BlockId, BlockRec } from '../../placement/model.js';
 import type { ContentRun, DisplayRoles } from '../runs.js';
-import type { SelfChecks } from './state.js';
+import type { IndexFacts, SelfChecks } from './build.js';
 /**
  * The facet name of a block's registry entry itself (inserted or removed) —
  * every other facet is named by the block attr it entered through.
@@ -65,12 +65,8 @@ export declare const sameShape: (roles: DisplayRoles, a: string, b: string) => b
  */
 export declare const indexChecks: {
     on: boolean;
-    of?: (ix: never) => SelfChecks;
+    of?: (facts: IndexFacts) => SelfChecks;
 };
-/** `ix`'s checker ({@link indexChecks}), built on its first check. */
-export declare const checksOf: (ix: {
-    checks: SelfChecks | null;
-}) => SelfChecks;
 /** Add `value` to `key`'s set in `index`. */
 export declare const addTo: <K, V>(index: Map<K, Set<V>>, key: K, value: V) => void;
 /** Remove `value` from `key`'s set in `index` (the set goes once empty). */

package/dist/crdt/text/index/shared.js

@@ -5,6 +5,7 @@
  */
 import { cloneJsonSafe } from '../../../utils/json.js';
 import { CONTENT, DATA, DATA_LEAF_PREFIX, ID, LAST_CHANGED_ATTR, TYPE } from '../../schema.js';
+import { getOr } from '../../../utils.js';
 /**
  * The facet name of a block's registry entry itself (inserted or removed) —
  * every other facet is named by the block attr it entered through.
@@ -67,20 +68,23 @@ export const EMPTY_IDS = Object.freeze([]);
  * its children.
  */
 export const sameShape = (roles, a, b) => {
-    const lines = new Set(roles.lineKinds());
-    const items = new Set([...roles.layoutKinds()].map((type) => roles.layout(type)));
-    const rows = new Set([...roles.tableKinds()].flatMap((type) => roles.table(type) ?? []));
-    const cells = new Set([...rows].map((row) => roles.defaultChild(row)));
-    return (roles.childless(a) === roles.childless(b) &&
-        roles.island(a) === roles.island(b) &&
-        roles.container(a) === roles.container(b) &&
-        roles.line(a) === roles.line(b) &&
-        lines.has(a) === lines.has(b) &&
-        roles.layout(a) === roles.layout(b) &&
-        items.has(a) === items.has(b) &&
-        roles.table(a) === roles.table(b) &&
-        rows.has(a) === rows.has(b) &&
-        cells.has(a) === cells.has(b));
+    const { lines, items, rows, cells } = roles.declared();
+    const shape = (t) => {
+        const k = roles.of(t);
+        return JSON.stringify([
+            k.childless,
+            k.island,
+            k.container,
+            k.line,
+            lines.has(t),
+            k.layout,
+            items.has(t),
+            k.table,
+            rows.has(t),
+            cells.has(t)
+        ]);
+    };
+    return shape(a) === shape(b);
 };
 /**
  * The index's self-checks, off in production: a test lane's setup installs
@@ -90,13 +94,9 @@ export const sameShape = (roles, a, b) => {
  * difference; after every report, the published tree.
  */
 export const indexChecks = { on: false };
-/** `ix`'s checker ({@link indexChecks}), built on its first check. */
-export const checksOf = (ix) => (ix.checks ??= indexChecks.of(ix));
 /** Add `value` to `key`'s set in `index`. */
 export const addTo = (index, key, value) => {
-    let set = index.get(key);
-    if (set === undefined)
-        index.set(key, (set = new Set()));
+    const set = getOr(index, key, () => new Set());
     set.add(value);
 };
 /** Remove `value` from `key`'s set in `index` (the set goes once empty). */

package/dist/crdt/text/model.d.ts

@@ -277,6 +277,16 @@ export declare const insertIntoText: (doc: EngineDoc, blocks: unknown, own: Owne
  * that step's undo still changes nothing.
  */
 export declare const deleteRange: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, length: number) => void;
+/**
+ * A suggestion's plan being written on a doc (`doc/suggest.ts`): its text
+ * deletes propose (fork patch YP32) into its record, `sort` telling each
+ * unit's lot (`1` its author's own: held; `2` proposed; `3` already
+ * proposed: stepped over).
+ */
+export declare const proposing: WeakMap<EngineDoc, {
+    into: EngineNode;
+    sort: (client: number, clock: number) => number;
+}>;
 export declare const formatRangeIn: (doc: EngineDoc, blocks: unknown, own: Ownership, b: BlockId, offset: number, length: number, formats: Record<string, unknown>) => void;
 /**
  * Delete the content of streams `streams` (the room's purge of a

package/dist/crdt/text/model.js

@@ -7,6 +7,7 @@ import { fitMarks, writeMarks } from './marks.js';
 import { nodeStart } from './items.js';
 import { readRange } from './ranges.js';
 import { claimsIn, delimiters, displayOf, locate, ownedLength, pieces, placeText, rangesOf, removedKeys, scanText } from './streams.js';
+import { getOr } from '../../utils.js';
 export { isBoundary, isClaimItem, isRowMark, nodeStart } from './items.js';
 export { canonKey, deepFreeze, inlineItemOf, protectItems, readRange } from './ranges.js';
 export { byId, claimsIn, delimiters, displayOf, locate, ownedLength, pieces, placeText, removedKeys, scanText } from './streams.js';
@@ -107,9 +108,7 @@ export const readSegs = (segs, stats) => {
     const out = [];
     const cursors = new Map();
     for (const seg of segs) {
-        let cur = cursors.get(seg.text);
-        if (cur === undefined)
-            cursors.set(seg.text, (cur = openRangeCursor(seg.text)));
+        const cur = getOr(cursors, seg.text, () => openRangeCursor(seg.text));
         readRange(cur, seg.i0, seg.i1, stats, out);
     }
     return out;
@@ -198,8 +197,15 @@ export const deleteRange = (doc, blocks, own, b, offset, length) => {
     const records = doc.get(TEXT_DELETES_ROOT);
     const fresh = openInserts(doc);
     for (const r of rangesOf(flatten(b, blocks, own), offset, offset + length))
-        r.text.delete(r.a, r.b - r.a, records, fresh);
+        r.text.delete(r.a, r.b - r.a, records, fresh, proposing.get(doc));
 };
+/**
+ * A suggestion's plan being written on a doc (`doc/suggest.ts`): its text
+ * deletes propose (fork patch YP32) into its record, `sort` telling each
+ * unit's lot (`1` its author's own: held; `2` proposed; `3` already
+ * proposed: stepped over).
+ */
+export const proposing = new WeakMap();
 export const formatRangeIn = (doc, blocks, own, b, offset, length, formats) => {
     for (const r of rangesOf(flatten(b, blocks, own), offset, offset + length))
         writeMarks(doc, r.text, r.a, r.b - r.a, formats);

package/dist/crdt/text/runs.d.ts

@@ -53,17 +53,16 @@
  * advancing the published tree in place (after a whole rebuild, the
  * reachable tree is compared).
  *
- * The index is built from parts under `index/`, each over the shared state
- * (`index/state.ts`) and the parts before it: the claim graph
- * (`claims.ts`), the stream table and each block's claims (`streams.ts`),
- * the layout rules (`layout.ts`), placements and the
- * children index (`placement.ts`), block records (`records.ts`), the run
- * cache (`cache.ts`), the fold (`fold.ts`), the change report
- * (`report.ts`); the self-checks a test lane installs are `indexChecks`. This module declares the
- * index's types and wires the parts into the doc's one index.
+ * The index is one closure (`index/build.ts`) over its state: the claim
+ * graph, the stream table and each block's claims, the layout rules,
+ * placements and the children index, block records, the run cache, the fold
+ * and the change report; the self-checks a test lane installs are
+ * `indexChecks`. This module declares the index's types.
  */
-import type { EngineApi, EngineDoc } from '../engine-api.js';
+import type { EngineApi } from '../engine-api.js';
 import type { BlockId, ContentItem, ModelView, ProjectedBlock } from '../placement/model.js';
+import { indexOf } from './index/build.js';
+export { indexOf };
 export { CONTENT_ATTR, ENTRY_FACET, SEQ_FACET, indexChecks } from './index/shared.js';
 /**
  * One visible run of a block — the maintained form of `ContentItem`.
@@ -220,42 +219,44 @@ export type RunView = {
     debug: RunViewDebug;
 };
 /**
- * The role table — one answer per kind, which the display and the
- * document's guards both ask. `childless`: kinds that display no children
- * (void roles) — a child of such a block displays in its slot.
- * `island`: a block promoted out of an island kind displays as
- * `defaultChild` of its display parent's kind (`null`: the root). `line`:
- * an island declared `lines` holds only lines — each direct child displays
- * as its line kind and holds no children. `container`: a
- * kind that renders no content and is neither void nor an island (a list)
- * — a block promoted out of one follows like one promoted out of an island. `rendersContent`: no block that renders content ever shows
- * as a kind that does not (its text would vanish). `layout`: a
- * layout kind displays only its items, and only two or more (`layout.*`).
- * `table`: a table kind displays only its rows, a row only its cells, in
- * the table's column order (`table.*`).
+ * A kind's answers, read once from its role (the one shape the display and
+ * every guard read). `childless`: displays no children (a void role) — a
+ * child of such a block displays in its slot. `island`: a block promoted
+ * out of one displays as `child` of its display parent's kind.
+ * `container`: renders no content and is neither void nor an island (a
+ * list) — a block promoted out of one follows like one promoted out of an
+ * island. `rendersContent`: no block that renders content ever shows as a
+ * kind that does not (its text would vanish). `child`: its default child
+ * (the document's default kind for the root, `null`). `line`: an island
+ * declared `lines` holds only lines of this kind, which hold no children.
+ * `layout`: a layout displays only items of this kind, and only two or
+ * more (`layout.*`). `table`: a table displays only rows of this kind, a
+ * row only its cells, in the table's column order (`table.*`).
  */
+export type KindRole = {
+    childless: boolean;
+    island: boolean;
+    container: boolean;
+    rendersContent: boolean;
+    child: string;
+    line?: string;
+    layout?: string;
+    table?: string;
+};
+/** The kinds the roles declare: line kinds, layout kinds and their item kinds, table kinds and their row kinds (→ cell kind). */
+export type DeclaredKinds = {
+    lines: ReadonlySet<string>;
+    layouts: readonly string[];
+    items: ReadonlySet<string>;
+    rows: ReadonlyMap<string, string>;
+    cells: ReadonlySet<string>;
+};
+/** The role table: each kind's {@link KindRole} and the declared kinds, both read once until the roles change. */
 export type DisplayRoles = {
-    childless: (type: string) => boolean;
-    island: (type: string) => boolean;
-    container: (type: string) => boolean;
-    rendersContent: (type: string) => boolean;
-    defaultChild: (parentType: string | null) => string;
-    /** The line kind of an island kind declared `lines` (its `defaultChild`), if any. */
-    line: (islandType: string) => string | undefined;
-    /** Every line kind the roles declare, present in the document or not. */
-    lineKinds: () => Iterable<string>;
-    /** The item kind of a layout kind (its `defaultChild`), if `type` is one. */
-    layout: (type: string) => string | undefined;
-    /** Every layout kind the roles declare, present in the document or not. */
-    layoutKinds: () => Iterable<string>;
-    /** The row kind of a table kind (its `defaultChild`), if `type` is one (`table.*`). */
-    table: (type: string) => string | undefined;
-    /** Every table kind the roles declare, present in the document or not. */
-    tableKinds: () => Iterable<string>;
+    of: (type: string | null) => KindRole;
+    declared: () => DeclaredKinds;
 };
-/** The doc's index — built on first use, torn down when the doc is destroyed. */
-export declare const indexOf: (doc: EngineDoc) => RunView;
 /** The index binding (the public binding's `runs`): {@link indexOf}. */
 export declare const bindRuns: (_Y: EngineApi) => {
-    attach: (doc: EngineDoc) => RunView;
+    attach: (doc: import("../engine-api.js").EngineDoc) => RunView;
 };

package/dist/crdt/text/runs.js

@@ -1,168 +1,5 @@
-import { isNodeLike } from '../schema.js';
-import { cloneJsonSafe } from '../../utils/json.js';
-import { indexState } from './index/state.js';
-import { indexClaims } from './index/claims.js';
-import { indexStreams } from './index/streams.js';
-import { indexLayout } from './index/layout.js';
-import { indexPlacement } from './index/placement.js';
-import { indexRecords } from './index/records.js';
-import { indexCache } from './index/cache.js';
-import { indexFold } from './index/fold.js';
-import { indexReporter } from './index/report.js';
+import { indexOf } from './index/build.js';
+export { indexOf };
 export { CONTENT_ATTR, ENTRY_FACET, SEQ_FACET, indexChecks } from './index/shared.js';
-/** One index per engine doc, shared by every binding (the doc's lifetime). */
-const indexes = new WeakMap();
-/** The doc's index — built on first use, torn down when the doc is destroyed. */
-export const indexOf = (doc) => {
-    let index = indexes.get(doc);
-    if (index === undefined)
-        indexes.set(doc, (index = buildView(doc)));
-    return index;
-};
 /** The index binding (the public binding's `runs`): {@link indexOf}. */
 export const bindRuns = (_Y) => ({ attach: indexOf });
-const buildView = (doc) => {
-    // The index's parts, each over the state and the parts before it (`index/*`).
-    const ix0 = indexState(doc);
-    const ix1 = Object.assign(ix0, indexClaims(ix0));
-    const ix2 = Object.assign(ix1, indexStreams(ix1));
-    const ix4 = Object.assign(ix2, indexLayout(ix2));
-    const ix5 = Object.assign(ix4, indexPlacement(ix4));
-    const ix6 = Object.assign(ix5, indexRecords(ix5));
-    const ix7 = Object.assign(ix6, indexCache(ix6));
-    const ix8 = Object.assign(ix7, indexFold(ix7));
-    const ix = Object.assign(ix8, indexReporter(ix8));
-    const { registry, blocks, rows, homeOfText, shells, placementsMap, frames, displays, ownShim, ensurePlacements, typeOf, order, rebuildTable, scanRow, applyReclaims, updateBlockRec, syncIncarnations, intern, debug, runs, settle, syncPending, syncAll, openTx, onCommit, committed, itemsOf, projectBlock, publish, onUpdate, onReport, hasSubscribers } = ix;
-    const ctx = {
-        blocks,
-        own: ownShim,
-        get placements() {
-            ensurePlacements();
-            return placementsMap;
-        },
-        get kids() {
-            ensurePlacements();
-            return ix.kidsMap;
-        },
-        get order() {
-            ensurePlacements();
-            return order();
-        },
-        // The publication boundary shares THIS interner, so a payload
-        // emitted by `project()`/`contentItems()` is `===` the runs' one.
-        intern,
-        displays,
-        accepted: (id) => {
-            ensurePlacements();
-            return ix.rejected.has(id) ? null : (ix.edges.get(id) ?? null);
-        }
-    };
-    // ── initial scan: index every existing block ────────────────────
-    registry.forEachAttr((v, id) => {
-        if (!isNodeLike(v))
-            return;
-        updateBlockRec(id);
-        for (const b of [id, ...syncIncarnations(id)]) {
-            const row = scanRow(b);
-            if (row !== undefined) {
-                rows.set(b, row);
-                homeOfText.set(row.text, b);
-            }
-        }
-    });
-    rebuildTable(new Set());
-    applyReclaims(null);
-    settle(shells, null);
-    // Every commit folds once, before the document's `afterTransaction` listeners.
-    doc.on('commit', onCommit);
-    /** Derived state lives exactly as long as the doc. */
-    const teardown = () => {
-        doc.off('commit', onCommit);
-        doc.off('destroy', teardown);
-        doc.off('update', onUpdate);
-        indexes.delete(doc);
-    };
-    doc.on('destroy', teardown);
-    // ── public surface ───────────────────────────────────────────────
-    const view = {
-        version: () => {
-            syncAll();
-            return ix.version;
-        },
-        runs,
-        contentItems: (b) => {
-            syncAll();
-            return blocks.get(b)?.deleted === false ? itemsOf(b) : [];
-        },
-        // Inline atoms always carry `data` (`{}` when absent) — the public
-        // `JSONInlineBlock` shape of `edytor.value`.
-        contentJSON: (b) => runs(b).map((r) => r.kind === 'text'
-            ? { text: r.text, ...(r.marks !== undefined && { marks: cloneJsonSafe(r.marks) }) }
-            : { id: r.id, type: r.type, data: r.data === undefined ? {} : cloneJsonSafe(r.data) }),
-        view: (tr) => {
-            syncAll();
-            if (tr !== undefined && !committed.has(tr))
-                syncPending(tr);
-            return ctx;
-        },
-        displayType: (id) => {
-            if (ix.roles === null)
-                return undefined;
-            syncAll();
-            ensurePlacements();
-            const shown = blocks.has(id) ? typeOf(id) : undefined;
-            return shown === blocks.get(id)?.type ? undefined : shown;
-        },
-        dissolved: (id) => {
-            syncAll();
-            ensurePlacements();
-            return ix.dissolved.has(id);
-        },
-        project: (root) => {
-            syncAll();
-            ensurePlacements();
-            return root === undefined
-                ? (ix.kidsMap.get(null) ?? []).map((k) => projectBlock(k.id))
-                : [projectBlock(root)];
-        },
-        roles: (next) => {
-            ix.roles = next;
-            ix.placementFull = true;
-            ix.version++;
-            // No commit carries a role change: report it now (not inside a
-            // transaction, whose commit reports it), so every view follows.
-            if (hasSubscribers() && !openTx())
-                publish(null, false);
-        },
-        track: () => {
-            syncAll();
-            const f = { touched: new Map(), wrote: false };
-            frames.add(f);
-            return {
-                end: () => {
-                    syncAll();
-                    frames.delete(f);
-                    return f;
-                },
-                quiet: (write) => {
-                    syncAll();
-                    const g = { touched: new Map(), wrote: false };
-                    frames.delete(f);
-                    frames.add(g);
-                    try {
-                        write();
-                        syncAll();
-                    }
-                    finally {
-                        frames.delete(g);
-                        frames.add(f);
-                        f.wrote ||= g.wrote;
-                    }
-                }
-            };
-        },
-        onReport,
-        debug
-    };
-    return view;
-};

package/dist/crdt/vendor/yjs/UPSTREAM.md

@@ -1515,6 +1515,89 @@ Oracle: `src/tests/crdt/attribution/first-write-binding.test.ts` (the first
 local edit's one update carries the binding; a remote update writes none),
 the upstream suite.
 
+### YP31 — a hold record inside a nested node holds nothing (`src/structs/Item.js`)
+
+Reason: edytor's shared suggestions keep, inside each suggestion's record
+node, the id ranges it proposes to delete and the ranges its reviewers
+settled: lists of `client, clock, len` ranges that must hide nothing until a
+reviewer accepts. YP20's hold record is exactly that codec (one unit per
+range, a left id and a length, consecutive records of one writer merging
+as typed runs do), but it holds whatever it names wherever it integrates.
+The study's prototype added a sibling content type that held nothing
+(content ref 14, `ContentPropose`, a `YNode#propose` writer, about 0.3 KB);
+the rule here keeps one record type and one reader. Design:
+`docs/archive/shared-suggestions/design.md`. Edytor's schema generation 11
+is the cutover (no conversion: a generation-10 replica would hold what a
+proposal names).
+
+Patch (new code delimited by `// YP31 begin` / `// YP31 end`, edits marked `// YP31`):
+
+- **`holding(item)`**: a hold record holds what it names iff its item is an
+  entry of a root's sequence (`item.parent._item === null`: the document's
+  records list, `textdel`). `ContentHold#integrate` and `ContentHold#delete`
+  hold and release only then; inside a nested node's sequence the record is
+  a list of ids: it moves no length, waits in no `pendingHolds`, logs
+  nothing in `transaction.holds`, and its delete (an undo, a reviewer's
+  withdrawal, its node's delete) releases nothing. `YNode#hold(ids)` on a
+  nested node appends one such list entry.
+
+Plain deletes and the root records list (every upstream test, every YP20
+row) are untouched: no other code path writes a hold record into a nested
+node.
+
+Edytor side: a suggestion's record node (root `suggest`) keeps its writer's
+proposed deletions and its reviewers' settled ranges as such entries
+(`crdt/doc/suggest.ts`); accepting a deletion writes a real hold record in
+the root list.
+
+Oracle: `src/tests/crdt/yp31-id-lists.test.ts` (written, deleted, merged,
+split, synced, reloaded, received before the items it names, deleted with
+its node: nothing hidden or released; the root list still holds), the YP20
+rows and the shared-suggestion rows, the upstream suite unchanged
+(`encoding.tests.js` still pins 14 content refs).
+
+### YP32 — a delete that proposes (`src/ynode.js`, `src/structs/Item.js`, `src/index.js`)
+
+Reason: in suggesting mode a text delete writes nothing to the text: the
+units that are not the suggestion's author's own pending ones are named by
+an id list in the suggestion's record (YP31), and they stay shown. The
+plan that deleted them was prepared with them gone, so edytor carried a
+layer that re-read each later step's offsets over the units the plan had
+proposed, batched the steps around every proposal and mapped the caret
+back (`crdt/doc/suggest.ts` `apply`, about 1.4 KB minified). The fork's
+delete now proposes, and hides what it proposed until the plan ends: the
+plan's later steps read the offsets they were prepared with, and an
+insertion at a proposed deletion lands after it (at the end of the gap,
+as any insertion lands after deleted items). Design:
+`docs/archive/suggestions-in-engine/design.md`.
+
+Patch (new code delimited by `// YP32 begin` / `// YP32 end`, edits marked `// YP32`):
+
+- **`YNode#delete(index, length, into, fresh, propose)`**: with `propose`
+  (`{ into, sort }`), each live unit the delete reaches is sorted by
+  `sort(client, clock)`: `1` held by the record appended to `into` (the
+  author's own pending text, YP20's path), `2` proposed (one id list
+  appended to `propose.into`, the suggestion's record, which holds nothing
+  there, YP31), `3` stepped over (already proposed). `fresh` units are
+  removed as before. Proposed and stepped-over units are hidden
+  (`hideIds`: a hold without a record, kept in `transaction.hidden`) until
+  `unhide(transaction)`, which edytor calls when the plan is written.
+  `deleteText` splits a run where the sort changes.
+- **`hideIds`, `unhide`** (`Item.js`, `unhide` exported): YP20's
+  `holdIds` with no record, and its release.
+
+Plain deletes (every upstream test, every YP20 row) are untouched: without
+`propose` the sort is not read and every changed path reduces to YP20's.
+
+Edytor side: `crdt/text/model.ts` `deleteRange` passes the plan's
+`proposing` context; `crdt/doc/suggest.ts` writes a suggesting plan as one
+frame, its caret anchored before `unhide` and resolved after.
+
+Oracle: the shared-suggestion rows (`src/tests/crdt/suggest/`, the random
+schedules with the index's self-checks on), `suggesting-input.test.tsx`
+(typing over a selection, a paste, Backspace and Delete over struck text),
+the YP20 rows, the upstream suite unchanged.
+
 ## Generated declarations (`dts/`)
 
 `svelte-package` copies JS verbatim but emits no `.d.ts` for JS inputs, so

package/dist/crdt/vendor/yjs/dts/index.d.ts

@@ -17,4 +17,4 @@ export { idAtIndex, indexOfId } from "./utils/positions.js";
 export { findIndexSS, getItemCleanStart, getItemCleanEnd, isKeptReplaced } from "./utils/transaction-helpers.js";
 export { Transaction, transact } from "./utils/Transaction.js";
 export { redoItem, keepItem } from "./utils/redo.js";
-export { Item, followRedone, ContentBinary, ContentDeleted, ContentFormat, ContentAny, ContentString, ContentType, ContentMove } from "./structs/Item.js";
+export { Item, followRedone, ContentBinary, ContentDeleted, ContentFormat, ContentAny, ContentString, ContentType, ContentMove, unhide } from "./structs/Item.js";

package/dist/crdt/vendor/yjs/dts/structs/Item.d.ts

@@ -427,13 +427,14 @@ export class ContentHold {
     mergeWith(right: ContentHold): boolean;
     /**
      * @param {Transaction} transaction
-     * @param {Item} _item
+     * @param {Item} item
      */
-    integrate(transaction: Transaction, _item: Item): void;
+    integrate(transaction: Transaction, item: Item): void;
     /**
      * @param {Transaction} transaction
+     * @param {Item} item
      */
-    delete(transaction: Transaction): void;
+    delete(transaction: Transaction, item: Item): void;
     /**
      * @param {Transaction} _tr
      */
@@ -449,6 +450,8 @@ export class ContentHold {
      */
     getRef(): 11;
 }
+export function hideIds(tr: Transaction, ids: Array<number>): void;
+export function unhide(tr: Transaction): void;
 export function applyPending(tr: Transaction, clients: Array<number>): void;
 /**
  * A move record: one countable unit at its destination, naming the units

package/dist/crdt/vendor/yjs/dts/ynode.d.ts

@@ -25,7 +25,7 @@ export class ItemTextListPosition {
     advance(transaction: Transaction, length: number): void;
 }
 export function insertAtGapEndHelper(transaction: Transaction, parent: YNode, index: number, content: import("./structs/Item.js").AbstractContent): void;
-export function deleteText(transaction: Transaction, currPos: ItemTextListPosition, length: number, held?: Array<number> | null, fresh?: import("./utils/ids.js").IdSet | null): ItemTextListPosition;
+export function deleteText(transaction: Transaction, currPos: ItemTextListPosition, length: number, held?: Array<number> | null, fresh?: import("./utils/ids.js").IdSet | null, sort?: ((client: number, clock: number) => number) | null, proposed?: Array<number> | null, hidden?: Array<number> | null): ItemTextListPosition;
 export class ArraySearchMarker {
     /**
      * @param {Item} p
@@ -193,12 +193,23 @@ export class YNode {
      * which an undo of the record takes back), except those `fresh` names (the
      * open undo step's inserts: removed, so that step's undo changes nothing).
      *
+     * YP32: with `propose` (a suggestion's delete) each unit is sorted: held
+     * by the record in `into` (`1`: its author's own), proposed (`2`: an id
+     * list appended to `propose.into`, a suggestion's record, holding nothing)
+     * or stepped over (`3`: already proposed); proposed and stepped-over units
+     * read gone until `unhide`, so the rest of the plan reads the offsets it
+     * was prepared with.
+     *
      * @param {number} index Index at which to start deleting elements
      * @param {number} length The number of elements to remove. Defaults to 1.
      * @param {YNode|null} [into]
      * @param {import('./utils/ids.js').IdSet|null} [fresh]
+     * @param {{ into: YNode, sort: (client: number, clock: number) => number }|null} [propose]
      */
-    delete(index: number, length?: number, into?: YNode | null, fresh?: import("./utils/ids.js").IdSet | null): void;
+    delete(index: number, length?: number, into?: YNode | null, fresh?: import("./utils/ids.js").IdSet | null, propose?: {
+        into: YNode;
+        sort: (client: number, clock: number) => number;
+    } | null): void;
     /**
      * YP20: append to this node (the document's records list) one hold record of
      * the items `ids` names (`client, clock, len` triples): they read as deleted

package/dist/crdt/vendor/yjs/src/index.js

@@ -19,7 +19,7 @@ export { RangeCursor } from './utils/RangeCursor.js'
 export { YNode as Node } from './ynode.js'
 export { AbstractStruct } from './structs/AbstractStruct.js'
 export { GC } from './structs/GC.js'
-export { Item, followRedone, ContentBinary, ContentDeleted, ContentFormat, ContentAny, ContentString, ContentType, ContentMove } from './structs/Item.js' // YP22: ContentMove
+export { Item, followRedone, ContentBinary, ContentDeleted, ContentFormat, ContentAny, ContentString, ContentType, ContentMove, unhide } from './structs/Item.js' // YP22: ContentMove; YP32: unhide
 export { Skip } from './structs/Skip.js'
 
 /**

package/dist/crdt/vendor/yjs/src/structs/Item.js

@@ -1134,17 +1134,18 @@ export class ContentHold {
 
   /**
    * @param {Transaction} transaction
-   * @param {Item} _item
+   * @param {Item} item
    */
-  integrate (transaction, _item) {
-    holdIds(transaction, this.ids, 1)
+  integrate (transaction, item) {
+    if (holding(item)) holdIds(transaction, this.ids, 1) // YP31
   }
 
   /**
    * @param {Transaction} transaction
+   * @param {Item} item
    */
-  delete (transaction) {
-    holdIds(transaction, this.ids, -1)
+  delete (transaction, item) {
+    if (holding(item)) holdIds(transaction, this.ids, -1) // YP31
   }
 
   /**
@@ -1170,6 +1171,44 @@ export class ContentHold {
 }
 // YP20 end
 
+// YP31 begin (edytor fork: id lists — see UPSTREAM.md YP31)
+/**
+ * Whether the hold record `item` holds what it names: one in a root's
+ * sequence does (the document's records list, YP20); one in a nested node's
+ * sequence is a list of ids, the same codec, that holds nothing.
+ *
+ * @param {Item} item
+ * @return {boolean}
+ */
+const holding = item => /** @type {YNode} */ (item.parent)._item === null
+// YP31 end
+
+// YP32 begin (edytor fork: a delete that proposes — see UPSTREAM.md YP32)
+/**
+ * Hide the units `ids` names until `unhide` (a suggestion's proposed
+ * deletion, which the rest of its plan reads gone): a hold without a
+ * record, kept in `tr.hidden`.
+ *
+ * @param {Transaction} tr
+ * @param {Array<number>} ids
+ */
+export const hideIds = (tr, ids) => {
+  holdIds(tr, ids, 1)
+  ;/** @type {any} */ (tr).hidden = (/** @type {any} */ (tr).hidden ?? []).concat(ids)
+}
+
+/**
+ * Show again what `hideIds` hid in `tr`.
+ *
+ * @param {Transaction} tr
+ */
+export const unhide = tr => {
+  const hidden = /** @type {any} */ (tr).hidden
+  if (hidden) holdIds(tr, hidden, -1)
+  ;/** @type {any} */ (tr).hidden = null
+}
+// YP32 end
+
 // YP22 begin (edytor fork: move records — see UPSTREAM.md YP22)
 /**
  * Whether move record `a` beats `b`: the greater `(priority, client, clock)`