edytor 5.0.0 → 7.0.0

package/dist/crdt/restore.d.ts

@@ -35,6 +35,8 @@ export type Unit = {
 };
 /** `items` one unit each (a character with its marks, or an atom), keyed for comparison. */
 export declare const unitsOf: (items: readonly ContentItem[]) => Unit[];
+/** Units back to runs: consecutive characters with the same marks joined. */
+export declare const runsOf: (units: readonly Unit[]) => ContentItem[];
 /** The one changed stretch from `x` to `y`: `x[p, e)` became `mid`. */
 export declare const hunk: (x: readonly Unit[], y: readonly Unit[]) => {
     p: number;
@@ -76,9 +78,19 @@ export type RestoreFacade<Plan> = Partial<SuggestFacade> & {
         patchData(target: null, ops: DataPatch[]): Plan;
     };
 };
+/** How a restore writes content, and whether it rejects the pending suggestions. */
+export type RestoreOptions<Plan> = {
+    /**
+     * The content rewrite of a block that differs (default `rewriteContent`).
+     * Another one edits through the display, so the block keeps its claims.
+     */
+    rewrite?: (facade: RestoreFacade<Plan>, id: BlockId, have: readonly Unit[], want: readonly Unit[]) => boolean;
+    /** `keep`: the pending suggestions stay (a re-seed's rebase writes as one more writer). */
+    suggestions?: 'reject' | 'keep';
+};
 /**
  * Make the visible document `doc` (through `facade`, the facade over it)
  * equal `json`. Runs inside the caller's transaction; the writer is
  * `doc.clientID`. See the module comment for what it writes.
  */
-export declare const restoreDocument: <Plan>(doc: EngineDoc, facade: RestoreFacade<Plan>, json: JSONDoc) => RestoreReport;
+export declare const restoreDocument: <Plan>(doc: EngineDoc, facade: RestoreFacade<Plan>, json: JSONDoc, { rewrite, suggestions }?: RestoreOptions<Plan>) => RestoreReport;

package/dist/crdt/restore.js

@@ -24,7 +24,7 @@ export const unitsOf = (items) => {
     return out;
 };
 /** Units back to runs: consecutive characters with the same marks joined. */
