@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/sync/sync-adapter.js

@@ -1,524 +0,0 @@
-"use strict";
-// Wave 9 — Card 5: the SyncAdapter. Everything that is hard about collaboration, in one
-// place, above the transport, so that every transport gets it right for free.
-//
-//        Replica (log · LWW gate · capture)         ← Card 0, not touched here
-//            ▲                       │ onLocalOp
-//            │ receive(ready)        ▼
-//     ┌──────┴───────────────────────────────┐
-//     │  CausalBuffer     OpBatcher          │   ← this file wires them
-//     │  VersionVector    Awareness          │
-//     └──────▲───────────────────────────────┘
-//            │  SyncMessage                  │
-//     ┌──────┴───────────────────────────────┐
-//     │  SyncTransport  (memory · Broadcast  │   ← dumb pipes. Cannot get this wrong,
-//     │                  Channel · WebSocket)│      because they are not told what it is.
-//     └──────────────────────────────────────┘
-//
-// THE FIVE THINGS THIS FILE OWNS, none of which a transport is allowed to know about:
-//
-//  1. CATCH-UP.   Reconnect ⇒ exchange frontiers ⇒ each side ships the other exactly what
-//                 it lacks. See version-vector.ts for why the obvious watermark is a trap.
-//  2. CAUSALITY.  An op whose entity has not arrived is HELD, not dropped. See
-//                 causal-buffer.ts for why dropping it is unrecoverable.
-//  3. BATCHING.   60Hz of drag ops become one message a frame, last-write-wins per
-//                 register, order preserved. See batcher.ts.
-//  4. AWARENESS.  On the wire, never in the log. See awareness.ts.
-//  5. RELAY.      In a mesh, forward what was new to us. `Replica.receive()` returns
-//                 exactly that set, and returns EMPTY for a re-delivery, which is what
-//                 makes the forwarding terminate instead of looping forever.
-//
-// THE REACHABILITY DISCIPLINE. This engine's signature bug — found in all eight previous
-// waves — is machinery wired to nothing: a `setLayoutService()` nobody called, LOD presets
-// that were all no-ops, a worker stack every test disabled, a `Command.serialize()` with
-// no deserializer anywhere. So the load-bearing test for this card is NOT the unit tests
-// below the fold. It is `reachability.spec.ts` and the two-pane e2e: mount a REAL
-// `createDiagram`, drag a node with REAL pointer events, and assert the bytes come out of
-// the OTHER pane's model. If that test is deleted, this file is decoration.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncAdapter = void 0;
-exports.createSyncSession = createSyncSession;
-const replica_1 = require("../collab/replica");
-const op_1 = require("../collab/op");
-const awareness_1 = require("./awareness");
-const batcher_1 = require("./batcher");
-const causal_buffer_1 = require("./causal-buffer");
-const version_vector_1 = require("./version-vector");
-/**
- * Binds one `Replica` to one `SyncTransport`.
- *
- * The replica must be constructed with `onLocalOp` pointing at `adapter.publish` — use
- * {@link createSyncSession}, which does that wiring for you and cannot get it backwards.
- */
-class SyncAdapter {
-    constructor(replica, transport, options = {}) {
-        var _a, _b, _c, _d, _e, _f;
-        this.replica = replica;
-        this.transport = transport;
-        this.options = options;
-        this.vv = new version_vector_1.VersionVector();
-        /**
-         * Ops we COALESCED AWAY and will therefore never transmit — to anyone, ever.
-         *
-         * They are in our LOG (they really happened) but not in the history we SHARE, so they must
-         * not appear in our frontier or in any catch-up delta we serve. See `sharedHistory()` for
-         * the bug this prevents; it is the difference between "one op per drag" and "the entire
-         * document history, resent on every sync round, forever".
-         */
-        this.suppressed = new Set();
-        this.unsubs = [];
-        this.syncTimer = null;
-        this.heartbeatTimer = null;
-        this.awarenessTimer = null;
-        this.awarenessPending = false;
-        this.lastAwarenessSend = 0;
-        this.joined = false;
-        /** Have we ever successfully announced? Distinguishes the first connect from a RECONNECT. */
-        this.announced = false;
-        this.disposed = false;
-        this.stats = {
-            messagesSent: 0,
-            messagesReceived: 0,
-            opsSent: 0,
-            opsReceived: 0,
-            opsDuplicate: 0,
-            opsHeld: 0,
-            syncsRequested: 0,
-            repairs: 0,
-            opsCoalesced: 0,
-            reconnects: 0,
-        };
-        this.nowFn = (_a = options.now) !== null && _a !== void 0 ? _a : Date.now;
-        this.setTimerFn = (_b = options.setTimer) !== null && _b !== void 0 ? _b : ((cb, ms) => setTimeout(cb, ms));
-        this.clearTimerFn =
-            (_c = options.clearTimer) !== null && _c !== void 0 ? _c : ((h) => clearTimeout(h));
-        this.setIntervalFn =
-            (_d = options.setInterval) !== null && _d !== void 0 ? _d : ((cb, ms) => setInterval(cb, ms));
-        this.clearIntervalFn =
-            (_e = options.clearInterval) !== null && _e !== void 0 ? _e : ((h) => clearInterval(h));
-        this.buffer = new causal_buffer_1.CausalBuffer(replica.diagram);
-        this.awareness = new awareness_1.Awareness({
-            actor: replica.actor,
-            timeoutMs: options.awarenessTimeoutMs,
-            now: this.nowFn,
-        });
-        // The diagram may already have history (loaded from disk, or edited before anyone
-        // else joined). Our frontier must reflect it, or our very first `sync` would ask a
-        // peer to resend everything we already have.
-        this.vv.observeAll(replica.history());
-        this.batcher =
-            options.batch === false
-                ? null
-                : new batcher_1.OpBatcher(Object.assign(Object.assign({}, ((_f = options.batch) !== null && _f !== void 0 ? _f : {})), { onFlush: (kept, dropped) => {
-                        // Ops coalesced away are ops we will NEVER put on the wire. Record them, or
-                        // our frontier advertises history no peer can ever obtain. See `suppressed`.
-                        for (const op of dropped)
-                            this.suppressed.add((0, op_1.opId)(op));
-                        // The frontier advances HERE — at the moment ops actually go out — and not in
-                        // `publish()`, because at publish time we do not yet know which of them will
-                        // survive coalescing.
-                        this.vv.observeAll(kept);
-                        this.sendOps(kept);
-                    }, setTimer: options.setTimer, clearTimer: options.clearTimer }));
-        this.unsubs.push(this.transport.onMessage((m) => this.onMessage(m)));
-        this.unsubs.push(this.transport.onStatus((s) => this.onStatus(s)));
-    }
-    get actor() {
-        return this.replica.actor;
-    }
-    get diagram() {
-        return this.replica.diagram;
-    }
-    /** Ops still waiting on an `add` that has not arrived. Should return to 0. */
-    get pendingOps() {
-        return this.buffer.pending();
-    }
-    /**
-     * What we tell peers we have.
-     *
-     * THE INVARIANT, and it is worth stating as one because it is the whole correctness
-     * condition of this layer in a single line:
-     *
-     *     frontier() === VersionVector.fromOps(sharedHistory())     — ALWAYS.
-     *
-     * SHARED history, not the local log — an op coalescing withheld is not part of the history
-     * we share with anyone, and advertising it would make every peer chase a hole that can
-     * never be filled. That distinction IS the bug documented on `sharedHistory()`.
-     *
-     * The frontier is a CACHE of that summary, maintained incrementally so we do not rescan
-     * the history on every sync. A cache that disagrees with its source is not a performance
-     * detail; it is a peer lying to the network about what it holds. Claim too much and you
-     * never receive the op you are missing (silent data loss); claim too little and every
-     * round resends an actor's entire history (a silent O(history) amplifier on the flakiest
-     * connections, which is precisely where you can least afford it).
-     *
-     * `sync-adapter.spec.ts` asserts this equality after a full hostile session, which is what
-     * makes it a checked invariant rather than a comment.
-     */
-    frontier() {
-        return this.vv.toJSON();
-    }
-    // -- lifecycle -------------------------------------------------------------
-    /**
-     * Announce ourselves and ask for what we are missing.
-     *
-     * `hello` carries our frontier, so an existing peer can push us the history we lack
-     * without a second round trip — a joining peer should see the document on the first
-     * message, not the third.
-     */
-    join() {
-        var _a, _b;
-        if (this.disposed)
-            return;
-        this.joined = true;
-        // `connect()` may complete SYNCHRONOUSLY (the memory bus) or ASYNCHRONOUSLY (a real
-        // socket, which opens some milliseconds later). Both must announce exactly once, and
-        // neither may announce into a channel that is not up yet — a `hello` sent before the
-        // socket opens is silently dropped and the peer never learns we exist.
-        //
-        // So the announcement is owned by the STATUS handler, which is the one place that
-        // knows the channel is actually up, and it fires for both cases. The fallback below
-        // covers only the third: a transport handed to us already connected, which therefore
-        // never transitions and never fires.
-        this.transport.connect();
-        if (this.transport.status === 'connected' && !this.announced)
-            this.announce();
-        const interval = (_a = this.options.syncIntervalMs) !== null && _a !== void 0 ? _a : 0;
-        if (interval > 0 && this.syncTimer === null) {
-            this.syncTimer = this.setIntervalFn(() => this.sync(), interval);
-        }
-        const beat = (_b = this.options.heartbeatMs) !== null && _b !== void 0 ? _b : 0;
-        if (beat > 0 && this.heartbeatTimer === null) {
-            this.heartbeatTimer = this.setIntervalFn(() => {
-                // A heartbeat is a re-send of the CURRENT state at the CURRENT sequence — it must
-                // not bump `seq`, or every peer would think our cursor "changed" every 5 seconds
-                // and repaint it. It refreshes their `lastSeen`, nothing more.
-                this.sendAwareness();
-                // …and it is where WE drop peers who have stopped heartbeating at us. Expiry has
-                // to be driven by a timer: nothing arrives from a peer whose tab has crashed, so
-                // there is no event to hang it on. That is precisely why their cursor would
-                // otherwise hover on the canvas forever.
-                this.awareness.prune();
-            }, beat);
-        }
-    }
-    /** Say goodbye and stop. Best-effort — the peers' TTL is what actually guarantees it. */
-    leave() {
-        var _a;
-        if (!this.joined)
-            return;
-        this.joined = false;
-        (_a = this.batcher) === null || _a === void 0 ? void 0 : _a.flush();
-        this.send({ t: 'bye', from: this.actor });
-        this.stopTimers();
-        this.transport.disconnect();
-        // We can no longer vouch for anyone: their cursors must go.
-        this.awareness.clearPeers();
-    }
-    /**
-     * An anti-entropy round: "here is my frontier; send me what I lack, and tell me yours."
-     *
-     * Called on join, on RECONNECT, and (optionally) on a timer. The timer is not paranoia:
-     * a transport that can drop a message can drop an op, and the ONLY thing that ever
-     * repairs that is asking again.
-     */
-    sync() {
-        this.stats.syncsRequested++;
-        this.send({ t: 'sync', from: this.actor, vv: this.vv.toJSON(), reply: true });
-    }
-    /** Push any queued local ops onto the wire now. */
-    flush() {
-        var _a;
-        (_a = this.batcher) === null || _a === void 0 ? void 0 : _a.flush();
-    }
-    /**
-     * Our own edits. Wired to `Replica.onLocalOp` — see {@link createSyncSession}.
-     *
-     * The local op is ALREADY in our log and already applied (the Replica did both before
-     * calling us). Our job is only to get it to the others, so a failure to send is not a
-     * failure to edit — it is a divergence the next sync round will close.
-     */
-    publish(op) {
-        if (this.disposed)
-            return;
-        // The causal buffer has to know about entities WE create, not just ones a peer told us
-        // about. Skip this and a peer's edit to a node we made waits forever for an `add` that
-        // nobody will ever send us — because we are the only one who has it. See
-        // `CausalBuffer.noteLocal`; the fuzz found it, and it is the most ordinary interaction
-        // there is: someone moving someone else's node.
-        this.buffer.noteLocal(op);
-        if (this.batcher) {
-            // NOTE what is NOT here: `this.vv.observe(op)`. The frontier advances when the op is
-            // SENT, not when it is made — because coalescing may yet decide never to send it, and
-            // advertising an op we will never transmit is what makes a peer chase a hole forever.
-            this.batcher.push(op);
-            return;
-        }
-        // Un-batched: every op goes out, so nothing is ever suppressed and the frontier can
-        // advance immediately.
-        this.vv.observe(op);
-        this.sendOps([op]);
-    }
-    /**
-     * THE LOG AS THE NETWORK SEES IT — our history, minus everything coalescing withheld.
-     *
-     * ---------------------------------------------------------------------------
-     * THE BUG THIS EXISTS TO FIX, WHICH WAS MINE, AND WHICH ONLY THE BROWSER FOUND
-     * ---------------------------------------------------------------------------
-     * A 20-frame drag puts ONE op on the wire and leaves TWENTY in the local log — that is
-     * coalescing working exactly as designed, and the two peers' documents agree perfectly.
-     *
-     * But anti-entropy compares FRONTIERS DERIVED FROM LOGS. So on the next sync round my
-     * frontier said "I hold 20 ops from alice" and the peer's said "I hold 1", and the digest
-     * — which cannot tell a withheld op from a lost one — declared a HOLE and repaired it by
-     * resending my entire history. Measured: `opsSent` went from 1 to 21 on the first sync
-     * after a single drag. And it never settles, because the peer can NEVER obtain the 19 ops
-     * I have deliberately decided never to send. Every sync round, forever, for the rest of
-     * the session, on the most common interaction in the product.
-     *
-     * It is invisible to a convergence oracle — the document is perfectly correct throughout —
-     * and it was invisible to my own frontier-invariant test, which flushed after every single
-     * op and therefore never once coalesced anything while syncing. It took driving a real drag
-     * through a real browser to compose the two.
-     *
-     * THE FIX is a definition, not a patch: THE FRONTIER DESCRIBES THE SHARED LOG. An op we
-     * chose never to transmit is not part of the history we share with anyone, so it is not in
-     * our frontier and it is not in the catch-up delta we serve — to ANY peer, including one
-     * that joins tomorrow. Every peer therefore holds the same shared set, every digest agrees,
-     * and the fast path stays fast.
-     */
-    sharedHistory() {
-        if (this.suppressed.size === 0)
-            return [...this.replica.history()];
-        return this.replica.history().filter((op) => !this.suppressed.has((0, op_1.opId)(op)));
-    }
-    // -- awareness -------------------------------------------------------------
-    /**
-     * Publish our cursor / selection / name.
-     *
-     * THROTTLED, not debounced. A debounce would send nothing at all while the mouse keeps
-     * moving — the cursor would only appear once you stopped, which is the exact opposite
-     * of the feature. A throttle sends the newest sample at a bounded rate and drops the
-     * ones in between, which is precisely correct for a value where only the latest matters.
-     */
-    setAwareness(patch) {
-        var _a;
-        if (this.disposed)
-            return;
-        if (!this.awareness.setLocalState(patch))
-            return; // nothing actually changed
-        const throttle = (_a = this.options.awarenessThrottleMs) !== null && _a !== void 0 ? _a : 50;
-        const since = this.nowFn() - this.lastAwarenessSend;
-        if (since >= throttle) {
-            this.sendAwareness();
-            return;
-        }
-        if (this.awarenessPending)
-            return;
-        // Trailing edge: whatever the state IS when the timer fires is what goes out. Not the
-        // state as of the call that scheduled it — that sample is already stale, and sending
-        // it would make the remote cursor permanently lag by one throttle window.
-        this.awarenessPending = true;
-        this.awarenessTimer = this.setTimerFn(() => {
-            this.awarenessTimer = null;
-            this.awarenessPending = false;
-            this.sendAwareness();
-        }, throttle - since);
-    }
-    sendAwareness() {
-        if (!this.joined)
-            return;
-        this.lastAwarenessSend = this.nowFn();
-        this.send({
-            t: 'awareness',
-            from: this.actor,
-            state: this.awareness.getLocalState(),
-            seq: this.awareness.localSeq,
-        });
-    }
-    // -- the wire --------------------------------------------------------------
-    send(message) {
-        if (this.disposed)
-            return;
-        this.stats.messagesSent++;
-        this.transport.send(message);
-    }
-    sendOps(ops) {
-        if (ops.length === 0)
-            return;
-        this.stats.opsSent += ops.length;
-        if (this.batcher) {
-            this.stats.opsCoalesced = this.batcher.queued - this.batcher.sent;
-        }
-        this.send({ t: 'ops', from: this.actor, ops });
-    }
-    onStatus(status) {
-        var _a;
-        if (this.disposed || !this.joined)
-            return;
-        if (status === 'disconnected') {
-            // Do NOT flush: the transport is down, so a flush would drop the batch on the floor
-            // and we would think we had sent it. Discard is safe because every op is already in
-            // our log — the reconnect's sync round is what actually delivers them.
-            (_a = this.batcher) === null || _a === void 0 ? void 0 : _a.discard();
-            this.awareness.clearPeers();
-            return;
-        }
-        // BACK. `announce()` IS the whole reconnect story.
-        if (this.announced)
-            this.stats.reconnects++;
-        this.announce();
-    }
-    /**
-     * "Here I am; here is what I have."
-     *
-     * Fired on the first connect and on every RECONNECT, and it is the same two messages
-     * both times — because "I have been away for 30 seconds" and "I have just arrived" are
-     * the same question from the network's point of view, and answering them with one code
-     * path is why the reconnect case cannot rot: it is exercised by every single join.
-     *
-     * Everything both sides did while apart is sitting in their logs. Nothing was lost; it
-     * was only undelivered. `deltaFor` works out exactly what each side missed.
-     */
-    announce() {
-        this.announced = true;
-        this.send({
-            t: 'hello',
-            from: this.actor,
-            vv: this.vv.toJSON(),
-            awareness: this.awareness.getLocalState(),
-        });
-        this.sync();
-    }
-    onMessage(msg) {
-        if (this.disposed)
-            return;
-        this.stats.messagesReceived++;
-        switch (msg.t) {
-            case 'ops':
-                this.ingest(msg.ops);
-                return;
-            case 'hello':
-                // Someone new (or someone back). Push them what they lack, unprompted — a joining
-                // peer that has to ASK for the document sees a blank canvas until the round trip
-                // completes.
-                this.answer(msg.vv);
-                if (msg.awareness) {
-                    this.awareness.applyRemote(msg.from, msg.awareness, 0);
-                }
-                // …and tell them ours, so THEY can push US what WE lack. Both directions, because
-                // a rejoining peer has edits of its own.
-                this.send({ t: 'sync', from: this.actor, vv: this.vv.toJSON(), reply: false });
-                return;
-            case 'sync':
-                this.answer(msg.vv);
-                // `reply: false` on the response, or two peers answer each other's sync requests
-                // forever — a broadcast storm that looks exactly like a working system until you
-                // count the messages.
-                if (msg.reply) {
-                    this.send({ t: 'sync', from: this.actor, vv: this.vv.toJSON(), reply: false });
-                }
-                return;
-            case 'awareness':
-                // NOTE WHAT IS NOT HERE: no log, no clock, no causal buffer, no version vector.
-                // Awareness stops at this line and never travels further into the document.
-                this.awareness.applyRemote(msg.from, msg.state, msg.seq);
-                return;
-            case 'bye':
-                this.awareness.remove(msg.from);
-                return;
-        }
-    }
-    /** Ship a peer exactly the ops its frontier says it does not have. */
-    answer(remoteVv) {
-        // `sharedHistory()`, NOT `history()`. Serving the raw log would hand a joining peer the
-        // 19 drag samples we withheld from everyone else — so IT would hold ops no other peer
-        // has, and the two of them would then repair each other forever.
-        const { ops, repairedActors } = (0, version_vector_1.deltaFor)(this.sharedHistory(), remoteVv);
-        if (repairedActors.length > 0)
-            this.stats.repairs++;
-        if (ops.length > 0)
-            this.sendOps(ops);
-    }
-    /**
-     * The receive path, in the only order that works.
-     *
-     *   CausalBuffer → Replica → VersionVector → relay
-     *
-     * The buffer FIRST, and that ordering is the load-bearing part: an op that reaches the
-     * Replica before its `add` is logged, stamped, and silently dropped, and no later
-     * delivery can ever resurrect it (the log de-duplicates it, and the LWW gate now refuses
-     * it as superseded by itself). Once it is past the Replica it is too late. See
-     * causal-buffer.ts.
-     */
-    ingest(ops) {
-        this.stats.opsReceived += ops.length;
-        const { ready } = this.buffer.admit(ops);
-        this.stats.opsHeld = this.buffer.pendingCount;
-        if (ready.length === 0)
-            return;
-        // `receive()` returns exactly the ops that were NEW — duplicates come back as nothing.
-        const fresh = this.replica.receive(ready);
-        this.stats.opsDuplicate += ready.length - fresh.length;
-        if (fresh.length === 0)
-            return;
-        // The frontier advances ONLY on ops the log genuinely accepted. Counting a duplicate
-        // here would inflate the digest, fake a hole, and make every subsequent sync round
-        // "repair" a history that was never broken.
-        this.vv.observeAll(fresh);
-        // Mesh forwarding. Empty for a re-delivery, which is what makes it terminate.
-        if (this.options.relay)
-            this.sendOps(fresh);
-    }
-    stopTimers() {
-        if (this.syncTimer !== null) {
-            this.clearIntervalFn(this.syncTimer);
-            this.syncTimer = null;
-        }
-        if (this.heartbeatTimer !== null) {
-            this.clearIntervalFn(this.heartbeatTimer);
-            this.heartbeatTimer = null;
-        }
-        if (this.awarenessTimer !== null) {
-            this.clearTimerFn(this.awarenessTimer);
-            this.awarenessTimer = null;
-        }
-        this.awarenessPending = false;
-    }
-    dispose() {
-        var _a;
-        if (this.disposed)
-            return;
-        if (this.joined)
-            this.leave();
-        this.disposed = true;
-        this.stopTimers();
-        (_a = this.batcher) === null || _a === void 0 ? void 0 : _a.dispose();
-        for (const u of this.unsubs)
-            u();
-        this.unsubs.length = 0;
-        this.transport.close();
-    }
-}
-exports.SyncAdapter = SyncAdapter;
-/**
- * Build a Replica and a SyncAdapter, correctly wired to each other.
- *
- * The wiring is one line and it is easy to forget, and forgetting it produces the exact
- * failure this codebase is famous for: everything green, every unit test passing, and not
- * one edit ever reaching the wire — because `onLocalOp` went nowhere.
- */
-function createSyncSession(diagram, transport, options) {
-    let adapter;
-    const replica = new replica_1.Replica(diagram, {
-        actor: options.actor,
-        startClock: options.startClock,
-        // The closure defers the lookup: the Replica needs the callback at construction and
-        // the adapter needs the Replica. An edit cannot possibly happen between these two
-        // statements, so the `?.` is a type formality, not a race.
-        onLocalOp: (op) => adapter === null || adapter === void 0 ? void 0 : adapter.publish(op),
-    });
-    adapter = new SyncAdapter(replica, transport, options);
-    return adapter;
-}
-//# sourceMappingURL=sync-adapter.js.map

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

