edytor 3.0.0 → 4.0.0

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

@@ -1,9 +1,10 @@
 /**
  * The maintained form of one backing text's boundary table — the
- * index's row: the text's live boundary items in text order and the live
- * units between them, held in a Fenwick tree so an edit that writes or
+ * index's row: the text's live boundary and claim items in text order and
+ * the live units between them, held in a Fenwick tree so an edit that writes or
  * removes no boundary moves every later boundary in O(log B) instead of a
- * rescan.
+ * rescan. (A claim item is a bound like a boundary that never delimits: below,
+ * "boundary" names both.)
  *
  * `h[j]` is the units before boundary `j` since the one before it, plus
  * boundary `j` itself (`h[B]`: the units after the last boundary), so the
@@ -21,11 +22,11 @@
  * segment `k > 0` is the stream of the block its opening cut names.
  */
 import type { EngineNode } from '../engine-api.js';
-import { type BlockId, type Bound, type Stream, type TextRow } from './model.js';
+import { type BlockId, type Bound, type Claim, type Stream, type TextRow } from './model.js';
 export type LiveRow = {
     home: BlockId;
     text: EngineNode;
-    /** The live boundaries in text order (`at` is NOT maintained: read {@link boundAt}). */
+    /** The live boundaries and claim items in text order (`at` is NOT maintained: read {@link boundAt}). */
     bounds: readonly Bound[];
     /** Fenwick tree over `h` (1-based, size `bounds.length + 1`). */
     tree: Float64Array;
@@ -35,6 +36,8 @@ export type LiveRow = {
     keyIndex: Map<string, number>;
     /** Indexes into `bounds` of the delimiting boundaries, ascending ({@link placeRow}). */
     cuts: number[];
+    /** The block each cut opens the stream of (`null`: a removed block's, nobody's). */
+    heads: (BlockId | null)[];
     /** The block of segment 0 (`null`: the home is delimited elsewhere). */
     head: BlockId | null;
 };
@@ -82,11 +85,14 @@ export declare const segmentAt: (row: LiveRow, x: number) => number;
 export declare const segmentOfCut: (row: LiveRow, cut: string | null) => number;
 /** The block of segment `k` (`null`: nobody's). */
 export declare const headOf: (row: LiveRow, k: number) => BlockId | null;
+/** The claims of segment `k`: its claim items, in text order. */
+export declare const segmentClaims: (row: LiveRow, k: number) => Claim[];
 /** Segment `k` as a {@link Stream} of `block`. */
 export declare const streamOfSegment: (row: LiveRow, k: number, block: BlockId) => Stream;
 /**
  * Set the row's segments from the delimiting boundaries (`delim`): the
  * home's head (unless delimited elsewhere), then one per cut — the same
- * streams `placeText` returns for the row's scan.
+ * streams `placeText` returns for the row's scan (a cut of a block `nobody`
+ * names opens nobody's stretch).
  */
-export declare const placeRow: (row: LiveRow, delim: ReadonlyMap<BlockId, string>) => void;
+export declare const placeRow: (row: LiveRow, delim: ReadonlyMap<BlockId, string>, nobody: (s: BlockId) => boolean) => void;

package/dist/crdt/text/rows.js

@@ -1,4 +1,4 @@
-import { isBoundary } from './model.js';
+import { isRowMark } from './model.js';
 const add = (row, i, d) => {
     const t = row.tree;
     for (let x = i + 1; x < t.length; x += x & -x)
@@ -61,6 +61,7 @@ export const rowOf = (scan) => {
         key: scan.key,
         keyIndex,
         cuts: [],
+        heads: [],
         head: scan.home
     };
 };
@@ -76,7 +77,7 @@ const boundIn = (row, it, first) => {
         return -1;
     for (let n = 0; n < it.length; n++) {
         const k = first ? n : it.length - 1 - n;
-        if (!isBoundary(arr[k]))
+        if (!isRowMark(arr[k]))
             continue;
         return row.keyIndex.get(`${it.id.client}:${it.id.clock + k}`) ?? -2;
     }
@@ -153,7 +154,18 @@ export const segmentOfCut = (row, cut) => {
     return row.cuts[k] === j ? k + 1 : -1;
 };
 /** The block of segment `k` (`null`: nobody's). */
-export const headOf = (row, k) => k === 0 ? row.head : row.bounds[row.cuts[k - 1]].s;
+export const headOf = (row, k) => k === 0 ? row.head : row.heads[k - 1];
+/** The claims of segment `k`: its claim items, in text order. */
+export const segmentClaims = (row, k) => {
+    const out = [];
+    const hi = k < row.cuts.length ? row.cuts[k] : row.bounds.length;
+    for (let j = k === 0 ? 0 : row.cuts[k - 1] + 1; j < hi; j++) {
+        const b = row.bounds[j];
+        if (b.m !== undefined)
+            out.push({ m: b.m, stamp: b.stamp });
+    }
+    return out;
+};
 /** Segment `k` as a {@link Stream} of `block`. */
 export const streamOfSegment = (row, k, block) => {
     const lo = k === 0 ? -1 : row.cuts[k - 1];
@@ -168,15 +180,20 @@ export const streamOfSegment = (row, k, block) => {
 /**
  * Set the row's segments from the delimiting boundaries (`delim`): the
  * home's head (unless delimited elsewhere), then one per cut — the same
- * streams `placeText` returns for the row's scan.
+ * streams `placeText` returns for the row's scan (a cut of a block `nobody`
+ * names opens nobody's stretch).
  */
-export const placeRow = (row, delim) => {
+export const placeRow = (row, delim, nobody) => {
     const cuts = [];
+    const heads = [];
     for (let j = 0; j < row.bounds.length; j++) {
         const b = row.bounds[j];
-        if (delim.get(b.s) === b.key)
-            cuts.push(j);
+        if (b.m !== undefined || delim.get(b.s) !== b.key)
+            continue;
+        cuts.push(j);
+        heads.push(nobody(b.s) ? null : b.s);
     }
     row.cuts = cuts;
+    row.heads = heads;
     row.head = delim.has(row.home) ? null : row.home;
 };

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

@@ -18,9 +18,9 @@
  * The fold (see `docs/crdt-v14-richtext-adr.md` for the run contract):
  *
  * - One classifier maps a changed `(type, parentSub)` pair to the block and
- *   the facet it entered through (`content`, `claims`, `at`, `n`, a delete
- *   mark, `type`/`data`, or the registry entry itself); one routine folds a
- *   set of such pairs into the indexes.
+ *   the facet it entered through (`content`, `at`, `n`, a delete mark,
+ *   `type`/`data`, or the registry entry itself); one routine folds a set of
+ *   such pairs into the indexes.
  * - A transaction is folded ONCE at commit, from `transaction.changed`.
  * - A read first folds the PENDING part of every transaction whose writes
  *   are in the document and whose commit fold has not run: the open one, and
@@ -29,12 +29,12 @@
  *   fold (the watermark is those sets' lengths). The commit fold takes only
  *   what no read folded.
  * - Each backing text has a maintained row (`text/rows.ts`): its
- *   boundaries and the live units between them. An edit that writes or
- *   removes no boundary moves the row by its units in the gap it lies in
- *   (found by walking the item list to the nearest boundary), never a
- *   rescan; a boundary written or removed rescans that text, re-decides the
- *   delimiters of the blocks its boundaries name, and re-places only the
- *   rows those cut. Every cached block records which texts its display
+ *   boundaries and claim items and the live units between them. An edit
+ *   that writes or removes neither moves the row by its units in the gap it
+ *   lies in (found by walking the item list to the nearest boundary), never a
+ *   rescan; a boundary or claim item written or removed rescans that text,
+ *   re-decides the delimiters of the blocks its boundaries name, re-places
+ *   only the rows those cut, and re-reads the claims of their blocks. Every cached block records which texts its display
  *   walked and which blocks it walked or read a claim on (a skipped claim
  *   included); an edit invalidates the display owner of the stream it lies
  *   in, a placement the blocks whose stream's delimiting boundaries changed
@@ -55,8 +55,8 @@
  *
  * 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 (`streams.ts`), anchored merge claims
- * (`anchored.ts`), the layout rules (`layout.ts`), placements and the
+ * (`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
@@ -64,7 +64,7 @@
  */
 import type { EngineApi, EngineDoc } from '../engine-api.js';
 import type { BlockId, ContentItem, ModelView, ProjectedBlock } from '../placement/model.js';
-export { CONTENT_ATTR, ENTRY_FACET, indexChecks } from './index/shared.js';
+export { CONTENT_ATTR, ENTRY_FACET, SEQ_FACET, indexChecks } from './index/shared.js';
 /**
  * One visible run of a block — the maintained form of `ContentItem`.
  * `marks`/`data` are interned: equal payloads share one frozen instance,
@@ -139,6 +139,8 @@ export type RunViewDebug = {
      * last `reset()`: each struct once, whatever the number of reads.
      */
     readonly foldedStructs: number;
+    /** Blocks whose placement the index decided since last `reset()` (a global pass decides every one). */
+    readonly placements: number;
     reset: () => void;
 };
 /**
@@ -201,9 +203,12 @@ export type RunView = {
      * Track the folds from now on (the write funnel's frame): `end()` folds
      * what is pending and returns the facets every fold since `track()` saw
      * per block, and whether the transaction wrote anything meanwhile.
+     * `quiet(write)` runs a write whose facets are not the frame's (it counts
+     * as written).
      */
     track: () => {
         end: () => Folded;
+        quiet: (write: () => void) => void;
     };
     /**
      * Subscribe to the change report — one per commit that changed the

package/dist/crdt/text/runs.js

@@ -3,14 +3,13 @@ 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 { indexAnchored } from './index/anchored.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';
-export { CONTENT_ATTR, ENTRY_FACET, indexChecks } from './index/shared.js';
+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. */
@@ -27,14 +26,13 @@ const buildView = (doc) => {
     const ix0 = indexState(doc);
     const ix1 = Object.assign(ix0, indexClaims(ix0));
     const ix2 = Object.assign(ix1, indexStreams(ix1));
-    const ix3 = Object.assign(ix2, indexAnchored(ix2));
-    const ix4 = Object.assign(ix3, indexLayout(ix3));
+    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, applyRetargets, updateBlockRec, syncIncarnations, intern, debug, runs, settle, syncPending, syncAll, openTx, onCommit, committed, itemsOf, projectBlock, publish, onUpdate, onReport, hasSubscribers } = ix;
+    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,
@@ -53,7 +51,11 @@ const buildView = (doc) => {
         // The publication boundary shares THIS interner, so a payload
         // emitted by `project()`/`contentItems()` is `===` the runs' one.
         intern,
-        displays
+        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) => {
@@ -69,7 +71,7 @@ const buildView = (doc) => {
         }
     });
     rebuildTable(new Set());
-    applyRetargets(null);
+    applyReclaims(null);
     settle(shells, null);
     // Every commit folds once, before the document's `afterTransaction` listeners.
     doc.on('commit', onCommit);
@@ -141,6 +143,21 @@ const buildView = (doc) => {
                     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;
+                    }
                 }
             };
         },

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

@@ -1,27 +1,40 @@
 /**
- * The stream table, pure: a backing text's boundaries, each block's
- * delimiting boundary, a text's streams, and a block's display as pieces
- * of streams (its stream, then each effective claim's display).
+ * The stream table, pure: a backing text's boundaries and claim items, each
+ * block's delimiting boundary, a text's streams, and a block's display as
+ * pieces of streams (its stream, then each claim's display).
  */
 import type { EngineNode } from '../engine-api.js';
-import type { BlockId, Ownership, Seg, Stream, TextBlockRec, TextRow } from './model.js';
-/** Scan `text` (live space) for its boundary items. */
+import type { BlockId, Claim, Ownership, Seg, Stream, TextBlockRec, TextRow } from './model.js';
+/** Scan `text` (live space) for its boundary and claim items. */
 export declare const scanText: (home: BlockId, text: EngineNode) => TextRow;
 export declare const byId: (a: string, b: string) => number;
-/** Each block's delimiting boundary: the lowest-id live boundary whose nonce matches its record. */
-export declare const delimiters: (blocks: ReadonlyMap<BlockId, Pick<TextBlockRec, "n">>, rows: Iterable<TextRow>) => Map<BlockId, string>;
+/**
+ * Whether `s` names a removed block of `registry` (`room.purge.what`): its
+ * entry was deleted — only the purge deletes one — and holds no value. The
+ * purge removes a block that streams in another block's text alone, and its
+ * boundary keeps delimiting the stream it emptied, which nobody shows.
+ */
+export declare const removedKeys: (registry: EngineNode) => (s: BlockId) => boolean;
+/**
+ * Each block's delimiting boundary: the lowest-id live boundary whose nonce
+ * matches its record; for a removed block (`removed`, no record), the
+ * lowest-id live boundary naming it.
+ */
+export declare const delimiters: (blocks: ReadonlyMap<BlockId, Pick<TextBlockRec, "n">>, rows: Iterable<TextRow>, removed?: (s: BlockId) => boolean) => Map<BlockId, string>;
 /**
  * The streams of one text, in text order: the home's head (unless delimited
  * elsewhere), then one per delimiting boundary — one sweep over the
- * boundaries (each non-delimiting one is an inert boundary of the stream it
- * sits in).
+ * boundaries (each non-delimiting one, and each claim item, is an inert unit
+ * of the stream it sits in). A boundary of a block `nobody` names (a
+ * removed one) opens a stretch that is no block's stream.
  */
-export declare const placeText: (row: TextRow, delim: ReadonlyMap<BlockId, string>) => Stream[];
-/** A stream's content pieces: the range minus its inert boundaries (at least one piece). */
+export declare const placeText: (row: TextRow, delim: ReadonlyMap<BlockId, string>, nobody?: (s: BlockId) => boolean) => Stream[];
+/** The claims of stream `s` of `row`: its claim items, in text order. */
+export declare const claimsIn: (row: TextRow, s: Stream) => Claim[];
+/** A stream's content pieces: the range minus its inert units (at least one piece). */
 export declare const pieces: (s: Stream) => [number, number][];
 /**
- * `display(b)`: `b`'s stream, then each effective claim's display, in claim
- * order. `track(x, home)` reports every walked block and the home of its
+ * `display(b)`: `b`'s stream, then each claim's display, in claim order. `track(x, home)` reports every walked block and the home of its
  * stream (the index's dependency capture). `null` when `b` is hidden, unless
  * `hidden` asks for the pieces a hidden block would show (an anchor minted in
  * a merged-away or deleted block binds its items all the same).

package/dist/crdt/text/streams.js

@@ -1,5 +1,7 @@
-import { isBoundary, nodeStart } from './items.js';
-/** Scan `text` (live space) for its boundary items. */
+import { isIncarnationId } from '../incarnations.js';
+import { attrItems } from '../structs.js';
+import { isBoundary, isClaimItem, nodeStart } from './items.js';
+/** Scan `text` (live space) for its boundary and claim items. */
 export const scanText = (home, text) => {
     const bounds = [];
     let at = 0;
@@ -10,8 +12,11 @@ export const scanText = (home, text) => {
         if (arr !== undefined) {
             for (let j = 0; j < it.length; j++) {
                 const v = arr[j];
+                const [c, k] = [it.id.client, it.id.clock + j];
                 if (isBoundary(v))
-                    bounds.push({ s: v.s, n: v.n, at: at + j, key: `${it.id.client}:${it.id.clock + j}` });
+                    bounds.push({ s: v.s, n: v.n, at: at + j, key: `${c}:${k}` });
+                else if (isClaimItem(v))
+                    bounds.push({ m: v.m, stamp: { c, k }, at: at + j, key: `${c}:${k}` });
             }
         }
         at += it.length;
@@ -23,12 +28,26 @@ export const byId = (a, b) => {
     const [bc, bk] = b.split(':').map(Number);
     return ac - bc || ak - bk;
 };
-/** Each block's delimiting boundary: the lowest-id live boundary whose nonce matches its record. */
-export const delimiters = (blocks, rows) => {
+/**
+ * Whether `s` names a removed block of `registry` (`room.purge.what`): its
+ * entry was deleted — only the purge deletes one — and holds no value. The
+ * purge removes a block that streams in another block's text alone, and its
+ * boundary keeps delimiting the stream it emptied, which nobody shows.
+ */
+export const removedKeys = (registry) => (s) => attrItems(registry).get(s)?.deleted === true && !isIncarnationId(s);
+/**
+ * Each block's delimiting boundary: the lowest-id live boundary whose nonce
+ * matches its record; for a removed block (`removed`, no record), the
+ * lowest-id live boundary naming it.
+ */
+export const delimiters = (blocks, rows, removed = () => false) => {
     const out = new Map();
     for (const row of rows) {
         for (const b of row.bounds) {
-            if (blocks.get(b.s)?.n !== b.n)
+            if (b.m !== undefined)
+                continue;
+            const rec = blocks.get(b.s);
+            if (rec === undefined ? !removed(b.s) : rec.n !== b.n)
                 continue;
             const cur = out.get(b.s);
             if (cur === undefined || byId(b.key, cur) < 0)
@@ -40,10 +59,11 @@ export const delimiters = (blocks, rows) => {
 /**
  * The streams of one text, in text order: the home's head (unless delimited
  * elsewhere), then one per delimiting boundary — one sweep over the
- * boundaries (each non-delimiting one is an inert boundary of the stream it
- * sits in).
+ * boundaries (each non-delimiting one, and each claim item, is an inert unit
+ * of the stream it sits in). A boundary of a block `nobody` names (a
+ * removed one) opens a stretch that is no block's stream.
  */
-export const placeText = (row, delim) => {
+export const placeText = (row, delim, nobody = () => false) => {
     const out = [];
     let block = delim.has(row.home) ? null : row.home;
     let start = 0;
@@ -53,17 +73,25 @@ export const placeText = (row, delim) => {
             out.push({ block, home: row.home, text: row.text, start, end, inert });
     };
     for (const b of row.bounds) {
-        if (delim.get(b.s) !== b.key) {
+        if (b.m !== undefined || delim.get(b.s) !== b.key) {
             inert.push(b.at);
             continue;
         }
         close(b.at);
-        [block, start, inert] = [b.s, b.at + 1, []];
+        [block, start, inert] = [nobody(b.s) ? null : b.s, b.at + 1, []];
     }
     close(row.len);
     return out;
 };
-/** A stream's content pieces: the range minus its inert boundaries (at least one piece). */
+/** The claims of stream `s` of `row`: its claim items, in text order. */
+export const claimsIn = (row, s) => {
+    const out = [];
+    for (const b of row.bounds)
+        if (b.m !== undefined && b.at >= s.start && b.at < s.end)
+            out.push({ m: b.m, stamp: b.stamp });
+    return out;
+};
+/** A stream's content pieces: the range minus its inert units (at least one piece). */
 export const pieces = (s) => {
     const out = [];
     let a = s.start;
@@ -75,8 +103,7 @@ export const pieces = (s) => {
     return out;
 };
 /**
- * `display(b)`: `b`'s stream, then each effective claim's display, in claim
- * order. `track(x, home)` reports every walked block and the home of its
+ * `display(b)`: `b`'s stream, then each claim's display, in claim order. `track(x, home)` reports every walked block and the home of its
  * stream (the index's dependency capture). `null` when `b` is hidden, unless
  * `hidden` asks for the pieces a hidden block would show (an anchor minted in
  * a merged-away or deleted block binds its items all the same).