edytor 3.0.0 → 4.0.0

package/dist/crdt/schema.d.ts

@@ -5,7 +5,7 @@
  * facade module.
  */
 import type { EngineNode } from './engine-api.js';
-/** A replicated value that is a node (a block, its content, claims or `at` map, an atom). */
+/** A replicated value that is a node (a block, its content, an atom). */
 export declare const isNodeLike: (v: unknown) => v is EngineNode;
 /** Flat block registry root: blockId → node('block') (`SCHEMA.roots.registry`). */
 export declare const REGISTRY_KEY = "blocks";
@@ -13,21 +13,19 @@ export declare const REGISTRY_KEY = "blocks";
 export declare const META_ROOT_KEY = "meta";
 /** Attribution metadata root (`SCHEMA.roots.attribution`). */
 export declare const ATTRIBUTION_ROOT = "attribution";
-/** The per-block attribution root — `b/<blockId>` records (`SCHEMA.roots.blockAttribution`). */
-export declare const BLOCK_ATTR_ROOT = "blockattr";
 /**
- * Per-writer text delete marks (`text/deletes.ts`): one record per text
- * delete, naming the characters it deleted; its writer is the record's
- * engine client. In the history's scope, so an undo removes the undoer's
- * own mark and a redo writes it again.
+ * The per-block attribution root — one record per block, keyed by the block's
+ * id (`SCHEMA.roots.blockAttribution`): the string table writes the id once
+ * for its registry entry and its record (fork patch YP24).
  */
-export declare const TEXT_DELETES_ROOT = "textdel";
+export declare const BLOCK_ATTR_ROOT = "blockattr";
 /**
- * Restoration records (`text/deletes.ts`): which characters an undo's copies
- * restore, one attr per record (keyed by its writer and clock). Outside the
- * history's scope: a record is never removed.
+ * The text hold records (fork patch YP20): a text delete appends one record
+ * naming the characters it hides; its writer is the record's engine client.
+ * A character shows while no live record holds it. In the history's scope,
+ * so an undo deletes the undoer's own record and a redo writes it again.
  */
-export declare const RESTORED_ROOT = "restored";
+export declare const TEXT_DELETES_ROOT = "textdel";
 /**
  * The document's own data (`crdt/data.ts`): its leaves, as a block's. In the
  * history's scope.
@@ -41,13 +39,21 @@ export declare const DOC_DATA_ROOT = "docdata";
  */
 export declare const HORIZON_ROOT = "horizon";
 export declare const HORIZON_ATTR = "h";
+/**
+ * The ended histories (`hist.release.end`): a list of release records, one
+ * item per session whose history ended (its page left for good). A
+ * record's engine id names its writer and the clock it ended at: what that
+ * writer deleted before it (its delete and withdraw marks, its text hold
+ * records) no history can bring back, so the room's purge removes it at
+ * its next tick, past the horizon or not. The purge drops a record the
+ * horizon covers.
+ */
+export declare const RELEASE_ROOT = "released";
 /** Named node roles (`SCHEMA.nodes`). */
 export declare const BLOCK_NODE = "block";
 export declare const CONTENT_NODE = "content";
-export declare const CLAIMS_NODE = "claims";
-export declare const AT_NODE = "at";
 export declare const INLINE_NODE = "inline";
-/** Attr keys on a block node (`SCHEMA.blockAttrs`). */
+/** Attr keys on a block node (`SCHEMA.blockAttrs`); `id` is an atom's own (a block's id is its registry key). */
 export declare const ID = "id";
 export declare const TYPE = "type";
 /** A block's or atom's whole data, as documents before 0.1.0-next.6 stored it: no longer read; the room's purge deletes it. */
