@grafloria/element 0.3.17 → 0.3.19

package/src/libs/engine/src/sync/awareness.js

@@ -0,0 +1,221 @@
+"use strict";
+// Wave 9 — Card 5, part B: AWARENESS. Who else is here, where are they looking, what
+// have they got selected.
+//
+// ---------------------------------------------------------------------------
+// AWARENESS IS NOT A DOCUMENT EDIT, AND THE DAY IT BECOMES ONE IS THE DAY THE
+// DOCUMENT IS RUINED
+// ---------------------------------------------------------------------------
+//
+// It is genuinely tempting to reuse the op log. It is right there; it already has
+// ordering, delivery, de-duplication and catch-up; a cursor is "just" a property of a
+// peer. Do it and here is what you have built:
+//
+//   • A 60Hz write stream into an APPEND-ONLY, PERSISTED, REPLAYABLE log. Ten minutes of
+//     four people moving their mice is ~150,000 permanent entries in a document whose
+//     actual content is forty nodes.
+//   • A Lamport clock in the millions, because every mouse sample ticks it — so every
+//     real edit now sorts against a clock dominated by mouse jitter.
+//   • "Replay the document" now literally re-enacts someone's mouse movements from last
+//     March, and the byte-identical-replay contract has to reproduce them exactly.
+//   • And a cursor that has to be UNDONE, because it is in the undo stack.
+//
+// None of that is recoverable later: the log is append-only, so a bad decision here is
+// permanent by construction. Hence: separate message kind, separate store, separate
+// lifecycle. This class cannot reach the op log — it holds no Replica and is handed no
+// log — and there is a test that drives a thousand cursor moves through a live adapter
+// and asserts the log is still EMPTY.
+//
+// ---------------------------------------------------------------------------
+// THE LIFECYCLE, WHICH IS THE OPPOSITE OF THE LOG'S IN EVERY RESPECT
+// ---------------------------------------------------------------------------
+//
+//   log:        durable · causally ordered · de-duplicated · every op matters · forever
+//   awareness:  ephemeral · LWW per peer · lossy on purpose · only the LATEST matters ·
+//               expires
+//
+// LOSSY ON PURPOSE is the load-bearing one. Dropping a cursor sample costs nothing — the
+// next is 16ms behind it. So awareness needs no retransmission, no acknowledgement, no
+// catch-up and no buffering, and building any of those would be pure waste.
+//
+// EXPIRES is the other. A tab that crashes sends no `bye`, and a peer whose ghost cursor
+// hovers over the canvas forever is worse than no cursor at all. So every peer's state
+// carries a `lastSeen`, a heartbeat refreshes it, and anything stale is dropped. The
+// explicit `bye` is a fast path, never the guarantee.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Awareness = void 0;
+/**
+ * The presence store for one peer: our own state, and everyone else's.
+ *
+ * Deliberately transport-free. `SyncAdapter` wires it to a channel; a test wires it to
+ * nothing and drives it directly. It never sees an Op, a Replica or an OpLog, and that
+ * is not an accident — it is the containment.
+ *
+ * ---------------------------------------------------------------------------
+ * WHY `lastSeen` IS A WALL CLOCK WHEN THE LOG WENT TO SUCH LENGTHS TO AVOID ONE
+ * ---------------------------------------------------------------------------
+ * Because the question is different. The log asks "did A happen before B?", which a wall
+ * clock cannot answer across machines (they disagree, and they run backwards). Expiry
+ * asks "has it been 15 seconds since I last heard from Bob?" — measured entirely on MY
+ * clock, about MY receipts, comparing my own `now()` to my own earlier `now()`. Bob's
+ * clock is never consulted, so its wrongness cannot infect anything. Using a Lamport
+ * clock for a TIMEOUT would be the actual mistake: it has no relationship to seconds.
+ */
+class Awareness {
+    constructor(options) {
+        var _a, _b;
+        this.options = options;
+        this.peers = new Map();
+        this.local = {};
+        this.seq = 0;
+        this.listeners = new Set();
+        this.timeoutMs = (_a = options.timeoutMs) !== null && _a !== void 0 ? _a : 15000;
+        this.nowFn = (_b = options.now) !== null && _b !== void 0 ? _b : Date.now;
+    }
+    get actor() {
+        return this.options.actor;
+    }
+    /** Our own published state, and the sequence a peer will LWW it by. */
+    getLocalState() {
+        return this.local;
+    }
+    get localSeq() {
+        return this.seq;
+    }
+    /**
+     * Merge a patch into our own state and bump the sequence.
+     *
+     * Returns false when nothing actually changed — a mouse that has not moved must not
+     * burn a sequence number, wake the throttle, or send a message. (A `mousemove` fires
+     * on sub-pixel jitter and on scroll; without this guard an idle user with a resting
+     * hand is a 60Hz broadcaster.)
+     */
+    setLocalState(patch) {
+        let changed = false;
+        const next = Object.assign({}, this.local);
+        for (const [k, v] of Object.entries(patch)) {
+            if (!shallowEqual(next[k], v)) {
+                next[k] = v;
+                changed = true;
+            }
+        }
+        if (!changed)
+            return false;
+        this.local = next;
+        this.seq++;
+        return true;
+    }
+    /**
+     * Take a peer's published state.
+     *
+     * `seq` is the whole reason a reordered transport does not make a cursor jump
+     * backwards: a sample older than the one we already hold is REFUSED, exactly as the LWW
+     * gate refuses a superseded op. Same idea, one scope down, and no shared machinery
+     * because the lifecycles have nothing in common.
+     */
+    applyRemote(actor, state, seq) {
+        if (actor === this.options.actor)
+            return null; // our own echo; ignore
+        if (state === null) {
+            return this.remove(actor);
+        }
+        const existing = this.peers.get(actor);
+        if (existing && seq < existing.seq)
+            return null; // a stale sample overtook a fresh one
+        const now = this.nowFn();
+        if (existing) {
+            // Even a same-seq message refreshes lastSeen: that is what a HEARTBEAT is — "still
+            // here, nothing new". Without this an idle-but-present peer times out and their
+            // cursor vanishes while they are staring at it.
+            existing.lastSeen = now;
+            if (seq === existing.seq)
+                return null;
+            existing.seq = seq;
+            existing.state = state;
+            this.emit({ added: [], updated: [actor], removed: [] });
+            return { added: [], updated: [actor], removed: [] };
+        }
+        this.peers.set(actor, { actor, state, lastSeen: now, seq });
+        const change = { added: [actor], updated: [], removed: [] };
+        this.emit(change);
+        return change;
+    }
+    /** An explicit `bye`, or a transport that told us the peer is gone. */
+    remove(actor) {
+        if (!this.peers.delete(actor))
+            return null;
+        const change = { added: [], updated: [], removed: [actor] };
+        this.emit(change);
+        return change;
+    }
+    /**
+     * Drop peers we have not heard from inside the timeout.
+     *
+     * THE GUARANTEE, as opposed to `bye`, which is merely the optimisation. A crashed tab,
+     * a closed laptop, a killed process and a severed cable all send no `bye` whatsoever,
+     * and every one of them must eventually stop showing a cursor.
+     */
+    prune() {
+        const cutoff = this.nowFn() - this.timeoutMs;
+        const removed = [];
+        for (const [actor, p] of this.peers) {
+            if (p.lastSeen < cutoff) {
+                this.peers.delete(actor);
+                removed.push(actor);
+            }
+        }
+        if (removed.length === 0)
+            return null;
+        const change = { added: [], updated: [], removed };
+        this.emit(change);
+        return change;
+    }
+    /** Everyone but us. */
+    getPeers() {
+        return [...this.peers.values()];
+    }
+    getPeer(actor) {
+        return this.peers.get(actor);
+    }
+    get peerCount() {
+        return this.peers.size;
+    }
+    /** Everyone is gone (we disconnected — we can no longer vouch for anyone). */
+    clearPeers() {
+        if (this.peers.size === 0)
+            return null;
+        const removed = [...this.peers.keys()];
+        this.peers.clear();
+        const change = { added: [], updated: [], removed };
+        this.emit(change);
+        return change;
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit(change) {
+        for (const l of [...this.listeners])
+            l(change);
+    }
+}
+exports.Awareness = Awareness;
+/** Enough to tell "the cursor moved" from "the cursor did not". Selections are arrays. */
+function shallowEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null || b === null || a === undefined || b === undefined)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => v === b[i]);
+    }
+    if (typeof a === 'object' && typeof b === 'object') {
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        return ka.every((k) => a[k] === b[k]);
+    }
+    return false;
+}
+//# sourceMappingURL=awareness.js.map

