@grafloria/element 0.3.17 → 0.3.19

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

@@ -0,0 +1,524 @@
+"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/sync-adapter.js.map

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

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

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

@@ -0,0 +1,28 @@
+"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/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../../../../../engine/src/sync/transport.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,uFAAuF;AACvF,yEAAyE;AACzE,EAAE;AACF,mFAAmF;AACnF,qFAAqF;AACrF,yFAAyF;AACzF,yFAAyF;AACzF,yFAAyF;AACzF,8CAA8C;AAC9C,EAAE;AACF,qDAAqD;AACrD,sEAAsE;AACtE,6DAA6D;AAC7D,wFAAwF;AACxF,0EAA0E;AAC1E,iDAAiD;AACjD,wEAAwE;AACxE,EAAE;AACF,wFAAwF;AACxF,yFAAyF;AACzF,wCAAwC"}

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

@@ -0,0 +1,39 @@
+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;
+}