@@ -1,30 +0,0 @@
-import type { SyncMessage } from './protocol';
-export type Unsubscribe = () => void;
-export type TransportStatus = 'connected' | 'disconnected';
-/**
- * A pipe that moves `SyncMessage`s between peers.
- *
- * The delivery model is BROADCAST-TO-OTHERS: `send()` delivers to every other peer on
- * the channel and never echoes back to the sender. (A star topology through a server, a
- * BroadcastChannel between tabs, and a full WebRTC mesh all present this way; a
- * point-to-point transport presents itself as a channel with one other peer.)
- */
-export interface SyncTransport {
-    /** Broadcast to the other peers. A no-op — NOT an error — while disconnected. */
-    send(message: SyncMessage): void;
-    /** Inbound messages from other peers. Never our own. */
-    onMessage(handler: (message: SyncMessage) => void): Unsubscribe;
-    /**
-     * Connection transitions. THE hook the whole reconnect story hangs on: the adapter
-     * subscribes here and fires an anti-entropy round the moment it hears 'connected'
-     * again. A transport that never reports its status can never be caught up.
-     */
-    onStatus(handler: (status: TransportStatus) => void): Unsubscribe;
-    readonly status: TransportStatus;
-    /** Open (or re-open) the channel. Idempotent. */
-    connect(): void;
-    /** Close the channel but stay re-openable — this is what a "drop" is. */
-    disconnect(): void;
-    /** Tear down for good. */
-    close(): void;
-}

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

