edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/attribution/block.js

@@ -1,22 +1,6 @@
 import { REGISTRY_KEY } from '../placement/model.js';
 import { BLOCK_ATTR_ROOT, isNodeLike, LAST_CHANGED_ATTR, NONCE, REC_PREFIX } from '../schema.js';
-import { attrItems, newNode as makeNode, onTransaction } from '../structs.js';
-/**
- * The ring's retention bound — the deepest `lineage.depth` any surviving
- * entry's writer was configured with. `POSITIVE_INFINITY` when ANY entry
- * lacks `d` (pre-watermark data): without knowing every writer's bound,
- * no entry may be evicted on their behalf.
- */
-export const lineageWatermarkOf = (entries) => {
-    let wm = 0;
-    for (const e of entries) {
-        if (typeof e.d !== 'number' || !Number.isFinite(e.d))
-            return Number.POSITIVE_INFINITY;
-        if (e.d > wm)
-            wm = e.d;
-    }
-    return wm;
-};
+import { attrItems, newNode as makeNode } from '../structs.js';
 // `BLOCK_ATTR_ROOT`/`LAST_CHANGED_ATTR`/`REC_PREFIX` live in the shared
 // `../schema.js` leaf — re-exported so existing import sites stay.
 export { BLOCK_ATTR_ROOT, LAST_CHANGED_ATTR };
@@ -82,15 +66,6 @@ export const blockAttributionOf = (doc, id) => {
         lastChangedBy: typeof l === 'string' ? l : undefined
     };
 };
-/**
- * Read one block's lineage ring, oldest → newest — or `undefined` when
- * the block carries no record. Entries are the stored content values;
- * callers deep-copy before exposing them publicly.
- */
-export const lineageOf = (doc, id) => {
-    const rec = recordOf(doc, id);
-    return rec === null ? undefined : rec.toArray();
-};
 /**
  * Bound write helpers. `stampChange`/`stampCreated`/`unionContributors`
  * must be called INSIDE the operation's `doc.transact` — they perform
@@ -205,124 +180,6 @@ export const bindBlockAttribution = (Y) => {
             const into = ensureRecord(doc, intoId, blockNodeOf(doc, intoId));
             for (const a of contributorsOfRecord(from))
                 addContributor(into, a);
-        },
-        /**
-         * Append a displaced-state checkpoint to the block's ring and trim
-         * to the ring's watermark — `max` of surviving entries' `d`,
-         * including the fresh one. The caller captures `entry.j` BEFORE its
-         * model write (see `lineagePending` in `edytor-doc.ts`) and calls
-         * this only after the write proves out, so a refused write appends
-         * nothing. The watermark is THE retention policy — identical on
-         * append, on receive (`attachRingTrim`), and on read — so a shallow
-         * replica never evicts a deeper writer's surviving history, and the
-         * bound shrinks only once the deepest entries have themselves
-         * aged out. Concurrent appends under partition can still merge a
-         * ring past the watermark — neither side saw the other's entry —
-         * which the receive-side repair converges back.
-         */
-        appendLineage: (doc, id, entry, depth) => {
-            const rec = ensureRecord(doc, id);
-            rec.insert(rec.length, [{ ...entry, s: rec.length, d: depth }]);
-            const wm = lineageWatermarkOf(rec.toArray());
-            if (rec.length > wm)
-                rec.delete(0, rec.length - wm);
-        },
-        /**
-         * The block's lineage ring, oldest → newest — or `undefined` when
-         * the block has no record at all. Entries are the stored content
-         * values; the public surface copies them before handing them out.
-         */
-        lineageOf,
-        /**
-         * Attach the doc's shared ring-watermark repair — once per doc for
-         * the doc's lifetime (module-level dedupe). See the module-level comment
-         * below.
-         */
-        attachRingTrim: (doc) => {
-            if (ringTrimAttached.has(doc))
-                return;
-            ringTrimAttached.set(doc, true);
-            const trimToWatermark = (rec) => {
-                const wm = lineageWatermarkOf(rec.toArray());
-                if (rec.length > wm)
-                    rec.delete(0, rec.length - wm);
-            };
-            onTransaction(doc, 'afterTransaction', (transaction) => {
-                try {
-                    const changed = transaction?.changed;
-                    if (changed === undefined)
-                        return;
-                    let over;
-                    for (const type of changed.keys()) {
-                        const rec = type;
-                        if (rec?.name === REC_NODE &&
-                            rec.length > lineageWatermarkOf(rec.toArray())) {
-                            (over ??= []).push(rec);
-                        }
-                    }
-                    if (over === undefined)
-                        return;
-                    // A follow-up transaction in the same cleanup sweep — the
-                    // trim deletes exactly the items the next append would
-                    // evict, so concurrent trims (each replica runs this on
-                    // the same merged state) delete the SAME items and stay
-                    // convergent. The watermark never goes below a surviving
-                    // entry's own configured depth.
-                    doc.transact(() => {
-                        for (const rec of over)
-                            trimToWatermark(rec);
-                    }, LINEAGE_TRIM_ORIGIN);
-                }
-                catch (err) {
-                    // A failure here must never propagate — throwing inside
-                    // `afterTransaction` would break the host transaction's
-                    // cleanup sweep. An untrimmed ring still converges.
-                    console.error('[edytor-doc] lineage ring trim failed; leaving over-cap state', err);
-                }
-            });
-            // Install-time sweep: a doc that arrived over-cap BEFORE this
-            // listener existed — `loadDocument`/`attachDocument` integrate
-            // the payload before the facade composes — never fires the
-            // hook above for that data. One O(records) pass converges it.
-            try {
-                const root = doc.get(BLOCK_ATTR_ROOT);
-                let over;
-                for (const key of root.attrKeys()) {
-                    if (!key.startsWith(REC_PREFIX))
-                        continue;
-                    const rec = root.getAttr(key);
-                    if (isNodeLike(rec) &&
-                        rec.name === REC_NODE &&
-                        rec.length > lineageWatermarkOf(rec.toArray())) {
-                        (over ??= []).push(rec);
-                    }
-                }
-                if (over !== undefined) {
-                    doc.transact(() => {
-                        for (const rec of over)
-                            trimToWatermark(rec);
-                    }, LINEAGE_TRIM_ORIGIN);
-                }
-            }
-            catch (err) {
-                console.error('[edytor-doc] lineage ring sweep failed; leaving over-cap state', err);
-            }
         }
     };
 };