package/src/libs/engine/src/sync/awareness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"awareness.js","sourceRoot":"","sources":["../../../../../../engine/src/sync/awareness.ts"],"names":[],"mappings":"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"}

package/src/libs/engine/src/sync/batcher.d.ts

@@ -0,0 +1,84 @@
+import type { Op } from '../collab/op';
+/**
+ * Drop every `set` that a later `set` in the same batch overwrites.
+ *
+ * A stable filter: elements are removed, never reordered. Exported because it is worth
+ * testing on its own, and because it is the part that is easy to get wrong.
+ *
+ * RETURNS THE DROPPED OPS TOO, AND THAT IS NOT A CONVENIENCE — IT IS LOAD-BEARING.
+ *
+ * An op that is coalesced away is an op the sender HAS (it is in its log) and the receiver
+ * will NEVER have. Anti-entropy compares frontiers derived from logs, so unless the sender
+ * knows exactly which ops it deliberately withheld, its frontier says "I hold 20 ops" while
+ * the peer holds 1 — a gap indistinguishable from a lost packet, which triggers a full
+ * history REPAIR on the next sync round. And the round after. Forever, because the peer can
+ * never obtain ops that will never be sent.
+ *
+ * That is a silent O(history) resend after EVERY DRAG — the most common interaction there
+ * is. See `SyncAdapter.suppressed`.
+ */
+export declare function coalesce(ops: readonly Op[]): {
+    kept: Op[];
+    dropped: Op[];
+};
+export interface OpBatcherOptions {
+    /**
+     * Where a flushed batch goes. Never called with an empty `kept`.
+     *
+     * `dropped` are the ops COALESCED AWAY — ops the sender holds and the receiver will never
+     * see. The adapter must record them, or its frontier will advertise ops it is never going
+     * to send and every anti-entropy round will try to "repair" the gap. See `coalesce()`.
+     */
+    onFlush: (kept: Op[], dropped: Op[]) => void;
+    /**
+     * How long to accumulate, in ms. 16 ≈ one frame: a drag's pointermoves collapse into
+     * one message per frame, which is the point.
+     *
+     * 0 means "flush on the next macrotask", which for a drag means one message per
+     * pointermove — i.e. no batching at all. It is a legal setting (a test may want it) and
+     * a bad default.
+     */
+    intervalMs?: number;
+    /**
+     * Flush immediately once the queue reaches this many ops, regardless of the timer.
+     * Backpressure: a scripted bulk import can emit ten thousand ops inside one tick, and
+     * an unbounded queue would hand the transport a single ten-megabyte frame.
+     */
+    maxBatch?: number;
+    /** Injectable timer, so tests are deterministic and Node/browser both work. */
+    setTimer?: (cb: () => void, ms: number) => unknown;
+    clearTimer?: (handle: unknown) => void;
+}
+/**
+ * Accumulates local ops and flushes them as one coalesced, correctly-ordered batch.
+ */
+export declare class OpBatcher {
+    private readonly options;
+    private queue;
+    private timer;
+    private disposed;
+    private readonly intervalMs;
+    private readonly maxBatch;
+    private readonly setTimer;
+    private readonly clearTimer;
+    /** Ops that went in. */
+    queued: number;
+    /** Ops that went out. `queued - sent` is what coalescing saved. */
+    sent: number;
+    /** Flushes performed. */
+    batches: number;
+    constructor(options: OpBatcherOptions);
+    get size(): number;
+    push(op: Op): void;
+    /** Send whatever is queued, right now. Idempotent, and a no-op when empty. */
+    flush(): void;
+    /**
+     * Drop the queue WITHOUT sending.
+     *
+     * Used on disconnect, and it is safe for exactly one reason: the ops are already in the
+     * local log, so the peer will get them from the next anti-entropy round. If they were
+     * not, this would be a silent data-loss hatch.
+     */
+    discard(): void;
+    dispose(): void;
+}