@@ -1,28 +0,0 @@
-"use strict";
-// Wave 9 — Card 5: the transport seam.
-//
-// This interface is deliberately, aggressively small. Six members, none of them clever.
-// Everything a collaboration engine actually has to get right — batching, catch-up after
-// a reconnect, causal readiness, duplicate suppression, awareness expiry — lives ABOVE
-// this line, in `SyncAdapter`, where it is written once and tested once.
-//
-// That is the entire point of "transport-agnostic". If the hard parts lived in the
-// transport, then adding WebRTC would mean re-implementing (and re-earning trust in)
-// reconnect and de-duplication for a third time, and the third implementation would have
-// a bug the first two do not. Here, a new transport is: move bytes, tell me when you are
-// up, tell me when you are down. Forty lines. It CANNOT get convergence wrong because it
-// is not allowed to know what convergence is.
-//
-// WHAT A TRANSPORT MAY DO TO YOU, AND IS ALLOWED TO:
-//   • drop a message      (the adapter's anti-entropy re-requests it)
-//   • deliver it twice    (the op log de-duplicates by opId)
-//   • deliver out of order(the LWW gate refuses superseded ops; the causal buffer holds
-//                          the ones that arrived before their dependency)
-//   • deliver it late     (same as out of order)
-//   • disconnect and come back (the adapter re-syncs from its frontier)
-//
-// None of those are bugs to be fixed in the transport. They are the CONTRACT. The proof
-// is `hostile-transport.spec.ts`, which does all five at once, on purpose, with a seeded
-// PRNG, and demands convergence anyway.
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=transport.js.map

