edytor 1.0.0-rc.3 → 2.0.0

package/dist/crdt/placement/rank.d.ts

@@ -69,11 +69,7 @@ export declare const encodeRank: (segs: readonly RankSeg[]) => string;
  * strictly-between key always exist (modulo the documented VMIN bound).
  */
 export declare const rankBetween: (left: string | undefined, right: string | undefined, clientId: number, rand?: () => number, compact?: boolean) => string;
-/**
- * The digit of the run marker data arrays wrote up to 0.1.0-next.21 (a run
- * of that form is the marker segment, then ranks of the client's own): still
- * read as a run, so what a client inserts there stays in it.
- */
+/** The base of the run band: a run member's digit lies just above it. */
 export declare const RANK_RUN: number;
 /**
  * A rank in `(left, right)` for an insert right after `left` — one rule for

package/dist/crdt/placement/rank.js

@@ -66,6 +66,10 @@ export class RankSpaceExhausted extends Error {
         this.name = 'RankSpaceExhausted';
     }
 }
+/** A rank this module cannot encode, a malformed rank, or bounds out of order (a caller's error). */
+const bad = (what) => {
+    throw new Error(`rank: ${what}`);
+};
 /** `n` (≥ 0) as exactly `width` base-64 places. */
 const places = (n, width) => {
     let out = '';
@@ -74,7 +78,7 @@ const places = (n, width) => {
         n = Math.floor(n / BASE);
     }
     if (n > 0)
-        throw new Error(`rank encode overflow: value exceeds ${width} places`);
+        bad('overflow');
     return out;
 };
 /** How many base-64 places `m` (≥ 1) takes. */
