edytor 3.0.0 → 4.0.0

package/dist/crdt/attribution/attribution.js

@@ -3,13 +3,28 @@ import { blockAttributionOf } from './block.js';
 /** Reserved replicated root for all attribution metadata (`SCHEMA.roots.attribution`). */
 export { ATTRIBUTION_ROOT };
 /**
- * Origin of every metadata write this module performs (`u/`/`c/`
- * dictionary publishes only — per-edit record writes are retired). Kept
- * out of undo capture; tooling classifies it as bookkeeping.
+ * Origin of the profile writes this module performs on its own
+ * (`setProfile`; the binding joins the transaction of the replica's first
+ * write, whatever its origin). Kept out of undo capture; tooling classifies
+ * it as bookkeeping.
  */
 export const ATTRIBUTION_ORIGIN = Symbol('edytor.attribution');
 const ACTOR_PREFIX = 'u/'; // actorId → profile records
 const CLIENT_PREFIX = 'c/'; // replica clientID → actorId records
+/** The actor each attached document's replica writes for (its attribution controller's). */
+const localActors = new WeakMap();
+/**
+ * The actor `doc`'s own replica writes for: its binding (`c/<clientID>`),
+ * else, before its first write, the actor its attribution controller was
+ * attached with (`undefined`: a raw doc). The provider's `saved` reads it.
+ */
+export const writerOf = (doc) => {
+    // A raw doc without the root gets none (reading would create it).
+    const bound = doc.share?.has(ATTRIBUTION_ROOT)
+        ? doc.get(ATTRIBUTION_ROOT).getAttr(`${CLIENT_PREFIX}${doc.clientID}`)
+        : undefined;
+    return typeof bound === 'string' && bound.length > 0 ? bound : localActors.get(doc);
+};
 const sanitizeProfile = (value) => {
     const v = (value ?? undefined);
     const out = {};
@@ -32,14 +47,45 @@ export const profileOf = (actor) => ({
  */
 export const bindAttribution = (_Y) => {
     /**
-     * Attach the actor dictionary to `doc`: publishes this replica's
-     * `c/`+`u/` records and returns the read-through view. No listeners —
-     * ordinary edits perform no attribution work.
+     * Attach the actor dictionary to `doc` and return the read-through view.
+     * This replica's `c/`+`u/` records are written with its first write
+     * (`bind`, below), never at attach: a replica that only reads leaves the
+     * document as it found it.
      */
     const attach = (doc, opts) => {
         const actor = opts.actor;
         const root = doc.get(ATTRIBUTION_ROOT);
         let destroyed = false;
+        /** The client id this replica's binding was written for (`null`: none yet). */
+        let bound = null;
+        /**
+         * The binding, inside the transaction of the replica's first write
+         * under its client id (and again for a new client id, fork patch
+         * YP15): `c/<clientID>`, and `u/<actorId>` when the stored profile
+         * differs (it is not rewritten at every reload). A binding the
+         * document already holds for the id (an attached doc, the room's
+         * rebinding) stands.
+         */
+        const bind = (transaction) => {
+            const tr = transaction;
+            const client = doc.clientID;
+            if (destroyed || bound === client || !tr.local || !tr.insertSet.clients.has(client))
+                return;
+            bound = client;
+            if (root.getAttr(`${CLIENT_PREFIX}${client}`) !== undefined)
+                return;
+            root.setAttr(`${CLIENT_PREFIX}${client}`, actor.id);
+            // A profile this transaction wrote (`setProfile`) stands.
+            const key = `${ACTOR_PREFIX}${actor.id}`;
+            if (tr.changed.get(root)?.has(key))
+                return;
+            const next = profileOf(actor);
+            const stored = sanitizeProfile(root.getAttr(key));
+            if (stored.name !== next.name || stored.color !== next.color)
+                root.setAttr(key, next);
+        };
+        doc.on('beforeCommit', bind);
+        localActors.set(doc, actor.id);
         const setProfile = (profile) => {
             if (destroyed)
                 return;
@@ -47,17 +93,6 @@ export const bindAttribution = (_Y) => {
                 root.setAttr(`${ACTOR_PREFIX}${actor.id}`, sanitizeProfile(profile));
             }, ATTRIBUTION_ORIGIN);
         };
-        doc.transact(() => {
-            root.setAttr(`${CLIENT_PREFIX}${doc.clientID}`, actor.id);
-            // `u/` is rewritten only when the stored profile actually differs —
-            // `c/<clientID>` is always fresh per attach (new clientID) but the
-            // profile item + tombstone shouldn't regrow on every reload.
-            const next = profileOf(actor);
-            const stored = sanitizeProfile(root.getAttr(`${ACTOR_PREFIX}${actor.id}`));
-            if (stored.name !== next.name || stored.color !== next.color) {
-                root.setAttr(`${ACTOR_PREFIX}${actor.id}`, next);
-            }
-        }, ATTRIBUTION_ORIGIN);
         const view = {
             get actors() {
                 const out = new Map();
@@ -73,7 +108,7 @@ export const bindAttribution = (_Y) => {
                 return typeof value === 'string' && value.length > 0 ? value : undefined;
             },
             setProfile,
-            // `b/<id>` records live on the `blockattr` root and `l` on
+            // block records live on the `blockattr` root and `l` on
             // the block node — plain replicated reads, no observer needed.
             block: (blockId) => blockAttributionOf(doc, blockId)
         };
@@ -82,6 +117,9 @@ export const bindAttribution = (_Y) => {
             setProfile,
             destroy: () => {
                 destroyed = true;
+                doc.off('beforeCommit', bind);
+                if (localActors.get(doc) === actor.id)
+                    localActors.delete(doc);
             }
         };
     };

package/dist/crdt/attribution/block.d.ts

@@ -3,7 +3,7 @@
  *
  * One block gets one small replicated record plus one block-node attr:
  *
- * - `b/<blockId>` → nested node on the `blockattr` root
+ * - `<blockId>` → nested node on the `blockattr` root
  *   (`SCHEMA.roots.blockAttribution`) carrying `c` (createdBy actorId)
  *   and `k/<actorId>` → true contributor membership.
  * - `l` (lastChangedBy) lives on the block node itself —
@@ -27,7 +27,7 @@
  * again after its creation was undone, or concurrently by two peers), and a
  * delayed remote write always addresses the incarnation its author saw.
  * Every block node carries the replicated nonce `n` of its incarnation;
- * every `b/<id>` record is stamped (`i`) with the nonce it belongs
+ * every record is stamped (`i`) with the nonce it belongs
  * to, and `ensureRecord` swaps in a FRESH record whenever the live node's
  * nonce doesn't match — a late write to a dead incarnation lands on an
  * orphaned record the recreated block never reads. An undo/redo copy of the
@@ -48,7 +48,7 @@
  * - Semantic no-ops (same-value type/data, empty ranges, pure moves)
  *   are suppressed by the CALLERS: ops stamp only after a real write.
  *
- * Known residual: `b/<id>` nodes are LWW map entries — concurrent FIRST
+ * Known residual: record nodes are LWW map entries — concurrent FIRST
  * touches of a record-less block (foreign/migrated docs may lack records)
  * can lose one contributor add. Convergent; heals on the next touch.
  *

package/dist/crdt/attribution/block.js

@@ -1,17 +1,16 @@
 import { REGISTRY_KEY } from '../placement/model.js';
-import { BLOCK_ATTR_ROOT, isNodeLike, LAST_CHANGED_ATTR, NONCE, REC_PREFIX } from '../schema.js';
+import { BLOCK_ATTR_ROOT, isNodeLike, LAST_CHANGED_ATTR, NONCE } from '../schema.js';
 import { attrItems, newNode as makeNode } from '../structs.js';
-// `BLOCK_ATTR_ROOT`/`LAST_CHANGED_ATTR`/`REC_PREFIX` live in the shared
+// `BLOCK_ATTR_ROOT`/`LAST_CHANGED_ATTR` live in the shared
 // `../schema.js` leaf — re-exported so existing import sites stay.
 export { BLOCK_ATTR_ROOT, LAST_CHANGED_ATTR };
 const REC_NODE = 'brec';
 const CREATED_KEY = 'c';
 const CONTRIBUTOR_PREFIX = 'k/';
-/** Incarnation stamp on a `b/` record: the nonce `n` of the node it belongs to. */
+/** Incarnation stamp on a record: the nonce `n` of the node it belongs to. */
 const INCARNATION_KEY = 'i';
-const recKey = (id) => `${REC_PREFIX}${id}`;
 const recordOf = (doc, id) => {
-    const v = doc.get(BLOCK_ATTR_ROOT).getAttr(recKey(id));
+    const v = doc.get(BLOCK_ATTR_ROOT).getAttr(id);
     return isNodeLike(v) ? v : null;
 };
 const blockNodeOf = (doc, id) => {
@@ -19,7 +18,7 @@ const blockNodeOf = (doc, id) => {
     return isNodeLike(v) ? v : null;
 };
 /**
- * Reads resolve whatever record node the `b/<id>` attr currently elects.
+ * Reads resolve whatever record node the block's attr currently elects.
  * Isolation is enforced on the WRITE side — `ensureRecord` swaps a fresh
  * record in when the attr winner's incarnation stamp doesn't match the live
  * block node's nonce — and the attr winner is already convergent.
@@ -74,7 +73,7 @@ export const blockAttributionOf = (doc, id) => {
 export const bindBlockAttribution = (Y) => {
     const newNode = (name) => makeNode(Y, name);
     /**
-     * Get-or-create the `b/<id>` record for `node`'s incarnation (its nonce).
+     * Get-or-create the record for `node`'s incarnation (its nonce).
      * A record stamped for another incarnation is dead state — a fresh record
      * replaces it as the attr winner (the orphan stays readable only as the
      * last-incarnation fallback). `node` defaults to the id's current registry
@@ -87,7 +86,7 @@ export const bindBlockAttribution = (Y) => {
             return existing;
         }
         const rec = newNode(REC_NODE);
-        doc.get(BLOCK_ATTR_ROOT).setAttr(recKey(id), rec);
+        doc.get(BLOCK_ATTR_ROOT).setAttr(id, rec);
         if (n !== undefined)
             rec.setAttr(INCARNATION_KEY, n);
         return rec;

package/dist/crdt/attribution/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Public surface of the attribution service. `block.ts` holds the
- * compact per-block records (`b/<blockId>` + the block-node `l` attr)
+ * compact per-block records (`blockattr` `<blockId>` + the block-node `l` attr)
  * written inside the owning facade op's transaction. `attribution.ts`
  * holds the actor dictionary (`u/`/`c/`) plus inert reads over
  * pre-existing `a/` per-edit records written by retired builds.

package/dist/crdt/attribution/index.js

@@ -1,6 +1,6 @@
 /**
  * Public surface of the attribution service. `block.ts` holds the
- * compact per-block records (`b/<blockId>` + the block-node `l` attr)
+ * compact per-block records (`blockattr` `<blockId>` + the block-node `l` attr)
  * written inside the owning facade op's transaction. `attribution.ts`
  * holds the actor dictionary (`u/`/`c/`) plus inert reads over
  * pre-existing `a/` per-edit records written by retired builds.

package/dist/crdt/data.d.ts

@@ -5,27 +5,30 @@
  * leaf's path as an RFC 6901 pointer without its leading `/` (`~` → `~0`,
  * `/` → `~1`). A leaf is a primitive, `null` or an empty container (`{}`,
  * `[]`), so an emptied one persists. An array is its `[]` leaf plus its
- * items, as `Y.Array` holds them: item `id` keeps its value under the
- * segment `~id` (a primitive at it, an object's or array's leaves under it)
- * and its place in the rank `~id#` (`placement/rank.ts`), a move's in
- * `~id>`; `~` and a letter is no escape, so no key reads as an item. Each
- * attr is a map entry, so different keys and different items merge, one
- * key is last writer wins, and an item lives while its first rank does: a
- * delete removes its ranks and leaves, so a concurrent edit inside it or
- * move of it leaves orphans the read skips. A path names an item by index
- * or by id, so a held item is reached wherever peers moved it; an id that
- * names no live item (removed, or its array gone) refuses the patch, so
- * nothing is written under a dead item. A key starting with `~` is `~0…`
- * in a path (`keySegment`).
+ * items: item `id` keeps its value under the segment `~id` (a primitive at
+ * it, an object's or array's leaves under it), and its existence and place
+ * are its SLOT `{ p, i }` in the owner's one order sequence — the node's
+ * list part (`placement/slots.ts`, fork patch YP22): an item lives while a
+ * live slot of its id does (the first live slot of an id counts: two peers
+ * adopting one array write two), the order is the sequence's, and a move is
+ * a move record there. `~` and a letter is no escape, so no key reads as an
+ * item. Each leaf is a map entry, so different keys and different items
+ * merge and one key is last writer wins; a delete removes the item's slots
+ * and leaves, so a concurrent edit inside it or move of it leaves orphans
+ * the read skips. A path names an item by index or by id, so a held item
+ * is reached wherever peers moved it; an id that names no live item
+ * refuses the patch, so nothing is written under a dead item. A key
+ * starting with `~` is `~0…` in a path (`keySegment`).
  *
  * 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. 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.
+ * array (in slot order), 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. 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 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, and the first write through it gives every
+ * item its slot.
  */
 import type { EngineNode } from './engine-api.js';
 type JsonObj = Record<string, unknown>;
@@ -43,6 +46,28 @@ export type DataPatch = {
 };
 /** An attr write a patch plans: the key and its value, `undefined` to delete it. */
 export type LeafWrite = readonly [key: string, value: unknown];
+/**
+ * A sequence write a patch plans (`placement/slots.ts`): new items' slots
+ * after item `after` (`null`: first) of the array at `path`, a move of items
+ * there, or the removal of items' slots.
+ */
+export type SlotWrite = {
+    seq: 'insert';
+    path: string;
+    after: string | null;
+    ids: string[];
+} | {
+    seq: 'move';
+    path: string;
+    after: string | null;
+    ids: string[];
+} | {
+    seq: 'remove';
+    path: string;
+    ids: string[];
+};
+/** One write a data patch plans. */
+export type DataWrite = LeafWrite | SlotWrite;
 export declare const isObject: (v: unknown) => v is JsonObj;
 /**
  * Key `k` as a patch path segment: a leading `~` as `~0` (RFC 6901), so a
@@ -62,8 +87,8 @@ export declare const segmentKey: (s: string) => string;
  * `arrange` pairs those items by position.
  */
 export declare const common: (a: readonly string[], b: readonly string[]) => [number, number][];
-/** A new node's data, as leaves. */
-export declare const dataLeaves: (data: unknown) => Map<string, unknown>;
+/** A new node's data, as the writes that give it (its leaves and its arrays' slots). */
+export declare const dataWrites: (data: unknown) => DataWrite[];
 /** A path of the data as a leaf key (`d/` and its pointer). */
 export declare const leafKey: (path: readonly string[]) => string;
 /** `node`'s data (`undefined` when it has none). */
@@ -76,7 +101,7 @@ export declare const itemIds: (node: EngineNode, path: readonly string[]) => str
 /**
  * `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.
+ * makes has no slot 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[]) => {
@@ -86,14 +111,20 @@ export declare const previewData: (node: EngineNode | undefined, patches: readon
 /** `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. An
- * atomic path is written as one leaf and the leaves under it are deleted.
- * An unchanged value writes nothing.
+ * The writes that give `node` the data `patches` make of its own (new
+ * items get ids from `rand`), 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, and only the slots of
+ * the items it makes, moves or removes. An atomic path is written as one
+ * leaf and the leaves and slots under it are dropped. An unchanged value
+ * writes nothing.
+ */
+export declare const patchWrites: (node: EngineNode, patches: readonly DataPatch[], client?: number, rand?: () => number, atomic?: readonly string[]) => DataWrite[] | null;
+/**
+ * Write `writes` on `node`: its attrs, and its arrays' slots in its one
+ * sequence (`placement/slots.ts`). On a detached node (a block or atom being
+ * created) the slots are appended in order; on an integrated one each write
+ * goes after the item it names, read from the sequence as it stands.
  */
-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). */
-export declare const writeLeaves: (node: EngineNode, writes: Iterable<LeafWrite>) => void;
+export declare const writeData: (node: EngineNode, writes: Iterable<DataWrite>) => void;
 export {};