package/src/libs/engine/src/sync/transports/broadcast-channel.d.ts

@@ -1,39 +0,0 @@
-import type { ActorId } from '../../collab/op';
-import type { SyncMessage } from '../protocol';
-import type { SyncTransport, TransportStatus, Unsubscribe } from '../transport';
-/** The slice of the BroadcastChannel API we use — so a test can hand us a fake. */
-export interface BroadcastChannelLike {
-    postMessage(data: unknown): void;
-    close(): void;
-    onmessage: ((event: {
-        data: unknown;
-    }) => void) | null;
-}
-export interface BroadcastChannelTransportOptions {
-    /** The room. Every peer on the same name shares a document. Namespace it by doc id. */
-    name: string;
-    actor: ActorId;
-    /** Injectable factory — the default reaches for the global. */
-    create?: (name: string) => BroadcastChannelLike;
-}
-export declare class BroadcastChannelTransport implements SyncTransport {
-    private readonly options;
-    private channel;
-    private readonly handlers;
-    private readonly statusHandlers;
-    private _status;
-    private closed;
-    constructor(options: BroadcastChannelTransportOptions);
-    get status(): TransportStatus;
-    /** True when this environment can actually do cross-tab sync. */
-    static isSupported(): boolean;
-    connect(): void;
-    send(message: SyncMessage): void;
-    private receive;
-    onMessage(handler: (m: SyncMessage) => void): Unsubscribe;
-    onStatus(handler: (s: TransportStatus) => void): Unsubscribe;
-    /** Simulates (and, on `pagehide`, effects) a drop. Re-`connect()` to come back. */
-    disconnect(): void;
-    close(): void;
-    private setStatus;
-}