package/src/libs/engine/src/sync/batcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batcher.js","sourceRoot":"","sources":["../../../../../../engine/src/sync/batcher.ts"],"names":[],"mappings":"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"}

package/src/libs/engine/src/sync/causal-buffer.d.ts

@@ -0,0 +1,81 @@
+import type { DiagramModel } from '../models/DiagramModel';
+import { type Op } from '../collab/op';
+export interface CausalBufferOptions {
+    /**
+     * Hard cap on held ops. A malicious or badly broken peer must not be able to make us
+     * buffer without limit; past the cap we release the oldest held op anyway (it will
+     * apply as a no-op and be logged, which is exactly what would have happened before this
+     * file existed — degraded, but bounded, and counted so it is visible).
+     */
+    maxPending?: number;
+}
+/** Where an op sits: released to the replica, or waiting on a dependency. */
+export interface CausalSplit {
+    /** Ready NOW, in total order. Hand straight to `Replica.receive()`. */
+    ready: Op[];
+    /** Newly held this round (diagnostics). */
+    held: number;
+}
+/**
+ * Holds ops whose entity has not been added yet, and releases them the instant it is.
+ *
+ * Sits BETWEEN the transport and the Replica. Nothing it holds has touched the log, the
+ * clock or the LWW registry — which is the whole point: an op the replica has never seen
+ * is an op that can still be applied later.
+ */
+export declare class CausalBuffer {
+    private readonly diagram;
+    /** Entity ids we have ever seen an `add` for — including ones since deleted. */
+    private readonly known;
+    /** Held ops, keyed by the entity id they are waiting on. */
+    private readonly waiting;
+    /** opIds already held — a duplicate delivery must not double the buffer. */
+    private readonly heldIds;
+    private readonly maxPending;
+    /** Ops force-released because the buffer was full. Should be 0. Watch it. */
+    overflowed: number;
+    constructor(diagram: DiagramModel, options?: CausalBufferOptions);
+    get pendingCount(): number;
+    /**
+     * WE created an entity. Record it — the transport will never tell us about it.
+     *
+     * THE FUZZ FOUND THIS ONE, AND IT IS A PERMANENT HANG, NOT A HICCUP.
+     *
+     * `known` was fed from exactly two places: entities on the diagram at construction, and
+     * `add` ops that arrived from PEERS. A node the local user creates during the session is
+     * in NEITHER — so as far as the buffer was concerned, an entity this peer invented did
+     * not exist.
+     *
+     * Now watch a peer edit it. Bob creates node X. Alice learns about it, drags it, and
+     * sends `set(X, position)`. It arrives at Bob, whose buffer asks "have I seen an `add`
+     * for X?", answers NO, and holds it — waiting for an `add(X)` that is never coming, from
+     * anyone, ever. It cannot come: the only `add(X)` in existence is Bob's OWN, it is
+     * already in Bob's log, and Alice's anti-entropy correctly concludes that Bob already
+     * has it and never echoes it back.
+     *
+     * So Bob's node freezes wherever it was when he made it, Alice watches it move, and the
+     * two documents differ forever — over the single most ordinary interaction in a
+     * collaborative editor: one person moving another person's node. On a healthy transport
+     * it never fires (the `set` cannot overtake an `add` that was never sent), which is
+     * exactly why it took a reordering channel to find it.
+     *
+     * No drain is needed. A peer can only `set` an entity it has learned about, which means
+     * our `add` had already reached it — so nothing can be waiting on an id at the moment we
+     * create it. The registration alone closes the hole.
+     */
+    noteLocal(op: Op): void;
+    /**
+     * Split an arriving batch into what can be applied now and what must wait — and fold in
+     * anything that was already waiting and has just become releasable.
+     */
+    admit(incoming: readonly Op[]): CausalSplit;
+    /** Everything we are still holding — for a status panel, and for the tests. */
+    pending(): Op[];
+    private isReady;
+    /**
+     * Emit a ready op, then drain anything that was waiting on it. Recursive in spirit
+     * (a released `add` can free `set`s, and nothing else) but flat in code.
+     */
+    private release;
+    private hold;
+}