@@ -84,14 +90,9 @@ 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";
-/** Ordered merge claims `{m: blockId}`. */
-export declare const CLAIMS = "claims";
-export declare const AT = "at";
-/** `b/<blockId>` record-key prefix on the `blockattr` root. */
-export declare const REC_PREFIX = "b/";
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export declare const SCHEMA: {
-    readonly version: 6;
+    readonly version: 10;
     readonly name: "edytor-doc";
     readonly roots: {
         readonly registry: "blocks";

package/dist/crdt/schema.js

@@ -1,4 +1,4 @@
-/** A replicated value that is a node (a block, its content, claims or `at` map, an atom). */
+/** A replicated value that is a node (a block, its content, an atom). */
 export const isNodeLike = (v) => v != null && typeof v.getAttr === 'function';
 /** Flat block registry root: blockId → node('block') (`SCHEMA.roots.registry`). */
 export const REGISTRY_KEY = 'blocks';
@@ -6,21 +6,19 @@ export const REGISTRY_KEY = 'blocks';
 export const META_ROOT_KEY = 'meta';
 /** Attribution metadata root (`SCHEMA.roots.attribution`). */
 export const ATTRIBUTION_ROOT = 'attribution';
-/** The per-block attribution root — `b/<blockId>` records (`SCHEMA.roots.blockAttribution`). */
-export const BLOCK_ATTR_ROOT = 'blockattr';
 /**
- * Per-writer text delete marks (`text/deletes.ts`): one record per text
- * delete, naming the characters it deleted; its writer is the record's
- * engine client. In the history's scope, so an undo removes the undoer's
- * own mark and a redo writes it again.
+ * The per-block attribution root — one record per block, keyed by the block's
+ * id (`SCHEMA.roots.blockAttribution`): the string table writes the id once
+ * for its registry entry and its record (fork patch YP24).
  */
-export const TEXT_DELETES_ROOT = 'textdel';
+export const BLOCK_ATTR_ROOT = 'blockattr';
 /**
- * Restoration records (`text/deletes.ts`): which characters an undo's copies
- * restore, one attr per record (keyed by its writer and clock). Outside the
- * history's scope: a record is never removed.
+ * The text hold records (fork patch YP20): a text delete appends one record
+ * naming the characters it hides; its writer is the record's engine client.
+ * A character shows while no live record holds it. In the history's scope,
+ * so an undo deletes the undoer's own record and a redo writes it again.
  */
-export const RESTORED_ROOT = 'restored';
+export const TEXT_DELETES_ROOT = 'textdel';
 /**
  * The document's own data (`crdt/data.ts`): its leaves, as a block's. In the
  * history's scope.
@@ -34,13 +32,21 @@ export const DOC_DATA_ROOT = 'docdata';
  */
 export const HORIZON_ROOT = 'horizon';
 export const HORIZON_ATTR = 'h';
+/**
+ * The ended histories (`hist.release.end`): a list of release records, one
+ * item per session whose history ended (its page left for good). A
+ * record's engine id names its writer and the clock it ended at: what that
+ * writer deleted before it (its delete and withdraw marks, its text hold
+ * records) no history can bring back, so the room's purge removes it at
+ * its next tick, past the horizon or not. The purge drops a record the
+ * horizon covers.
+ */
+export const RELEASE_ROOT = 'released';
 /** Named node roles (`SCHEMA.nodes`). */
 export const BLOCK_NODE = 'block';
 export const CONTENT_NODE = 'content';
-export const CLAIMS_NODE = 'claims';
-export const AT_NODE = 'at';
 export const INLINE_NODE = 'inline';
-/** Attr keys on a block node (`SCHEMA.blockAttrs`). */
+/** Attr keys on a block node (`SCHEMA.blockAttrs`); `id` is an atom's own (a block's id is its registry key). */
 export const ID = 'id';
 export const TYPE = 'type';
 /** A block's or atom's whole data, as documents before 0.1.0-next.6 stored it: no longer read; the room's purge deletes it. */
@@ -73,16 +79,16 @@ 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';
-/** Ordered merge claims `{m: blockId}`. */
-export const CLAIMS = 'claims';
-export const AT = 'at';
-/** `b/<blockId>` record-key prefix on the `blockattr` root. */
-export const REC_PREFIX = 'b/';
 /** The schema generation stamped on the `meta` root (`v`) and its manifest name (`schema`). */
 export const SCHEMA = {
-    // 6: one update encoding (the columnar one) on the wire and in storage;
-    // a container or frame of an earlier generation is refused.
-    version: 6,
+    // 7: a text delete is a hold record (fork patch YP20) on the wire and in
+    // storage; 8: a merge claim is an item `{m}` in a backing text (fork patch
+    // YP21), a block has no `claims` list; 9: a block's place is its home slot
+    // in its parent's sequence and a move is a move record (fork patch YP22),
+    // a block has no `at` map and an array item no rank; 10: the update encoding
+    // writes each distinct string once (fork patch YP24). A container or frame
+    // of an earlier generation is refused.
+    version: 10,
     name: 'edytor-doc',
     roots: { registry: REGISTRY_KEY, meta: META_ROOT_KEY },
     metaAttrs: { version: 'v', schema: 'schema' }

package/dist/crdt/storage.d.ts

@@ -4,7 +4,7 @@
  * when that makes them smaller (`CompressionStream`, in every supported
  * browser, Node and Workers). A compressed record starts with gzip's magic
  * `1f 8b`, which no update does (its first byte is the encoder's feature
- * flag, `00`), so a record says itself whether it is compressed.
+ * flag, the encoding: `01`), so a record says itself whether it is compressed.
  * Worker-safe: no timers.
  */
 /** Whether `bytes` are gzip (its magic `1f 8b`). */

package/dist/crdt/storage.js

@@ -4,7 +4,7 @@
  * when that makes them smaller (`CompressionStream`, in every supported
  * browser, Node and Workers). A compressed record starts with gzip's magic
  * `1f 8b`, which no update does (its first byte is the encoder's feature
- * flag, `00`), so a record says itself whether it is compressed.
+ * flag, the encoding: `01`), so a record says itself whether it is compressed.
  * Worker-safe: no timers.
  */
 /** Whether `bytes` are gzip (its magic `1f 8b`). */

package/dist/crdt/structs.d.ts

@@ -24,6 +24,16 @@ export type StoreStruct = {
         client: number;
         clock: number;
     } | null;
+    /** Live hold records naming the item (fork patch YP20): a held item reads as deleted. */
+    holds?: number;
+    /** Whether the engine deleted it (`deleted` also covers a held or moved item). */
+    removed?: boolean;
+    /** Removed or held: shown nowhere (fork patch YP22; a moved item shows at its mover). */
+    gone?: boolean;
+    /** The live move records naming the item (fork patch YP22), `null` at home. */
+    movers?: StoreStruct[] | null;
+    /** The record that shows the item (the greatest `(priority, client, clock)` of `movers`). */
+    mover?: StoreStruct | null;
 };
 /**
  * The engine's IdSet shape (insertSet/deleteSet): per-client range lists —
@@ -85,8 +95,6 @@ export declare const followRedone: (Y: EngineApi, doc: EngineDoc, id: {
  * drops them the same way after a pop.
  */
 export declare const dropSearchMarkers: (node: unknown) => void;