@@ -87,13 +91,13 @@ const width = (m) => {
 /** A signed integer as a self-delimiting, order-preserving string. */
 const encInt = (v) => {
     if (!Number.isSafeInteger(v))
-        throw new Error(`rank encode: bad digit ${v}`);
+        bad('digit');
     if (v === 0)
         return 'H';
     const m = Math.abs(v);
     const k = width(m);
     if (k > MAX_PLACES)
-        throw new Error(`rank encode overflow: ${v}`);
+        bad('overflow');
     if (v > 0)
         return String.fromCharCode(ZERO + k) + places(m, k);
     // Complemented: a greater magnitude sorts first.
@@ -102,16 +106,14 @@ const encInt = (v) => {
 /** The integer at `s[i]`, and where it ends. */
 const decInt = (s, i) => {
     const k = s.charCodeAt(i) - ZERO;
-    if (Number.isNaN(k) || Math.abs(k) > MAX_PLACES)
-        throw new Error(`rank decode: bad length at ${i}`);
     const n = Math.abs(k);
-    if (i + 1 + n > s.length)
-        throw new Error(`rank decode: truncated at ${i}`);
+    if (Number.isNaN(k) || n > MAX_PLACES || i + 1 + n > s.length)
+        bad('malformed');
     let x = 0;
     for (let j = i + 1; j <= i + n; j++) {
         const d = ALPHABET.indexOf(s[j]);
         if (d < 0)
-            throw new Error(`rank decode: bad char ${s[j]}`);
+            bad('malformed');
         x = x * BASE + d;
     }
     const v = k === 0 ? 0 : k > 0 ? x : -(BASE ** n - 1 - x);
@@ -120,7 +122,7 @@ const decInt = (s, i) => {
 /** Decode a rank string into its segment array (`t: Infinity` where a segment has no tie). */
 export const decodeRank = (rank) => {
     if (rank.length === 0)
-        throw new Error('rank decode: empty');
+        bad('malformed');
     const segs = [];
     for (let i = 0; i < rank.length;) {
         const [v, j] = decInt(rank, i);
@@ -131,7 +133,7 @@ export const decodeRank = (rank) => {
         segs.push({ v, t });
     }
     if (segs[segs.length - 1].t === Infinity)
-        throw new Error('rank decode: untied last segment');
+        bad('malformed');
     return segs;
 };
 /** Encode segments back to the persisted string form. */
@@ -139,7 +141,7 @@ export const encodeRank = (segs) => {
     let out = '';
     for (const { v, t } of segs) {
         if (v < RANK_VMIN || v > RANK_VMAX)
-            throw new Error(`rank encode overflow: digit ${v}`);
+            bad('overflow');
         out += encInt(v);
         if (t !== Infinity)
             out += TIE + encInt(t);
@@ -170,9 +172,8 @@ const APPEND_WINDOW = 2 ** 16;
 export const rankBetween = (left, right, clientId, rand = Math.random, compact = true) => {
     const L = left === undefined ? [] : decodeRank(left);
     const R = right === undefined ? [] : decodeRank(right);
-    if (left !== undefined && right !== undefined && left >= right) {
-        throw new Error(`rankBetween: left >= right (${left} !< ${right})`);
-    }
+    if (left !== undefined && right !== undefined && left >= right)
+        bad('left >= right');
     const rightOpen = right === undefined;
     const path = [];
     // `locked`: the emitted prefix already sorts below the right bound.
@@ -209,9 +210,8 @@ export const rankBetween = (left, right, clientId, rand = Math.random, compact =
             // Right bound ended while left continues: valid only when `locked`
             // already holds (an earlier copied segment was < the right's). If not,
             // right is a proper prefix of left — i.e. right < left, caller error.
-            if (!rightOpen && !locked) {
-                throw new Error(`rankBetween: right bound is a prefix of left (right < left)`);
-            }
+            if (!rightOpen && !locked)
+                bad('left >= right');
             // No right bound at this level (open, or `locked` below it): emit
             // within the bounded append window — dense growth, and one more
             // level per exhausted gap, not one per insert (SW12-crdt-2).
@@ -254,16 +254,12 @@ export const rankBetween = (left, right, clientId, rand = Math.random, compact =
         else if (c > 0 && !locked) {
             // Never locked and left's segment exceeds right's at the first
             // differing level → left > right (invalid bounds — caller error).
-            throw new Error(`rankBetween: left >= right at level ${i}`);
+            bad('left >= right');
         }
         path.push(lSeg);
     }
 };
-/**
- * The digit of the run marker data arrays wrote up to 0.1.0-next.21 (a run
- * of that form is the marker segment, then ranks of the client's own): still
- * read as a run, so what a client inserts there stays in it.
- */
+/** The base of the run band: a run member's digit lies just above it. */
 export const RANK_RUN = -(2 ** 30);
 /**
  * A run member's digit lies in `(RANK_RUN, RANK_RUN + RUN_BAND)`: below every
@@ -297,25 +293,25 @@ export const rankAfter = (left, right, client, rand = Math.random) => {
     const top = encodeRank([{ v: RANK_RUN + RUN_BAND, t: 0 }]);
     /**
      * `prefix` and a rank after `after` (`undefined`: the run opens) in the
-     * run: inside the band when `band`. Opening, it takes the band's middle,
-     * or a digit below the run's first member; at the run's end it appends as
-     * an open end does (a window, not half the band); else between the two.
+     * run, inside the band. Opening, it takes the band's middle, or a digit
+     * below the run's first member; at the run's end it appends as an open
+     * end does (a window, not half the band); else between the two.
      */
-    const own = (prefix, after, band) => {
+    const own = (prefix, after) => {
         const tail = (r) => r && r.length > prefix.length && r.startsWith(prefix) ? r.slice(prefix.length) : undefined;
         let next = tail(right);
-        if (band && next !== undefined && next > top)
+        if (next !== undefined && next > top)
             next = undefined;
         let mine;
         if (after === undefined) {
             if (next === undefined)
                 mine = encodeRank([{ v: RUN_START, t: client }]);
-            else if (band && next > bottom)
+            else if (next > bottom)
                 mine = rankBetween(bottom, next, client, rand, false);
             else
                 return plain();
         }
-        else if (next === undefined && band) {
+        else if (next === undefined) {
             const append = rankBetween(after, undefined, client, rand, false);
             mine = append < top ? append : rankBetween(after, top, client, rand, false);
         }
@@ -326,17 +322,11 @@ export const rankAfter = (left, right, client, rand = Math.random) => {
     };
     // A member of the client's run: the next member, inside the band.
     if (last.t === client && inRun(last.v))
-        return own(encodeRank(segs.slice(0, -1)), encodeRank([last]), true);
-    // A run of the earlier form (the marker, then the client's ranks): stays in it.
-    const k = segs.findLastIndex((g) => g.v === RANK_RUN);
-    if (k >= 0 && segs[k].t === client) {
-        const prefix = encodeRank(segs.slice(0, k + 1));
-        return own(prefix, left.length > prefix.length ? left.slice(prefix.length) : undefined, false);
-    }
+        return own(encodeRank(segs.slice(0, -1)), encodeRank([last]));
     // A rank the client made: its run opens right after it. The prefix keeps
     // `left`'s tie: a peer's rank of the same digit and a greater tie
     // then sorts after the whole run, never between `left` and it.
     if (last.t === client)
-        return own(left, undefined, true);
+        return own(left, undefined);
     return plain();
 };

package/dist/crdt/props.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Properties: the deep proxy behind `block.data`, `atom.data`,
+ * `edytor.data` and `document.data` (SyncedStore's feel, one small module).
+ * It is sugar over the one write path: every mutation is a data patch
+ * handed to `write`, which is the `patchData` operation (dispatched on a
+ * view, raw on a bare document).
+ *
+ * A read goes to `read()` every time (the live source), so a reactive
+ * reader of `block.data.title` re-runs when anyone changes it, and a key a
+ * peer deletes is gone. Plain objects read as nested proxies, arrays as
+ * array proxies, everything else as the raw value; a proxy is cached per
+ * path, so its identity is stable. An object or array held in an array
+ * item is that item's (its path names the item by id, from `ids`): it
+ * stays on its item wherever peers move it, so `{#each list as item (item)}`
+ * keeps a row on its item; once the item is removed, its writes are
+ * refused. A key is a path segment as `keySegment` writes it.
+ *
+ * Writes, each the patch of only what it changes (per-leaf storage, so
+ * concurrent edits of other keys and items merge): `obj.key = v`,
+ * `arr[i] = v` and `delete obj.key` patch that path; `push`, `pop`,
+ * `shift`, `unshift`, `splice` and `length` are one `splice` (the items
+ * kept keep their ids), `sort` and `reverse` one `order` (the items move),
+ * `fill` and `copyWithin` writes of the items they change. Assigning a
+ * value equal to the one there writes nothing. `JSON.stringify` and
+ * `$state.snapshot` read plain JSON through it.
+ */
+import { type DataPatch } from './data.js';
+type Json = Record<string, unknown>;
+export declare const propsProxy: <T extends object = Json>(read: () => Json, write: (ops: DataPatch[]) => void, 
+/** The ids of the items of the array at a path (`facade.dataItemIds`). */
+ids?: (path: readonly string[]) => string[]) => T;
+export {};

package/dist/crdt/props.js

@@ -0,0 +1,172 @@
+/**
+ * Properties: the deep proxy behind `block.data`, `atom.data`,
+ * `edytor.data` and `document.data` (SyncedStore's feel, one small module).
+ * It is sugar over the one write path: every mutation is a data patch
+ * handed to `write`, which is the `patchData` operation (dispatched on a
+ * view, raw on a bare document).
+ *
+ * A read goes to `read()` every time (the live source), so a reactive
+ * reader of `block.data.title` re-runs when anyone changes it, and a key a
+ * peer deletes is gone. Plain objects read as nested proxies, arrays as
+ * array proxies, everything else as the raw value; a proxy is cached per
+ * path, so its identity is stable. An object or array held in an array
+ * item is that item's (its path names the item by id, from `ids`): it
+ * stays on its item wherever peers move it, so `{#each list as item (item)}`
+ * keeps a row on its item; once the item is removed, its writes are
+ * refused. A key is a path segment as `keySegment` writes it.
+ *
+ * Writes, each the patch of only what it changes (per-leaf storage, so
+ * concurrent edits of other keys and items merge): `obj.key = v`,
+ * `arr[i] = v` and `delete obj.key` patch that path; `push`, `pop`,
+ * `shift`, `unshift`, `splice` and `length` are one `splice` (the items
+ * kept keep their ids), `sort` and `reverse` one `order` (the items move),
+ * `fill` and `copyWithin` writes of the items they change. Assigning a
+ * value equal to the one there writes nothing. `JSON.stringify` and
+ * `$state.snapshot` read plain JSON through it.
+ */
+import { isObject, keySegment, segmentKey } from './data.js';
+import { jsonEquals } from '../utils/json.js';
+/** A plain JSON copy (proxies included), or `undefined`. */
+const plain = (v) => (v === undefined ? v : JSON.parse(JSON.stringify(v)));
+/** The items of `now` that differ from `was`, as writes of those items. */
+const changed = (_, __, was, now) => now.flatMap((value, i) => JSON.stringify(value) === JSON.stringify(was[i]) ? [] : [{ at: `${i}`, value }]);
+/**
+ * Each array mutator as the patches of the array (or of its items `at`),
+ * from its length `n`, the call's `args`, the array `was` and the result `out`.
+ */
+const MUTATORS = {
+    push: (n, args) => ({ splice: [n, 0, ...args] }),
+    pop: (n) => ({ splice: [Math.max(n - 1, 0), n && 1] }),
+    shift: () => ({ splice: [0, 1] }),
+    unshift: (_, args) => ({ splice: [0, 0, ...args] }),
+    // The start and count `splice` resolved (negative, fractional, past the end).
+    splice: (n, [start, , ...items], _, out) => {
+        const s = Math.trunc(Number(start)) || 0;
+        return { splice: [s < 0 ? Math.max(n + s, 0) : Math.min(s, n), out.length, ...items] };
+    },
+    sort: (n, [compare], was) => ({ order: sorted(n, was, compare) }),
+    reverse: (n) => ({ order: Array.from({ length: n }, (_, i) => n - 1 - i) }),
+    fill: changed,
+    copyWithin: changed
+};
+/** The indexes `Array.prototype.sort` puts `values` in (stable, `undefined` compare: by string). */
+const sorted = (n, values, compare) => {
+    const by = typeof compare === 'function'
+        ? compare
+        : (a, b) => (`${a}` < `${b}` ? -1 : `${a}` > `${b}` ? 1 : 0);
+    return Array.from({ length: n }, (_, i) => i).sort((a, b) => by(values[a], values[b]));
+};
+export const propsProxy = (read, write, 
+/** The ids of the items of the array at a path (`facade.dataItemIds`). */
+ids = () => []) => {
+    const cache = new Map();
+    // Item ids per array path, for the value `read()` last gave.
+    let seen;
+    const known = new Map();
+    const idsOf = (path) => {
+        const now = read();
+        if (now !== seen) {
+            seen = now;
+            known.clear();
+        }
+        const key = JSON.stringify(path);
+        return known.get(key) ?? known.set(key, ids(path)).get(key);
+    };
+    const at = (path) => path.reduce((v, k, n) => /^~[a-z]/.test(k)
+        ? Array.isArray(v)
+            ? v[idsOf(path.slice(0, n)).indexOf(k)]
+            : undefined // its array is gone
+        : v !== null && typeof v === 'object'
+            ? v[segmentKey(k)]
+            : undefined, read());
+    const put = (path, value) => {
+        const next = plain(value);
+        if (jsonEquals(at(path), next))
+            return;
+        write([{ path, ...(next !== undefined && { value: next }) }]);
+    };
+    const wrap = (path, v) => Array.isArray(v) || isObject(v) ? proxy(path, Array.isArray(v)) : v;
+    const proxy = (path, array) => {
+        const key = `${array ? '[' : '{'}${JSON.stringify(path)}`;
+        const cached = cache.get(key);
+        if (cached)
+            return cached;
+        const current = () => {
+            const v = at(path);
+            return array ? (Array.isArray(v) ? v : []) : isObject(v) ? v : {};
+        };
+        /** The path of child `k`: an item by its id, a key as its segment. */
+        const child = (k) => [...path, (array && idsOf(path)[Number(k)]) || keySegment(k)];
+        const items = () => current().map((v, i) => wrap(child(`${i}`), v));
+        const own = (k) => Object.prototype.hasOwnProperty.call(current(), k);
+        const made = new Proxy(array ? [] : {}, {
+            get(target, k) {
+                if (typeof k === 'symbol')
+                    return array && k === Symbol.iterator
+                        ? () => items()[Symbol.iterator]()
+                        : Reflect.get(target, k);
+                if (array && k === 'length')
+                    return current().length;
+                if (own(k))
+                    return wrap(child(k), current()[k]);
+                if (array && Object.hasOwn(MUTATORS, k))
+                    return (...args) => {
+                        const was = plain(current());
+                        const next = [...was];
+                        const fn = Array.prototype[k];
+                        args = args.map((a) => (a !== null && typeof a === 'object' ? plain(a) : a));
+                        const out = fn.apply(next, args);
+                        const ops = [MUTATORS[k](was.length, args, was, out)].flat();
+                        if (!jsonEquals(was, next))
+                            write(ops.map(({ at, ...op }) => ({ ...op, path: at ? [...path, at] : path })));
+                        return out === next ? made : out;
+                    };
+                const method = array ? Array.prototype[k] : undefined;
+                if (typeof method === 'function')
+                    return (...args) => method.apply(items(), args);
+                return Reflect.get(target, k);
+            },
+            set(_, k, value) {
+                if (typeof k === 'symbol')
+                    return false;
+                if (array && k === 'length') {
+                    const n = current().length;
+                    const nulls = Array.from({ length: Math.max(value - n, 0) }, () => null);
+                    write([{ path, splice: [Math.min(value, n), Math.max(n - value, 0), ...nulls] }]);
+                }
+                else
+                    put([...path, keySegment(k)], value);
+                return true;
+            },
+            deleteProperty(_, k) {
+                if (typeof k === 'symbol')
+                    return false;
+                if (own(k))
+                    put([...path, keySegment(k)], undefined);
+                return true;
+            },
+            has: (target, k) => (typeof k === 'string' && own(k)) || Reflect.has(target, k),
+            ownKeys: () => [...Object.keys(current()), ...(array ? ['length'] : [])],
+            getOwnPropertyDescriptor(target, k) {
+                if (array && k === 'length')
+                    return (Reflect.getOwnPropertyDescriptor(target, k) && {
+                        value: current().length,
+                        writable: true,
+                        enumerable: false,
+                        configurable: false
+                    });
+                if (typeof k !== 'string' || !own(k))
+                    return undefined;
+                return {
+                    value: wrap(child(k), current()[k]),
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                };
+            }
+        });
+        cache.set(key, made);
+        return made;
+    };
+    return proxy([], false);
+};

package/dist/crdt/protocol.d.ts

@@ -16,7 +16,7 @@
  *   codec that needs no `Awareness` instance (whose sweep timer blocks
  *   hibernation);
  * - the admission gates (`assertAdmission`, `inspectAdmission`, …) that
- *   diagnostics and migration tooling read;
+ *   diagnostics read;
  * - the raw provider classes behind `createIndexeddbSync` and
  *   `createWebsocketSync` (`IndexeddbPersistence`, `WebsocketProvider`)
  *   and `storeState`.
@@ -24,15 +24,14 @@
  * `pnpm check:worker` keeps this graph Worker-safe; the site's
  * `server/protocol` page documents the contract.
  */
-export { bindCrdt, type Crdt, type EngineApi, type EngineDoc, type EngineNode, type EngineDeepEvent, type EngineTransaction, type EngineItemRef, type YNode, type YItem, type YDoc, type YUndoManager, type YTransaction } from './index.js';
+export { bindCrdt, type Crdt, type EngineApi, type EngineDoc, type EngineNode, type EngineTransaction, type EngineItemRef, type YNode, type YItem, type YDoc, type YUndoManager, type YTransaction } from './index.js';
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
-export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, STORED_GENERATION_RECORD, STORAGE_FORMAT, GenerationMismatchError, readProtocolVersion, type GenerationRecord, type StorageFormat } from './protocols/envelope.js';
-export { PREVIOUS_SCHEMA, isPreviousGenerationRecord } from './migration/generation.js';
+export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion, type GenerationRecord } from './protocols/envelope.js';
 export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, type ChunkReader, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate, type SyncProtocol } from './protocols/sync.js';
 export { messagePermissionDenied, messageReadOnly, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage, type CommentChange, type CommentMessage, type CommentSnapshot, type CommentThread, type ThreadComment } from './protocols/comments.js';
-export { applyAwarenessUpdate, encodeAwarenessUpdate, modifyAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries, type AwarenessEntry } from './protocols/awareness.js';
+export { applyAwarenessUpdate, encodeAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries, type AwarenessEntry } from './protocols/awareness.js';
 export { createDecoder, readVarUint, readVarUint8Array, type Decoder } from 'lib0-v14/decoding';
 export { writeVarUint8Array, type Encoder } from 'lib0-v14/encoding';
 export { assertAdmission, assertSchema, assertUsableDoc, checkSchema, inspectAdmission, isInitialized, registryEmpty, schemaVersion, SchemaMismatchError, UndecodableUpdateError, UnsupportedDocError, type AdmissionResult, type AdmissionVerdict, type SchemaProblem } from './admission.js';

package/dist/crdt/protocol.js

@@ -16,7 +16,7 @@
  *   codec that needs no `Awareness` instance (whose sweep timer blocks
  *   hibernation);
  * - the admission gates (`assertAdmission`, `inspectAdmission`, …) that
- *   diagnostics and migration tooling read;
+ *   diagnostics read;
  * - the raw provider classes behind `createIndexeddbSync` and
  *   `createWebsocketSync` (`IndexeddbPersistence`, `WebsocketProvider`)
  *   and `storeState`.
@@ -28,14 +28,13 @@
 export { bindCrdt } from './index.js';
 // ── The frame contract and the generation ──────────────────────────────
 export { SCHEMA_VERSION, META_KEY } from './edytor-doc.js';
-export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, STORED_GENERATION_RECORD, STORAGE_FORMAT, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
-export { PREVIOUS_SCHEMA, isPreviousGenerationRecord } from './migration/generation.js';
+export { GENERATION, generationWord, frame, PROTOCOL_VERSION, GENERATION_RECORD, GenerationMismatchError, readProtocolVersion } from './protocols/envelope.js';
 // ── Message types, acknowledgements and chunks ─────────────────────────
 export { messageSync, messageAwareness, messageAuth, messageQueryAwareness, messageSaved, messageChunk, messageComments, MAX_FRAME_BYTES, chunkFrame, createChunkReader, ChunkLimitError, CLOSE } from './providers/room.js';
 export { messageYjsSyncStep1, messageYjsSyncStep2, messageYjsUpdate } from './protocols/sync.js';
 export { messagePermissionDenied, messageReadOnly, writePermissionDenied, writeReadOnly } from './protocols/auth.js';
 export { commentsSubscribe, commentsSnapshot, commentsChange, writeCommentsSubscribe, writeCommentsSnapshot, writeCommentsChange, readCommentsMessage } from './protocols/comments.js';
-export { applyAwarenessUpdate, encodeAwarenessUpdate, modifyAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries } from './protocols/awareness.js';
+export { applyAwarenessUpdate, encodeAwarenessUpdate, readAwarenessEntries, writeAwarenessEntries } from './protocols/awareness.js';
 // Minimal wire codec for frame bodies (lib0 — the codec the frames are
 // written with): read the header/subtype/payload, write a payload into a
 // `frame` callback's encoder.

package/dist/crdt/protocols/awareness.d.ts

@@ -32,12 +32,12 @@ type AwarenessEvents = {
  * outdated, and remote states expire after {@link outdatedTimeout}.
  */
 export declare class Awareness extends IsolatedObservable<AwarenessEvents> {
+    #private;
     doc: AwarenessDoc;
     clientID: number;
     /** Maps from client id to client state */
     states: AwarenessStates;
     meta: Map<number, MetaClientState>;
-    private _checkInterval;
     /**
      * Idempotence guard — `destroy()` is reachable twice through the
      * OWNED-doc + OWNED-awareness composition: `EdytorDocument.destroy()`
@@ -59,6 +59,7 @@ export declare class Awareness extends IsolatedObservable<AwarenessEvents> {
  * peers. This change is propagated to remote clients.
  */
 export declare const removeAwarenessStates: (awareness: Awareness, clients: number[], origin: unknown) => void;
+/** The update carrying `clients`' entries of `awareness` (their states in `states`). */
 export declare const encodeAwarenessUpdate: (awareness: Awareness, clients: number[], states?: AwarenessStates) => Uint8Array;
 /** One awareness entry on the wire: a client's clock and state (`null` = removed). */
 export type AwarenessEntry = {
@@ -72,13 +73,8 @@ export type AwarenessEntry = {
  * must not hold timers (a hibernating Durable Object) can track presence.
  */
 export declare const readAwarenessEntries: (update: Uint8Array) => AwarenessEntry[];
-/** Instance-free awareness codec: encode entries as an update (the wire format of {@link encodeAwarenessUpdate}). */
+/** Instance-free awareness codec: encode entries as an update. */
 export declare const writeAwarenessEntries: (entries: readonly AwarenessEntry[]) => Uint8Array;
-/**
- * Modify the content of an awareness update before re-encoding it to an
- * awareness update — e.g. a central server preventing identity hijacking.
- */
-export declare const modifyAwarenessUpdate: (update: Uint8Array, modify: (state: Record<string, unknown> | null) => Record<string, unknown> | null) => Uint8Array;
 /**
  * Apply an encoded awareness update. `origin` is forwarded on the emitted
  * change/update events.

package/dist/crdt/protocols/awareness.js

@@ -14,11 +14,11 @@
  * wire compatibility is not peer compatibility (presence payload versioning
  * is the presence layer's concern).
  */
+import { jsonEquals } from '../../utils/json.js';
 import * as encoding from 'lib0-v14/encoding';
 import * as decoding from 'lib0-v14/decoding';
 import * as time from 'lib0-v14/time';
 import * as math from 'lib0-v14/math';
-import * as f from 'lib0-v14/function';
 import { IsolatedObservable } from './observable.js';
 export const outdatedTimeout = 30000;
 /**
@@ -33,7 +33,7 @@ export class Awareness extends IsolatedObservable {
     /** Maps from client id to client state */
     states;
     meta;
-    _checkInterval;
+    #checkInterval;
     /**
      * Idempotence guard — `destroy()` is reachable twice through the
      * OWNED-doc + OWNED-awareness composition: `EdytorDocument.destroy()`
@@ -49,7 +49,7 @@ export class Awareness extends IsolatedObservable {
         this.clientID = doc.clientID;
         this.states = new Map();
         this.meta = new Map();
-        this._checkInterval = setInterval(() => {
+        this.#checkInterval = setInterval(() => {
             const now = time.getUnixTime();
             const localMeta = this.meta.get(this.clientID);
             if (this.getLocalState() !== null &&
@@ -73,7 +73,7 @@ export class Awareness extends IsolatedObservable {
         // Node returns a `Timeout` (has `unref`), browsers a number — a stale-
         // state sweep must never be the thing keeping a node/SSR process alive
         // (a server-rendered component can't run its client teardown path).
-        this._checkInterval.unref?.();
+        this.#checkInterval.unref?.();
         doc.on('destroy', () => {
             this.destroy();
         });
@@ -87,7 +87,7 @@ export class Awareness extends IsolatedObservable {
         this.emit('destroy', [this]);
         this.setLocalState(null);
         super.destroy();
-        clearInterval(this._checkInterval);
+        clearInterval(this.#checkInterval);
     }
     getLocalState() {
         return this.states.get(this.clientID) || null;
@@ -121,7 +121,7 @@ export class Awareness extends IsolatedObservable {
         }
         else {
             updated.push(clientID);
-            if (!f.equalityDeep(prevState, state)) {
+            if (!jsonEquals(prevState, state)) {
                 filteredUpdated.push(clientID);
             }
         }
@@ -168,20 +168,12 @@ export const removeAwarenessStates = (awareness, clients, origin) => {
         awareness.emit('update', [{ added: [], updated: [], removed }, origin]);
     }
 };
-export const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => {
-    const len = clients.length;
-    const encoder = encoding.createEncoder();
-    encoding.writeVarUint(encoder, len);
-    for (let i = 0; i < len; i++) {
-        const clientID = clients[i];
-        const state = states.get(clientID) || null;
-        const clock = awareness.meta.get(clientID).clock;
-        encoding.writeVarUint(encoder, clientID);
-        encoding.writeVarUint(encoder, clock);
-        encoding.writeVarString(encoder, JSON.stringify(state));
-    }
-    return encoding.toUint8Array(encoder);
-};
+/** The update carrying `clients`' entries of `awareness` (their states in `states`). */
+export const encodeAwarenessUpdate = (awareness, clients, states = awareness.states) => writeAwarenessEntries(clients.map((clientID) => ({
+    clientID,
+    clock: awareness.meta.get(clientID).clock,
+    state: states.get(clientID) || null
+})));
 /**
  * Instance-free awareness codec: decode an update into its entries. Pure —
  * no `Awareness` (whose constructor starts an interval), so a relay that
@@ -195,7 +187,7 @@ export const readAwarenessEntries = (update) => {
         state: JSON.parse(decoding.readVarString(decoder))
     }));
 };
-/** Instance-free awareness codec: encode entries as an update (the wire format of {@link encodeAwarenessUpdate}). */
+/** Instance-free awareness codec: encode entries as an update. */
 export const writeAwarenessEntries = (entries) => encoding.encode((encoder) => {
     encoding.writeVarUint(encoder, entries.length);
     for (const { clientID, clock, state } of entries) {
@@ -204,27 +196,19 @@ export const writeAwarenessEntries = (entries) => encoding.encode((encoder) => {
         encoding.writeVarString(encoder, JSON.stringify(state));
     }
 });
-/**
- * Modify the content of an awareness update before re-encoding it to an
- * awareness update — e.g. a central server preventing identity hijacking.
- */
-export const modifyAwarenessUpdate = (update, modify) => writeAwarenessEntries(readAwarenessEntries(update).map((entry) => ({ ...entry, state: modify(entry.state) })));
 /**
  * Apply an encoded awareness update. `origin` is forwarded on the emitted
  * change/update events.
  */
 export const applyAwarenessUpdate = (awareness, update, origin) => {
-    const decoder = decoding.createDecoder(update);
     const timestamp = time.getUnixTime();
     const added = [];
     const updated = [];
     const filteredUpdated = [];
     const removed = [];
-    const len = decoding.readVarUint(decoder);
-    for (let i = 0; i < len; i++) {
-        const clientID = decoding.readVarUint(decoder);
-        let clock = decoding.readVarUint(decoder);
-        const state = JSON.parse(decoding.readVarString(decoder));
+    for (const entry of readAwarenessEntries(update)) {
+        const { clientID, state } = entry;
+        let { clock } = entry;
         const clientMeta = awareness.meta.get(clientID);
         const prevState = awareness.states.get(clientID);
         const currClock = clientMeta === undefined ? 0 : clientMeta.clock;
@@ -255,7 +239,7 @@ export const applyAwarenessUpdate = (awareness, update, origin) => {
                 removed.push(clientID);
             }
             else if (state !== null) {
-                if (!f.equalityDeep(state, prevState)) {
+                if (!jsonEquals(state, prevState)) {
                     filteredUpdated.push(clientID);
                 }
                 updated.push(clientID);