package/src/libs/engine/src/sync/causal-buffer.js

@@ -0,0 +1,199 @@
+"use strict";
+// Wave 9 — Card 5: CAUSAL READINESS.
+//
+// This file closes a hole that Card 0 wrote down and explicitly left open:
+//
+//     "CAUSAL READINESS. An op for an entity that has not arrived yet is currently
+//      DROPPED (applyOp returns false). Under a reliable, ordered transport that cannot
+//      happen; under an unreliable one it can, and the op must be BUFFERED until its
+//      dependency lands. Also Card 4/5."                       — op-log.ts, Card 0
+//
+// It is Card 5's, and it is worse than "the op is dropped", because of where the drop
+// happens. Follow one reordered packet through `Replica.receive()`:
+//
+//     set(node n7, position, {x:900})   arrives BEFORE   add(node n7)
+//
+//   1. `log.appendAll()` accepts the `set`. It is new. The log now REMEMBERS it.
+//   2. The LWW gate admits it and STAMPS the register — n7.position now belongs to that
+//      write, at that clock.
+//   3. `applyOp` looks for node n7, does not find it, and returns false. Nothing happens.
+//
+// Now the `add` arrives and the node appears — at its ORIGINAL position, because the
+// `set` that was supposed to move it evaporated in step 3. And it can never be recovered:
+//
+//   • the LOG has already seen it, so a re-delivery is de-duplicated to nothing;
+//   • the LWW REGISTER already belongs to it, so even a re-send would now be REFUSED as
+//     superseded — by itself.
+//
+// One reordered packet, permanent divergence, and every layer below behaves exactly as
+// designed. That is what makes it nasty: there is no bug in the log, no bug in the gate,
+// and no bug in the reducer. The bug is that nothing owns the ORDER.
+//
+// So this does. An op is held until the entity it talks about has been ADDED, and it
+// never reaches the replica until then — no log entry, no stamp, no silent no-op.
+//
+// ---------------------------------------------------------------------------
+// "SEEN", NOT "PRESENT" — and the difference is a hang
+// ---------------------------------------------------------------------------
+//
+// The readiness test is "have we ever seen an `add` for this id", NOT "does this entity
+// exist right now". They differ for a DELETED entity, and getting it wrong is a deadlock:
+// a `set` on a node that a peer legitimately deleted would wait for an `add` that is
+// never coming, sit in the buffer forever, and — because it never reaches the log — get
+// re-requested by every anti-entropy round for the rest of the session. An op for a
+// deleted entity is released immediately and applies as the harmless no-op it is.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CausalBuffer = void 0;
+const op_1 = require("../collab/op");
+/**
+ * Holds ops whose entity has not been added yet, and releases them the instant it is.
+ *
+ * Sits BETWEEN the transport and the Replica. Nothing it holds has touched the log, the
+ * clock or the LWW registry — which is the whole point: an op the replica has never seen
+ * is an op that can still be applied later.
+ */
+class CausalBuffer {
+    constructor(diagram, options = {}) {
+        var _a;
+        this.diagram = diagram;
+        /** Entity ids we have ever seen an `add` for — including ones since deleted. */
+        this.known = new Set();
+        /** Held ops, keyed by the entity id they are waiting on. */
+        this.waiting = new Map();
+        /** opIds already held — a duplicate delivery must not double the buffer. */
+        this.heldIds = new Set();
+        /** Ops force-released because the buffer was full. Should be 0. Watch it. */
+        this.overflowed = 0;
+        this.maxPending = (_a = options.maxPending) !== null && _a !== void 0 ? _a : 10000;
+        // Anything already on the diagram when we start collaborating was, as far as this
+        // peer is concerned, added. Without this, the very first `set` on a pre-existing node
+        // would be held forever waiting for an `add` that happened before the session began.
+        for (const n of diagram.getNodes())
+            this.known.add(n.id);
+        for (const l of diagram.getLinks())
+            this.known.add(l.id);
+        for (const g of diagram.getGroups())
+            this.known.add(g.id);
+    }
+    get pendingCount() {
+        return this.heldIds.size;
+    }
+    /**
+     * WE created an entity. Record it — the transport will never tell us about it.
+     *
+     * THE FUZZ FOUND THIS ONE, AND IT IS A PERMANENT HANG, NOT A HICCUP.
+     *
+     * `known` was fed from exactly two places: entities on the diagram at construction, and
+     * `add` ops that arrived from PEERS. A node the local user creates during the session is
+     * in NEITHER — so as far as the buffer was concerned, an entity this peer invented did
+     * not exist.
+     *
+     * Now watch a peer edit it. Bob creates node X. Alice learns about it, drags it, and
+     * sends `set(X, position)`. It arrives at Bob, whose buffer asks "have I seen an `add`
+     * for X?", answers NO, and holds it — waiting for an `add(X)` that is never coming, from
+     * anyone, ever. It cannot come: the only `add(X)` in existence is Bob's OWN, it is
+     * already in Bob's log, and Alice's anti-entropy correctly concludes that Bob already
+     * has it and never echoes it back.
+     *
+     * So Bob's node freezes wherever it was when he made it, Alice watches it move, and the
+     * two documents differ forever — over the single most ordinary interaction in a
+     * collaborative editor: one person moving another person's node. On a healthy transport
+     * it never fires (the `set` cannot overtake an `add` that was never sent), which is
+     * exactly why it took a reordering channel to find it.
+     *
+     * No drain is needed. A peer can only `set` an entity it has learned about, which means
+     * our `add` had already reached it — so nothing can be waiting on an id at the moment we
+     * create it. The registration alone closes the hole.
+     */
+    noteLocal(op) {
+        if (op.op === 'add')
+            this.known.add(op.id);
+    }
+    /**
+     * Split an arriving batch into what can be applied now and what must wait — and fold in
+     * anything that was already waiting and has just become releasable.
+     */
+    admit(incoming) {
+        const ready = [];
+        let held = 0;
+        // Total order first. An `add` and the `set`s that depend on it routinely arrive in
+        // the SAME batch (a catch-up delta is exactly that), and sorting means the add is
+        // seen first and its dependants never touch the buffer at all.
+        for (const op of [...incoming].sort(op_1.compareOps)) {
+            if (this.isReady(op)) {
+                this.release(op, ready);
+                continue;
+            }
+            switch (this.hold(op)) {
+                case 'held':
+                    held++;
+                    break;
+                case 'overflow':
+                    // Bounded degradation: the buffer is full, so we stop protecting this op and
+                    // let it through as the no-op it will be. That is a genuine (if remote) lost
+                    // edit — hence `overflowed`, which is counted rather than swallowed.
+                    ready.push(op);
+                    break;
+                case 'duplicate':
+                    break;
+            }
+        }
+        return { ready, held };
+    }
+    /** Everything we are still holding — for a status panel, and for the tests. */
+    pending() {
+        const out = [];
+        for (const list of this.waiting.values())
+            out.push(...list);
+        return out.sort(op_1.compareOps);
+    }
+    // -------------------------------------------------------------------------
+    isReady(op) {
+        // An `add` carries its own entity. A diagram-level `set` has no entity to wait on.
+        if (op.op === 'add')
+            return true;
+        if (op.target === 'diagram')
+            return true;
+        return this.known.has(op.id);
+    }
+    /**
+     * Emit a ready op, then drain anything that was waiting on it. Recursive in spirit
+     * (a released `add` can free `set`s, and nothing else) but flat in code.
+     */
+    release(op, out) {
+        out.push(op);
+        if (op.op !== 'add')
+            return;
+        this.known.add(op.id);
+        const freed = this.waiting.get(op.id);
+        if (!freed)
+            return;
+        this.waiting.delete(op.id);
+        // Sorted: the dependants must apply in total order among themselves, or two `set`s on
+        // the same register could land in the wrong sequence. (The LWW gate would catch that
+        // anyway — but relying on the gate to fix an ordering we control ourselves is how you
+        // end up depending on a safety net you have never tested.)
+        for (const f of freed.sort(op_1.compareOps)) {
+            this.heldIds.delete((0, op_1.opId)(f));
+            out.push(f);
+        }
+    }
+    hold(op) {
+        const id = (0, op_1.opId)(op);
+        if (this.heldIds.has(id))
+            return 'duplicate';
+        if (this.heldIds.size >= this.maxPending) {
+            this.overflowed++;
+            return 'overflow';
+        }
+        this.heldIds.add(id);
+        const list = this.waiting.get(op.id);
+        if (list)
+            list.push(op);
+        else
+            this.waiting.set(op.id, [op]);
+        return 'held';
+    }
+}
+exports.CausalBuffer = CausalBuffer;
+//# sourceMappingURL=causal-buffer.js.map