-/** The clock `client`'s next struct gets in `doc`. */
-export declare const nextClock: (doc: EngineDoc, client: number) => number;
 /**
  * Whether `doc` holds updates it cannot integrate yet (vendor-internal
  * `store.pendingStructs`/`pendingDs`): an out-of-order delivery can apply
@@ -141,6 +149,11 @@ export type StoreLike = {
 };
 /** The doc's struct store (vendor `store`). */
 export declare const storeOf: (doc: EngineDoc | YDoc) => StoreLike;
+/**
+ * Whether `doc` holds every id `client:clock … clock+len-1` (none past its
+ * clock, none in a gap the engine fills later: vendor `store.skips`).
+ */
+export declare const holdsIds: (doc: EngineDoc, client: number, clock: number, len: number) => boolean;
 /** Whether `doc` collects deleted content at all (vendor `gc`). */
 export declare const collects: (doc: EngineDoc | YDoc) => boolean;
 /** Whether `doc`'s collection filter lets it collect `item` (vendor `gcFilter`). */
@@ -156,11 +169,6 @@ export declare const keepFromCollection: <I = StoreStruct>(doc: EngineDoc | YDoc
  * {@link collects} and {@link collectable}.
  */
 export declare const collectNow: (item: object, tr: unknown) => void;
-/**
- * Listen to `doc`'s transaction events (vendor `beforeTransaction`,
- * `afterTransaction`), with the caller's view of a transaction.
- */
-export declare const onTransaction: <T>(doc: EngineDoc | YDoc, event: "beforeTransaction" | "afterTransaction", f: (tr: T) => void) => void;
 /**
  * Whether a transaction changed one of `nodes` or a node under one: its
  * `changed` types and their ancestors (what a deep observer of `nodes`
@@ -189,8 +197,6 @@ export declare const engineOps: (Y: EngineApi) => {
     insertInto: (into: IdSetLike, from: IdSetLike) => void;
     /** Each struct `ids` covers, split at its edges, inside `tr`. */
     iterate: <I = StoreStruct>(tr: unknown, ids: IdSetLike, f: (item: I) => void) => void;
-    /** The item starting at `client:clock`, split there, inside `tr`. */
-    cleanStart: <I = StoreStruct>(tr: unknown, client: number, clock: number) => I;
     /**
      * Re-create deleted `item` (`redoItem`, fork patch YP18): its copy, or
      * `null` when it cannot come back. `items` are re-created with it (a
@@ -217,12 +223,6 @@ export declare const engineOps: (Y: EngineApi) => {
     /** Listen to a doc event (vendor `on`/`off`), with the caller's view of its arguments. */
     on: (doc: EngineDoc, event: string, f: (...args: never[]) => void) => void;
     off: (doc: EngineDoc, event: string, f: (...args: never[]) => void) => void;
-    /**
-     * Integrate a new item holding `content` right after `left` (its
-     * origin: `left`'s last id) in `parent`, written by `client` at
-     * `clock`, inside `tr`.
-     */
-    appendAfter: (tr: unknown, left: StoreStruct, parent: EngineNode, client: number, clock: number, content: unknown[]) => void;
     /** Whether `item` is a node value a concurrent write replaced and its doc keeps. */
     isKeptReplaced: (item: unknown) => boolean;
 };