-const runsOf = (units) => {
+export const runsOf = (units) => {
     const out = [];
     let tag = null;
     for (const { key, item } of units) {
@@ -98,7 +98,7 @@ const walk = (specs, parent, into) => {
  * equal `json`. Runs inside the caller's transaction; the writer is
  * `doc.clientID`. See the module comment for what it writes.
  */
-export const restoreDocument = (doc, facade, json) => {
+export const restoreDocument = (doc, facade, json, { rewrite, suggestions = 'reject' } = {}) => {
     const report = { revived: 0, moved: 0, rewritten: 0, created: 0, deleted: 0 };
     const specs = json.children.map((block) => toBlockSpec(block));
     const all = walk(specs, null, new Map());
@@ -170,6 +170,11 @@ export const restoreDocument = (doc, facade, json) => {
         if (have.length === want.length && have.every((u, i) => u.key === want[i].key))
             continue;
         const claims = modelView(doc).blocks.get(id)?.claims ?? [];
+        if (rewrite) {
+            rewrite(facade, id, have, want);
+            report.rewritten++;
+            continue;
+        }
         if (claims.some((c) => c.stamp.c >= 0)) {
             deleteClaims(doc, claims);
             have = unitsOf(facade.contentItems(id));
@@ -202,7 +207,7 @@ export const restoreDocument = (doc, facade, json) => {
     // their proposals — is rejected, in the restore's step (its undo brings
     // them back).
     // (Built over the facade, its shared suggestions: `doc/suggest.ts`.)
-    const suggest = facade.part && suggestionsOf(facade);
+    const suggest = suggestions === 'reject' && facade.part && suggestionsOf(facade);
     if (suggest)
         suggest.run(suggest.decide(suggest.changes(), false));
     return report;

package/dist/crdt/schema.d.ts

@@ -98,6 +98,12 @@ export declare const hasWithdrawMark: (node: {
 /** The per-block `lastChangedBy` LWW attr (`SCHEMA.blockAttrs.lastChanged`). */
 export declare const LAST_CHANGED_ATTR = "l";
 export declare const CONTENT = "content";
+/**
+ * The epoch a re-seed wrote (`room.reseed.protocol`): the root `epoch`, its
+ * attr `n` (none before the first re-seed). Apart from `meta`, whose keys
+ * are the schema stamp's alone.
+ */
+export declare const EPOCH_ROOT = "epoch";
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export declare const SCHEMA: {
     readonly version: 11;

package/dist/crdt/schema.js

@@ -87,6 +87,12 @@ export const hasWithdrawMark = (node) => [...node.attrKeys()].some((key) => key.
 /** The per-block `lastChangedBy` LWW attr (`SCHEMA.blockAttrs.lastChanged`). */
 export const LAST_CHANGED_ATTR = 'l';
 export const CONTENT = 'content';
+/**
+ * The epoch a re-seed wrote (`room.reseed.protocol`): the root `epoch`, its
+ * attr `n` (none before the first re-seed). Apart from `meta`, whose keys
+ * are the schema stamp's alone.
+ */
+export const EPOCH_ROOT = 'epoch';
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export const SCHEMA = {
     // 7: a text delete is a hold record (fork patch YP20) on the wire and in

package/dist/crdt/structs.d.ts

@@ -64,17 +64,14 @@ export declare const clientsOf: (doc: EngineDoc) => Map<number, StoreStruct[]>;
  */
 export declare const structAt: (Y: EngineApi, structs: readonly StoreStruct[], clock: number) => StoreStruct | null;
 /**
- * Walk every struct an IdSet covers, in (client, clock) order: `fn(struct,
- * from, to)` gets the struct and the clock range `[from, to)` of it the set
- * covers (a struct can reach past a range a diff of two id sets cut). The
- * walk never splits a struct; `fn` returning `false` halts it.
- *
- * Returns `false` when coverage was INCOMPLETE — a client's struct list
- * was missing or a range start could not be located — so the caller can
- * fall back to an all-consumers/opaque answer instead of trusting a
- * partial walk. `clientsOf` throws first when the store itself is absent.
- */
-export declare const walkIdSet: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct, from: number, to: number) => boolean | void) => boolean;
+ * Walk every struct the range `client:clock`, `len` units, covers, in clock
+ * order: `fn(struct, from, to)` gets the struct and the clock range `[from,
+ * to)` of it the range covers (a struct can reach past it). The walk never
+ * splits a struct; a client or a clock the store lacks walks nothing.
+ */
+export declare const walkRange: (Y: EngineApi, doc: EngineDoc, client: number, clock: number, len: number, fn: (struct: StoreStruct, from: number, to: number) => void) => void;
+/** Walk every struct an IdSet covers, in (client, clock) order (`walkRange` over each range). */
+export declare const walkIdSet: (Y: EngineApi, doc: EngineDoc, idSet: IdSetLike, fn: (struct: StoreStruct, from: number, to: number) => void) => void;
 /**
  * The id the local `redone` chain leads `id` to: the copy an undo or redo
  * on THIS replica re-created of a deleted item (redo copies chain), or `id`

package/dist/crdt/structs.js

@@ -50,51 +50,32 @@ export const structAt = (Y, structs, clock) => {
     }
 };
 /**
- * Walk every struct an IdSet covers, in (client, clock) order: `fn(struct,
- * from, to)` gets the struct and the clock range `[from, to)` of it the set
- * covers (a struct can reach past a range a diff of two id sets cut). The
- * walk never splits a struct; `fn` returning `false` halts it.
- *
- * Returns `false` when coverage was INCOMPLETE — a client's struct list
- * was missing or a range start could not be located — so the caller can
- * fall back to an all-consumers/opaque answer instead of trusting a
- * partial walk. `clientsOf` throws first when the store itself is absent.
- */
-export const walkIdSet = (Y, doc, idSet, fn) => {
-    const clients = clientsOf(doc);
-    let complete = true;
-    let stopped = false;
-    idSet.clients.forEach((ranges, client) => {
-        if (stopped)
-            return;
-        const structs = clients.get(client);
-        if (structs === undefined) {
-            complete = false;
-            return;
-        }
-        for (const r of ranges.getIds()) {
-            const end = r.clock + r.len;
-            let i;
-            try {
-                i = Y.findIndexSS(structs, r.clock);
-            }
-            catch {
-                complete = false;
-                continue;
-            }
-            for (; i < structs.length; i++) {
-                const s = structs[i];
-                if (s.id.clock >= end)
-                    break;
-                if (fn(s, Math.max(r.clock, s.id.clock), Math.min(end, s.id.clock + s.length)) === false) {
-                    stopped = true;
-                    return;
-                }
-            }
-        }
-    });
-    return complete;
+ * Walk every struct the range `client:clock`, `len` units, covers, in clock
+ * order: `fn(struct, from, to)` gets the struct and the clock range `[from,
+ * to)` of it the range covers (a struct can reach past it). The walk never
+ * splits a struct; a client or a clock the store lacks walks nothing.
+ */
+export const walkRange = (Y, doc, client, clock, len, fn) => {
+    const structs = clientsOf(doc).get(client) ?? [];
+    const end = clock + len;
+    let i = structs.length;
+    try {
+        if (clock < end)
+            i = Y.findIndexSS(structs, clock);
+    }
+    catch {
+        // past the client's clock: nothing to walk
+    }
+    for (; i < structs.length && structs[i].id.clock < end; i++) {
+        const s = structs[i];
+        fn(s, Math.max(clock, s.id.clock), Math.min(end, s.id.clock + s.length));
+    }
 };
+/** Walk every struct an IdSet covers, in (client, clock) order (`walkRange` over each range). */
+export const walkIdSet = (Y, doc, idSet, fn) => idSet.clients.forEach((ranges, client) => {
+    for (const r of ranges.getIds())
+        walkRange(Y, doc, client, r.clock, r.len, fn);
+});
 /**
  * The id the local `redone` chain leads `id` to: the copy an undo or redo
  * on THIS replica re-created of a deleted item (redo copies chain), or `id`

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

@@ -0,0 +1,119 @@
+/**
+ * The per-document index (`indexOf`) as ONE closure: its state, then its
+ * parts — the claim graph, the stream table and each block's claims, the
+ * layout and table rules, placements and the children index (with THE
+ * shown-kind rule, `typeOf`), block records, the run cache, the fold and the
+ * change report — each reading the state and the parts before it as closure
+ * variables, then the view (`RunView`) over them. `../runs.ts` declares the
+ * index's types and contracts. The self-checks (`indexChecks`) read the
+ * maintained facts through {@link IndexFacts} and rebuild their own.
+ */
+import type { EngineDoc, EngineNode, EngineTransaction } from '../../engine-api.js';
+import { type BlockId, type BlockRec, type ChildSlot, type DisplayOwnership, type ResolvedPlacement } from '../../placement/model.js';
+import { type LiveRow, type RowItem } from '../rows.js';
+import type { ContentRun, RunView } from '../runs.js';
+import { type Cached } from './shared.js';
+import { type Claim, type Owner, type Stream } from '../model.js';
+import { type Edge, type SlotRef } from '../../placement/resolve.js';
+export type TextEdit = {
+    item: RowItem;
+    n: number;
+};
+export type TextEdits = {
+    edits: TextEdit[];
+    scan: boolean;
+    opaque: boolean;
+};
+/** One fold's effects: invalidated blocks, rescanned texts, rebuilt facets. */
+export type FoldCtx = {
+    invalidated: Set<BlockId>;
+    /** Per home block: its text's edits, whether it rescans, whether every reader re-reads. */
+    texts: Map<BlockId, {
+        edits: TextEdit[];
+        scan: boolean;
+        opaque: boolean;
+        seen: Set<TextEdits>;
+    }>;
+    /** The blocks whose entry or nonce changed: their delimiters are re-decided. */
+    named: Set<BlockId>;
+    table: boolean;
+    /** The winning parents, before and after, of the blocks the fold touched. */
+    parents: Set<BlockId>;
+};
+/** A slot in a children index: its display parent, rank and the island it displays out of. */
+export type Slot = {
+    parent: BlockId | null;
+    rank: string;
+    reset?: BlockId;
+};
+/** Each row's segments at its last placement: segment 0's block, then each cut's key and block. */
+export type Placed = {
+    head: BlockId | null;
+    keys: string[];
+    blocks: (BlockId | null)[];
+};
+/** The tree the change report last published. */
+export type Published = {
+    nodes: Map<BlockId, {
+        parent: BlockId | null;
+        index: number;
+        type: string;
+        data: unknown;
+        runs: readonly ContentRun[];
+        key?: string;
+    }>;
+    order: Map<BlockId | null, readonly BlockId[]>;
+    /** The children index version it was taken at. */
+    kids: number;
+};
+/** A transaction as the fold reads it. */
+export type Tx = {
+    changed?: EngineTransaction['changed'];
+    /** What the transaction did to items, in order: per item `kind, client, clock, len` (fork patch YP33). */
+    log?: number[];
+};
+/** The index's self-checks (`indexChecks`), run after each fold and each report. */
+export type SelfChecks = {
+    check: () => void;
+    checkPublished: (pub: Published) => void;
+};
+/**
+ * What the self-checks read of one index: the facts it maintains
+ * incrementally (compared with their rebuild from the replicated state) and
+ * the reads they compare through.
+ */
+export type IndexFacts = {
+    doc: EngineDoc;
+    registry: EngineNode;
+    blocks: ReadonlyMap<BlockId, BlockRec>;
+    displaysMap: ReadonlyMap<BlockId, ReadonlySet<BlockId>>;
+    rows: ReadonlyMap<BlockId, LiveRow>;
+    streamIx: ReadonlyMap<BlockId, unknown>;
+    delim: ReadonlyMap<BlockId, string>;
+    placementsMap: ReadonlyMap<BlockId, ResolvedPlacement>;
+    slotsByBlock: ReadonlyMap<BlockId, SlotRef[]>;
+    edges: ReadonlyMap<BlockId, Edge | null>;
+    rejected: ReadonlySet<BlockId>;
+    kids0: Map<BlockId | null, ChildSlot[]>;
+    kidsMap: Map<BlockId | null, ChildSlot[]>;
+    slots: ReadonlyMap<BlockId, Slot>;
+    dissolved: ReadonlySet<BlockId>;
+    following: ReadonlySet<BlockId>;
+    cache: ReadonlyMap<BlockId, Cached>;
+    dirty: ReadonlySet<BlockId>;
+    ownShim: DisplayOwnership;
+    own0: DisplayOwnership;
+    ownerOf: (b: BlockId) => Owner;
+    streamOf: (b: BlockId) => Stream | undefined;
+    sameClaims: (x: readonly Claim[], y: readonly Claim[]) => boolean;
+    dissolve: (kids: Map<BlockId | null, ChildSlot[]>) => Set<BlockId>;
+    noteFollowing: (id: BlockId) => void;
+    ensurePlacements: () => void;
+    computeFresh: (b: BlockId) => {
+        fresh: readonly ContentRun[];
+    };
+    unfolded: () => boolean;
+    reachable: (prev?: Published['nodes']) => Published;
+};
+/** The doc's index — built on first use, torn down when the doc is destroyed. */
+export declare const indexOf: (doc: EngineDoc) => RunView;