-/**
- * Per-doc attach table for the shared ring-trim listener — module level
- * (not binding- or facade-scoped) so the listener is installed ONCE per
- * doc across every binding's facade `create()`, and never detached: a
- * ring pushed over its watermark by concurrent appends is converged even
- * after the last facade disposes. The `WeakMap` entry and the doc-held
- * listener die with the doc — no leak.
- */
-const ringTrimAttached = new WeakMap();
-/**
- * Origin of the ring-trim's delete writes — an origin no UndoManager
- * tracks, so trims never enter an undo stack and never recurse (the trim
- * only deletes ring items: the follow-up `afterTransaction` pass finds
- * the ring at exactly the watermark and stops).
- */
-const LINEAGE_TRIM_ORIGIN = Symbol('edytor.lineage-trim');

package/dist/crdt/data.d.ts

@@ -21,15 +21,11 @@
  * Read rule: the leaves are read as a tree; a path with live items is an
  * array (sorted by rank, then id), one with keys an object (it beats a
  * primitive leaf at the same path: Ada sets `a = 1` while Bob sets
- * `a.b = 2`), else its leaf. The legacy whole `data` attr (documents
- * written before 0.1.0-next.6) is a base each leaf shadows at, above and
- * under its path; an array leaf with values (next.6's atomic arrays, and
- * every array of the attr) reads as items with ids and ranks derived from
- * the array (as any array assigned where no item is), so two replicas
- * exploding it write the same items. A patch
- * writes its leaves over the attr while it still reads right, else deletes
- * it and writes every leaf (residual: a peer's concurrent set of a key it
- * held, or its removal of an item, may then lose to the exploded value).
+ * `a.b = 2`), else its leaf. A leaf holding an object or an array (an
+ * atomic path's, `data.atomic`, or an array 0.1.0-next.6 wrote) reads as
+ * its keys or as items with ids and ranks derived from the array (as any
+ * array assigned where no item is), so two replicas writing into it write
+ * the same items; a patch opens it only along its path.
  */
 import type { EngineNode } from './engine-api.js';
 type JsonObj = Record<string, unknown>;
@@ -77,16 +73,25 @@ export declare const readData: (node: EngineNode) => JsonObj | undefined;
  * in `node`'s data, in order; `[]` where no array is.
  */
 export declare const itemIds: (node: EngineNode, path: readonly string[]) => string[];
+/**
+ * `node`'s data as it reads once `patches` are applied (nothing written),
+ * with the ids of the array items at a path (`itemIds`): an item a patch
+ * makes has no id yet (`''`), so a later patch names it by index.
+ * `null` when a patch fits no value.
+ */
+export declare const previewData: (node: EngineNode | undefined, patches: readonly DataPatch[]) => {
+    data: JsonObj;
+    ids: (path: readonly string[]) => string[];
+} | null;
 /** `data` with `patches` applied in order, as a fresh value (a root patch replaces it); `null` when one fits no value. */
 export declare const applyPatch: (data: JsonObj, patches: readonly DataPatch[]) => JsonObj | null;
 /**
  * The attr writes that give `node` the data `patches` make of its own (new
  * items get ids from `rand`, ranks from `client`), or `null` when a patch
  * fits no value there: only the leaves of the keys and items a patch
- * touches change, so a concurrent edit of another key or item is kept. A
- * legacy base (the attr, an atomic array leaf) stays under the leaves while
- * they still read as the patched value, else it is exploded: every leaf
- * written, the attr deleted. An unchanged value writes nothing.
+ * touches change, so a concurrent edit of another key or item is kept. An
+ * atomic path is written as one leaf and the leaves under it are deleted.
+ * An unchanged value writes nothing.
  */
 export declare const patchWrites: (node: EngineNode, patches: readonly DataPatch[], client?: number, rand?: () => number, atomic?: readonly string[]) => LeafWrite[] | null;
 /** Write `writes` on `node` (a detached one too: a block or atom being created). */

package/dist/crdt/data.js

@@ -1,4 +1,4 @@
-import { DATA, DATA_LEAF_PREFIX } from './schema.js';
+import { DATA_LEAF_PREFIX } from './schema.js';
 import { rankAfter } from './placement/rank.js';
 import { hash32 } from './rand.js';
 import { jsonEquals } from '../utils/json.js';
@@ -33,8 +33,21 @@ const itemsOf = (t) => {
 const isArr = (t) => Array.isArray(t.v) || itemsOf(t).length > 0;
 /** The item `seg` names among `items`: by its id (`~…`) or by its index. */
 const itemAt = (items, seg) => itemish(seg) ? items.find((i) => i.id === seg) : items[index(seg)];
-/** The JSON `t` reads as (`undefined` for nothing). */
+/** Whether `t` holds a non-empty object or array as one leaf (no subtree under it). */
+const closed = (t) => t.k.size === 0 && t.v !== null && typeof t.v === 'object' && Object.keys(t.v).length > 0;
+/** `t` with a container leaf's value as its subtree: its keys, or derived items. */
+const open = (t) => {
+    if (closed(t)) {
+        const value = t.v;
+        t.v = undefined;
+        derived.assign(t, value);
+    }
+    return t;
+};
+/** The JSON `t` reads as (`undefined` for nothing): a fresh value. */
 const valueOf = (t) => {
+    if (closed(t))
+        return valueOf(open(tree(t.v)));
     const items = itemsOf(t);
     if (items.length)
         return items.map(({ id }) => valueOf(t.k.get(id) ?? tree()) ?? null);
@@ -176,7 +189,7 @@ const edits = (rand, client = 0) => {
     };
     /** Make `t` read as `value`, writing only what differs: objects key by key, arrays item by item. */
     const assign = (t, value) => {
-        if (Array.isArray(value) && itemsOf(t).length)
+        if (Array.isArray(value) && itemsOf(open(t)).length)
             return arrange(t, value);
         // Anything else replaces what `t` held, but an object's equal keys.
         const object = isObject(value) && Object.keys(value).length > 0;
@@ -228,7 +241,7 @@ const edits = (rand, client = 0) => {
         for (const k of path) {
             if (!t)
                 return t;
-            if (isArr(t)) {
+            if (isArr(open(t))) {
                 const item = itemAt(itemsOf(t), k);
                 t = item && kid(t, item.id);
             }
@@ -239,7 +252,7 @@ const edits = (rand, client = 0) => {
                 t = kid(t, enc(segmentKey(k)));
             }
         }
-        return t;
+        return t && open(t);
     };
     /** Apply `patch` to `root`; `false` when it fits no value there. */
     const apply = (root, { path, value, splice, order }) => {
@@ -314,41 +327,6 @@ const leavesOfValue = (value, prefix = DATA_LEAF_PREFIX) => {
 };
 /** A new node's data, as leaves. */
 export const dataLeaves = (data) => leavesOfValue(isObject(data) ? data : {});
-/**
- * `leaves` over the bases they shadow (each leaf at, above and under its
- * path): the legacy attr, and each array leaf with values (as items).
- */
-const effective = (base, leaves) => {
-    /** `key` and the paths above it longer than `floor`. */
-    const above = (key, floor = 0) => {
-        const out = [];
-        for (let i = key.length; i > floor; i = key.lastIndexOf('/', i - 1))
-            out.push(key.slice(0, i));
-        return out;
-    };
-    const near = new Set([...leaves.keys()].flatMap((key) => above(key)));
-    const out = new Map();
-    const under = (prefix, value) => {
-        for (const [key, v] of leavesOfValue(value, prefix))
-            if (!near.has(key) && !above(key, prefix.length - 1).some((p) => leaves.has(p)))
-                out.set(key, v);
-    };
-    if (isObject(base))
-        under(DATA_LEAF_PREFIX, base);
-    for (const [key, v] of leaves) {
-        out.set(key, v);
-        if (Array.isArray(v) && v.length) {
-            under(`${key}/`, v);
-            out.set(key, []);
-        }
-        else if (isObject(v) && Object.keys(v).length) {
-            // An object written as one leaf (an atomic path, `data.atomic`) reads as its keys.
-            under(`${key}/`, v);
-            out.set(key, {});
-        }
-    }
-    return out;
-};
 /** A path of the data as a leaf key (`d/` and its pointer). */
 export const leafKey = (path) => DATA_LEAF_PREFIX + path.map((k) => enc(k)).join('/');
 /**
@@ -370,23 +348,40 @@ const collapse = (leaves, atomic) => {
     }
     return leavesFrom(root);
 };
-const read = (base, leaves) => valueOf(treeOf(effective(base, leaves)));
 /** `node`'s data (`undefined` when it has none). */
-export const readData = (node) => read(node.getAttr(DATA), leavesOf(node));
+export const readData = (node) => valueOf(treeOf(leavesOf(node)));
 /**
  * The ids of the items of the array at `path` (keys, item indexes or ids)
  * in `node`'s data, in order; `[]` where no array is.
  */
-export const itemIds = (node, path) => {
-    let t = treeOf(effective(node.getAttr(DATA), leavesOf(node)));
+export const itemIds = (node, path) => idsAt(treeOf(leavesOf(node)), path);
+const idsAt = (root, path) => {
+    let t = root;
     for (const k of path)
-        if (t && isArr(t)) {
+        if (t && isArr(open(t))) {
             const item = itemAt(itemsOf(t), k);
             t = item && t.k.get(item.id);
         }
         else
             t = itemish(k) ? undefined : t?.k.get(enc(segmentKey(k)));
-    return t ? itemsOf(t).map(({ id }) => id) : [];
+    return t ? itemsOf(open(t)).map(({ id }) => id) : [];
+};
+/**
+ * `node`'s data as it reads once `patches` are applied (nothing written),
+ * with the ids of the array items at a path (`itemIds`): an item a patch
+ * makes has no id yet (`''`), so a later patch names it by index.
+ * `null` when a patch fits no value.
+ */
+export const previewData = (node, patches) => {
+    const base = node ? leavesOf(node) : new Map();
+    const root = treeOf(base);
+    if (!patches.every((p) => edits().apply(root, p)))
+        return null;
+    const known = new Set([...base.keys()].flatMap((key) => key.split('/')));
+    return {
+        data: valueOf(root) ?? {},
+        ids: (path) => idsAt(root, path).map((id) => (known.has(`${id}#`) ? id : ''))
+    };
 };
 /** `data` with `patches` applied in order, as a fresh value (a root patch replaces it); `null` when one fits no value. */
 export const applyPatch = (data, patches) => {
@@ -399,40 +394,23 @@ export const applyPatch = (data, patches) => {
  * The attr writes that give `node` the data `patches` make of its own (new
  * items get ids from `rand`, ranks from `client`), or `null` when a patch
  * fits no value there: only the leaves of the keys and items a patch
- * touches change, so a concurrent edit of another key or item is kept. A
- * legacy base (the attr, an atomic array leaf) stays under the leaves while
- * they still read as the patched value, else it is exploded: every leaf
- * written, the attr deleted. An unchanged value writes nothing.
+ * touches change, so a concurrent edit of another key or item is kept. An
+ * atomic path is written as one leaf and the leaves under it are deleted.
+ * An unchanged value writes nothing.
  */
 export const patchWrites = (node, patches, client = 0, rand, atomic = []) => {
-    const [base, now] = [node.getAttr(DATA), leavesOf(node)];
-    const was = effective(base, now);
-    const root = treeOf(was);
+    const now = leavesOf(node);
+    const root = treeOf(now);
     const before = valueOf(root);
     const { apply } = edits(rand, client);
     if (!patches.every((p) => apply(root, p)))
         return null;
-    const value = valueOf(root);
-    if (jsonEquals(before, value))
+    if (jsonEquals(before, valueOf(root)))
         return [];
-    // An atomic path is written as one leaf, and every leaf stored under it goes.
     const want = collapse(leavesFrom(root), atomic);
-    const under = (key) => atomic.some((a) => key.startsWith(`${a}/`));
-    const diff = (from) => [...new Set([...from.keys(), ...want.keys()])]
-        .filter((key) => !jsonEquals(from.get(key), want.get(key)))
+    return [...new Set([...now.keys(), ...want.keys()])]
+        .filter((key) => !jsonEquals(now.get(key), want.get(key)))
         .map((key) => [key, want.get(key)]);
-    const own = [
-        ...diff(collapse(was, atomic)),
-        ...[...now.keys()]
-            .filter((key) => under(key) && !want.has(key))
-            .map((key) => [key, undefined])
-    ];
-    const after = new Map(now);
-    for (const [key, value] of own)
-        value === undefined ? after.delete(key) : after.set(key, value);
-    if (jsonEquals(read(base, after), value))
-        return own;
-    return [...(base === undefined ? [] : [[DATA, undefined]]), ...diff(now)];
 };
 /** Write `writes` on `node` (a detached one too: a block or atom being created). */
 export const writeLeaves = (node, writes) => {

package/dist/crdt/doc/anchors.js

@@ -4,11 +4,11 @@
  * resolved to the block that displays it now (`resolveAnchor`).
  */
 import { isLiveIn } from '../placement/model.js';
-import { DEAD, displayOf, locate, ownedLength } from '../text/model.js';
+import { anchorAt as textAnchorAt, DEAD, displayOf, locate, ownedLength, resolveAnchor as textResolveAnchor } from '../text/model.js';
 import { followRedone } from '../structs.js';
 /** The anchors of one facade. */
 export const docAnchors = (c) => {
-    const { Y, doc, T, view } = c;
+    const { Y, doc, view } = c;
     // ── anchors ─────────────────────────────────────────────────
     // An anchor is the home text id plus a relative position; the stream
     // containing the position says which block displays it. Both reads use
@@ -31,7 +31,7 @@ export const docAnchors = (c) => {
         const hit = locate(segs, Math.max(0, Math.min(offset, ownedLength(segs))), affinity);
         if (hit === null)
             return { b: blockId, a: { i: null, a: assoc } };
-        return { b: hit.seg.t, a: T.anchorAt(hit.seg.text, hit.idx, assoc) };
+        return { b: hit.seg.t, a: textAnchorAt(hit.seg.text, hit.idx, assoc) };
     };
     /**
      * `anchor` rebound to the copy this replica's last undo/redo
@@ -64,7 +64,7 @@ export const docAnchors = (c) => {
                 ? { blockId: anchor.b, offset: 0 }
                 : null;
         }
-        const i = T.resolveAnchor(doc, text, anchor.a);
+        const i = textResolveAnchor(doc, text, anchor.a);
         if (i === null)
             return null;
         const s = own.streamAt(anchor.b, i);

package/dist/crdt/doc/content.d.ts

@@ -1,12 +1,16 @@
 import type { BlockId, InlineSpec } from '../placement/model.js';
 import type { Prepared } from './types.js';
 import type { OpsContext } from './steps.js';
+/** An inline atom to insert: its id is minted when it names none. */
+export type NewInline = Omit<InlineSpec, 'id'> & {
+    id?: string;
+};
 /** The content ops of one facade, prepared. */
 export declare const contentOps: (c: OpsContext) => {
     insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
     deleteText: (id: BlockId, offset: number, length: number) => Prepared;
     formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
     clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
-    insertInline: (id: BlockId, offset: number, atom: InlineSpec) => Prepared;
+    insertInline: (id: BlockId, offset: number, atom: NewInline) => Prepared;
     removeInline: (id: BlockId, inlineId: string) => Prepared;
 };

package/dist/crdt/doc/content.js

@@ -3,6 +3,7 @@
  * inside voids — the caption contract), and marks over a range.
  */
 import { sanitizeWireJson, jsonEquals } from '../../utils/json.js';
+import { id as newId } from '../../utils.js';
 import { ref, sanitizeInline } from './plan.js';
 /** The content ops of one facade, prepared. */
 export const contentOps = (c) => {
@@ -50,9 +51,10 @@ export const contentOps = (c) => {
         }
         return formatRange(id, offset, length, clears);
     };
+    /** An atom without an id gets a fresh one. */
     const insertInline = (id, offset, atom) => {
         id = ref(id);
-        const clean = sanitizeInline(atom);
+        const clean = sanitizeInline({ ...atom, id: atom.id ?? newId('i') });
         if (!contentTarget(id))
             return REFUSED;
         return plan([id], [{ op: 'insertInline', id, offset: clamp(id, offset, 0)[0], atom: clean }]);

package/dist/crdt/doc/delete.d.ts

@@ -12,3 +12,4 @@ export declare const deleteOps: (c: OpsContext) => {
         keepChildren?: boolean;
     }) => Prepared;
 };
+export type DeleteOps = ReturnType<typeof deleteOps>;

package/dist/crdt/doc/funnel.d.ts

@@ -1,13 +1,4 @@
-/**
- * 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 and lineage pass.
- */
-import type { BlockId } from '../placement/model.js';
 import type { BlockAttributionApi } from '../attribution/block.js';
-import type { AttributionActor } from '../attribution/index.js';
-import type { JSONBlock } from '../../utils/json.js';
 import type { EdytorDocConfig, OpResult, Prepared } from './types.js';
 import type { DocBase, DocReads } from './reads.js';
 /**
@@ -20,12 +11,6 @@ import type { DocBase, DocReads } from './reads.js';
 export declare class EdytorDocDisposedError extends Error {
     constructor(service?: string);
 }
-/**
- * The lineage ring depth, validated — `NaN`/`Infinity`/fractional/negative
- * values would silently disable the ring's trim bound. The one check every
- * entry path (facade creation, document attach and reattach) runs.
- */
-export declare const lineageDepthOf: (depth: number | undefined) => number;
 /** What the write funnel writes with: the reads, the attribution writer and the facade's configuration. */
 export type FunnelContext = DocBase & DocReads & {
     BA: BlockAttributionApi;
@@ -35,14 +20,6 @@ export type FunnelContext = DocBase & DocReads & {
 export declare const writeFunnel: (c: FunnelContext) => {
     write: <R>(fn: () => R) => R;
     apply: (p: Prepared) => OpResult;
-    actorOf: () => AttributionActor | undefined;
-    lineageDepth: number;
-    lineagePending: (id: BlockId, force?: boolean) => {
-        a?: string;
-        by: string;
-        t: number;
-        j: JSONBlock;
-    } | undefined;
     /** Disposal is terminal for writes. */
     dispose: () => void;
     disposed: () => boolean;