package/dist/crdt/structs.js

@@ -121,12 +121,6 @@ export const dropSearchMarkers = (node) => {
     if (markers)
         markers.length = 0;
 };
-/** The clock `client`'s next struct gets in `doc`. */
-export const nextClock = (doc, client) => {
-    const structs = clientsOf(doc).get(client);
-    const last = structs?.[structs.length - 1];
-    return last === undefined ? 0 : last.id.clock + last.length;
-};
 /**
  * Whether `doc` holds updates it cannot integrate yet (vendor-internal
  * `store.pendingStructs`/`pendingDs`): an out-of-order delivery can apply
@@ -177,6 +171,14 @@ export const sequenceLength = (node) => node._length;
 export const itemOf = (node) => node._item;
 /** The doc's struct store (vendor `store`). */
 export const storeOf = (doc) => doc.store;
+/**
+ * Whether `doc` holds every id `client:clock … clock+len-1` (none past its
+ * clock, none in a gap the engine fills later: vendor `store.skips`).
+ */
+export const holdsIds = (doc, client, clock, len) => {
+    const store = doc;
+    return (clock + len <= store.store.getClock(client) && !store.store.skips.intersects(client, clock, len));
+};
 /** Whether `doc` collects deleted content at all (vendor `gc`). */
 export const collects = (doc) => doc.gc;
 /** Whether `doc`'s collection filter lets it collect `item` (vendor `gcFilter`). */
