@grafloria/element 0.3.19 → 0.3.21

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

@@ -1,221 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,84 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,81 +0,0 @@
-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

@@ -1,199 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"version":3,"file":"causal-buffer.js","sourceRoot":"","sources":["../../../../../../engine/src/sync/causal-buffer.ts"],"names":[],"mappings":";AAAA,qCAAqC;AACrC,EAAE;AACF,2EAA2E;AAC3E,EAAE;AACF,mFAAmF;AACnF,wFAAwF;AACxF,qFAAqF;AACrF,mFAAmF;AACnF,EAAE;AACF,sFAAsF;AACtF,oEAAoE;AACpE,EAAE;AACF,sEAAsE;AACtE,EAAE;AACF,iFAAiF;AACjF,wFAAwF;AACxF,6BAA6B;AAC7B,0FAA0F;AAC1F,EAAE;AACF,qFAAqF;AACrF,0FAA0F;AAC1F,EAAE;AACF,iFAAiF;AACjF,wFAAwF;AACxF,8BAA8B;AAC9B,EAAE;AACF,uFAAuF;AACvF,yFAAyF;AACzF,qEAAqE;AACrE,EAAE;AACF,qFAAqF;AACrF,kFAAkF;AAClF,EAAE;AACF,8EAA8E;AAC9E,uDAAuD;AACvD,8EAA8E;AAC9E,EAAE;AACF,wFAAwF;AACxF,0FAA0F;AAC1F,qFAAqF;AACrF,wFAAwF;AACxF,oFAAoF;AACpF,kFAAkF;;;AAGlF,qCAAyD;AAoBzD;;;;;;GAMG;AACH,MAAa,YAAY;IAevB,YACmB,OAAqB,EACtC,UAA+B,EAAE;;QADhB,YAAO,GAAP,OAAO,CAAc;QAfxC,gFAAgF;QAC/D,UAAK,GAAG,IAAI,GAAG,EAAU,CAAC;QAE3C,4DAA4D;QAC3C,YAAO,GAAG,IAAI,GAAG,EAAgB,CAAC;QAEnD,4EAA4E;QAC3D,YAAO,GAAG,IAAI,GAAG,EAAU,CAAC;QAI7C,6EAA6E;QAC7E,eAAU,GAAG,CAAC,CAAC;QAMb,IAAI,CAAC,UAAU,GAAG,MAAA,OAAO,CAAC,UAAU,mCAAI,KAAM,CAAC;QAE/C,kFAAkF;QAClF,sFAAsF;QACtF,qFAAqF;QACrF,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,EAAE;YAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACzD,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,QAAQ,EAAE;YAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACzD,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,SAAS,EAAE;YAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,SAAS,CAAC,EAAM;QACd,IAAI,EAAE,CAAC,EAAE,KAAK,KAAK;YAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,QAAuB;QAC3B,MAAM,KAAK,GAAS,EAAE,CAAC;QACvB,IAAI,IAAI,GAAG,CAAC,CAAC;QAEb,mFAAmF;QACnF,kFAAkF;QAClF,+DAA+D;QAC/D,KAAK,MAAM,EAAE,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC,IAAI,CAAC,eAAU,CAAC,EAAE,CAAC;YAChD,IAAI,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;gBACrB,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;gBACxB,SAAS;YACX,CAAC;YACD,QAAQ,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;gBACtB,KAAK,MAAM;oBACT,IAAI,EAAE,CAAC;oBACP,MAAM;gBACR,KAAK,UAAU;oBACb,6EAA6E;oBAC7E,6EAA6E;oBAC7E,qEAAqE;oBACrE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;oBACf,MAAM;gBACR,KAAK,WAAW;oBACd,MAAM;YACV,CAAC;QACH,CAAC;QAED,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACzB,CAAC;IAED,+EAA+E;IAC/E,OAAO;QACL,MAAM,GAAG,GAAS,EAAE,CAAC;QACrB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;YAAE,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAC5D,OAAO,GAAG,CAAC,IAAI,CAAC,eAAU,CAAC,CAAC;IAC9B,CAAC;IAED,4EAA4E;IAEpE,OAAO,CAAC,EAAM;QACpB,mFAAmF;QACnF,IAAI,EAAE,CAAC,EAAE,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC;QACjC,IAAI,EAAE,CAAC,MAAM,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;QACzC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACK,OAAO,CAAC,EAAM,EAAE,GAAS;QAC/B,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACb,IAAI,EAAE,CAAC,EAAE,KAAK,KAAK;YAAE,OAAO;QAE5B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAEtB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACtC,IAAI,CAAC,KAAK;YAAE,OAAO;QACnB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QAE3B,sFAAsF;QACtF,qFAAqF;QACrF,sFAAsF;QACtF,2DAA2D;QAC3D,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,eAAU,CAAC,EAAE,CAAC;YACvC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAA,SAAI,EAAC,CAAC,CAAC,CAAC,CAAC;YAC7B,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACd,CAAC;IACH,CAAC;IAEO,IAAI,CAAC,EAAM;QACjB,MAAM,EAAE,GAAG,IAAA,SAAI,EAAC,EAAE,CAAC,CAAC;QACpB,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YAAE,OAAO,WAAW,CAAC;QAE7C,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACzC,IAAI,CAAC,UAAU,EAAE,CAAC;YAClB,OAAO,UAAU,CAAC;QACpB,CAAC;QAED,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACrB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACrC,IAAI,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;;YACnB,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QACnC,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAzJD,oCAyJC"}

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

@@ -1,20 +0,0 @@
-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';