package/src/libs/engine/src/sync/causal-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"causal-buffer.js","sourceRoot":"","sources":["../../../../../../engine/src/sync/causal-buffer.ts"],"names":[],"mappings":"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"}

package/src/libs/engine/src/sync/index.d.ts

@@ -0,0 +1,20 @@
+export { SyncAdapter, createSyncSession } from './sync-adapter';
+export type { SyncAdapterOptions, SyncSessionOptions, SyncStats } from './sync-adapter';
+export type { SyncTransport, TransportStatus, Unsubscribe as TransportUnsubscribe } from './transport';
+export type { SyncMessage, HelloMessage, OpsMessage, AwarenessMessage, ByeMessage, AwarenessState, } from './protocol';
+export { isDocumentMessage } from './protocol';
+export { Awareness } from './awareness';
+export type { AwarenessChange, AwarenessOptions, PeerPresence } from './awareness';
+export { VersionVector, deltaFor } from './version-vector';
+export type { ActorFrontier, VersionVectorJSON } from './version-vector';
+export { OpBatcher, coalesce } from './batcher';
+export type { OpBatcherOptions } from './batcher';
+export { CausalBuffer } from './causal-buffer';
+export type { CausalBufferOptions, CausalSplit } from './causal-buffer';
+export { MemoryHub, MemoryTransport } from './transports/memory';
+export { UnreliableHub, mulberry32 } from './transports/unreliable';
+export type { UnreliableOptions } from './transports/unreliable';
+export { BroadcastChannelTransport } from './transports/broadcast-channel';
+export type { BroadcastChannelLike, BroadcastChannelTransportOptions, } from './transports/broadcast-channel';
+export { WebSocketTransport } from './transports/websocket';
+export type { WebSocketLike, WebSocketTransportOptions } from './transports/websocket';