@@ -196,11 +198,6 @@ export const keepFromCollection = (doc, keep) => {
  * {@link collects} and {@link collectable}.
  */
 export const collectNow = (item, tr) => item.gc(tr, false);
-/**
- * Listen to `doc`'s transaction events (vendor `beforeTransaction`,
- * `afterTransaction`), with the caller's view of a transaction.
- */
-export const onTransaction = (doc, event, f) => doc.on(event, f);
 /**
  * Whether a transaction changed one of `nodes` or a node under one: its
  * `changed` types and their ancestors (what a deep observer of `nodes`
@@ -229,8 +226,6 @@ export const engineOps = (Y) => {
         insertInto: (into, from) => Y.insertIntoIdSet(into, from),
         /** Each struct `ids` covers, split at its edges, inside `tr`. */
         iterate: (tr, ids, f) => Y.iterateStructsByIdSet(tr, ids, f),
-        /** The item starting at `client:clock`, split there, inside `tr`. */
-        cleanStart: (tr, client, clock) => Y.getItemCleanStart(tr, Y.createID(client, clock)),
         /**
          * Re-create deleted `item` (`redoItem`, fork patch YP18): its copy, or
          * `null` when it cannot come back. `items` are re-created with it (a
@@ -262,15 +257,6 @@ export const engineOps = (Y) => {
         /** Listen to a doc event (vendor `on`/`off`), with the caller's view of its arguments. */
         on: (doc, event, f) => doc.on(event, f),
         off: (doc, event, f) => doc.off(event, f),
-        /**
-         * Integrate a new item holding `content` right after `left` (its
-         * origin: `left`'s last id) in `parent`, written by `client` at
-         * `clock`, inside `tr`.
-         */
-        appendAfter: (tr, left, parent, client, clock, content) => {
-            const item = new Y.Item(Y.createID(client, clock), left, left.lastId, null, null, asYNode(parent), null, new Y.ContentAny(content));
-            item.integrate(tr, 0);
-        },
         /** Whether `item` is a node value a concurrent write replaced and its doc keeps. */
         isKeptReplaced: (item) => Y.isKeptReplaced(item)
     };

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

@@ -32,12 +32,16 @@ export const indexCache = (ix) => {
         get foldedStructs() {
             return foldStats.structs;
         },
+        get placements() {
+            return foldStats.placed;
+        },
         reset() {
             debug.recomputes = 0;
             debug.recomputed.clear();
             foldStats.folds = 0;
             foldStats.pairs = 0;
             foldStats.structs = 0;
+            foldStats.placed = 0;
             rangeStats.items = 0;
             rangeStats.markers = 0;
         }

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

@@ -117,6 +117,7 @@ export const indexClaims = (ix) => {
         // The tops a seed's claims (now, and those it dropped: noted in `claimersOf` changes) decide.
         const affected = new Set();
         const stack = [];
+        const seeds = [...ownerSeeds];
         for (const x of ownerSeeds) {
             stack.push(x);
             for (const m of claimTargets.get(x) ?? [])
@@ -150,6 +151,17 @@ export const indexClaims = (ix) => {
             setDisplay(x, was, now);
             ownerChanged.add(x);
         }
+        // A holder whose claims changed re-slots what shows through them: their
+        // order among its claims is the key of the blocks shown under it
+        // (`claimedRank`) — under its owner when it is itself merged away.
+        for (const x of seeds) {
+            if (!blocks.has(x))
+                continue;
+            ownerChanged.add(x);
+            const o = owners.get(x);
+            if (typeof o === 'string' && o !== x)
+                ownerChanged.add(o);
+        }
     };
     /** The claims each seed held before its record changed (their tops are re-decided too). */
     const claimTargets = new Map();

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

@@ -1,6 +1,5 @@
-import { type BlockId } from '../../placement/model.js';
+import type { BlockId } from '../../placement/model.js';
 import type { ContentRun } from '../runs.js';
-import type { IndexAnchored } from './anchored.js';
 import type { IndexCache } from './cache.js';
 import type { IndexClaims } from './claims.js';
 import type { IndexPlacement } from './placement.js';
@@ -9,7 +8,7 @@ import type { FoldCtx, IndexState, Tx } from './state.js';
 import type { IndexStreams } from './streams.js';
 import type { IndexLayout } from './layout.js';
 /** The fold of one doc's index, over every part it folds into. */
-export declare const indexFold: (ix: IndexState & IndexClaims & IndexStreams & IndexAnchored & IndexLayout & IndexPlacement & IndexRecords & IndexCache) => {
+export declare const indexFold: (ix: IndexState & IndexClaims & IndexStreams & IndexLayout & IndexPlacement & IndexRecords & IndexCache) => {
     runs: (b: BlockId) => readonly ContentRun[];
     settle: (affected: Iterable<BlockId>, ctx: FoldCtx | null) => void;
     syncPending: (tr: Tx | null | undefined) => boolean;