@rapidmx/meet-plugin 0.14.1 → 0.16.0

package/dist/apps/shared/collab/CollabSession.js

@@ -0,0 +1,559 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz. All rights reserved.
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * The call's text chat and shared whiteboard, over the same signaling channel the mesh uses (`../webrtc/types.ts`'s
+ * `chat`, `whiteboard`, `collab-sync-request` and `collab-sync` messages). Like everything else in a call they live
+ * only as long as the call does - there is no server-side copy; each participant's tab holds them.
+ *
+ * ## Chat
+ *
+ * `sendChat()` broadcasts one `chat` message and shows it locally at once (the server never echoes a sender's own
+ * messages). A received one is shown under the name its sender announced in their `hello`. At most
+ * `MAX_CHAT_HISTORY` messages are kept.
+ *
+ * ## Whiteboard
+ *
+ * Every drawing action becomes a `WhiteboardOp`, applied to this tab's own `WhiteboardModel` at once and broadcast. A
+ * stroke being drawn sends its points in batches every `POINT_FLUSH_MS` rather than one message per pointer move, so
+ * the others watch it being drawn without a message per pixel. `undo()` erases this participant's own most recent
+ * element still on the board.
+ *
+ * ## Pointers
+ *
+ * While a participant's pointer is over the board, `moveCursor()` tells everyone where it is and as which tool and
+ * color, at most every `CURSOR_INTERVAL_MS`; `hideCursor()` says it left. While they are drawing a stroke, no pointer
+ * messages are sent at all - everyone else moves their pointer along the stroke's own points instead. Pointers are
+ * never stored or caught up on; one not heard from for `CURSOR_IDLE_MS` is dropped, as is a participant's on `bye`.
+ *
+ * ## Who may draw
+ *
+ * `setDrawPolicy()` limits who may change the board (talking-stick mode: only whoever holds the stick). This
+ * participant's own drawing calls then do nothing unless it is allowed, and a received change from a participant who
+ * isn't is ignored - as cooperative as every other moderation signal in the call (see `../webrtc/types.ts`): each
+ * participant's own tab decides. A change in flight when the stick moves may land on some boards and not others.
+ * Pointers still show for everyone - pointing at something isn't drawing it.
+ *
+ * ## Catching up
+ *
+ * Someone joining a call already under way asks one participant for what they missed: on the first `hello` it hears
+ * within `SYNC_WINDOW_MS` of starting (an existing participant answering its own `hello`), it sends that participant a
+ * `collab-sync-request`; the answer is the chat history and the board as ops, split into `collab-sync` parts that
+ * each fit the server's message limit and paced `SYNC_PACE_MS` apart to stay inside its rate limit. When nothing has
+ * arrived from that participant for `SYNC_TIMEOUT_MS` (first part or next), the next one is asked - as it is when the
+ * whole answer was empty, which is what another newcomer who arrived moments earlier would send. Only the participant
+ * asked is listened to, and a participant answers the same requester at most once per `SYNC_ANSWER_COOLDOWN_MS`. A catch-up is that one participant's account of the call, which this tab cannot check - the chat history it
+ * carries names who said what, and the server stamps only the catch-up's own sender - so it is merged under the same
+ * validation as live messages, and live messages win wherever the two overlap.
+ */
+import { BOARD_HEIGHT, BOARD_WIDTH, MAX_CHAT_HISTORY, MAX_CHAT_LENGTH, MAX_POINTS_PER_OP, MAX_STROKE_POINTS, clampCoordinate, parseChat, parseCursor, parseSync, parseWhiteboardOp, } from "./protocol.js";
+import { WhiteboardModel } from "./WhiteboardModel.js";
+/** How often the points of a stroke being drawn are sent. */
+export const POINT_FLUSH_MS = 60;
+/** How long after starting a `hello` still counts as an existing participant answering ours - see this module's doc. */
+export const SYNC_WINDOW_MS = 15000;
+/** How long to wait for a catch-up to start arriving before asking someone else. */
+export const SYNC_TIMEOUT_MS = 5000;
+/** The gap between two parts of a catch-up this participant sends. */
+export const SYNC_PACE_MS = 250;
+/** Room left in each catch-up part for the message's own envelope. */
+export const SYNC_ENVELOPE_BYTES = 1024;
+/** The most stroke points one catch-up op carries, so one op always fits the server's smallest message limit. */
+export const SYNC_POINTS_PER_OP = 600;
+/** The least time between two pointer messages this participant sends. */
+export const CURSOR_INTERVAL_MS = 80;
+/** How long a participant's pointer stays on the board without news of it. */
+export const CURSOR_IDLE_MS = 30000;
+/** How long a participant waits before answering the same requester's catch-up request again. */
+export const SYNC_ANSWER_COOLDOWN_MS = 10000;
+/** What a message is sized against when the channel doesn't say. */
+const DEFAULT_MAX_MESSAGE_BYTES = 16 * 1024;
+export class CollabSession {
+    constructor(options) {
+        this.options = options;
+        this.board = new WhiteboardModel();
+        this.chatEntries = [];
+        /** How many of `chatEntries`, from the front, came from a catch-up - the next part's history goes after them. */
+        this.historyCount = 0;
+        this.chatKeys = new Set();
+        this.names = new Map();
+        this.listeners = new Set();
+        this.ownIds = [];
+        this.outgoingPoints = new Map();
+        this.timers = new Set();
+        this.syncTried = new Set();
+        this.knownPeers = [];
+        this.startedAt = 0;
+        this.seq = 0;
+        this.stopped = false;
+        this.remoteCursors = new Map();
+        this.cursorShown = false;
+        this.lastCursorSent = -Infinity;
+        this.syncAnswered = new Map();
+        this.syncReceivedAnything = false;
+    }
+    /** Every chat message, oldest first. */
+    get chat() {
+        return this.chatEntries;
+    }
+    /** Everyone else's pointers currently on the board. */
+    get cursors() {
+        return [...this.remoteCursors.values()];
+    }
+    /** Whether this participant may change the board now - see this module's doc comment on who may draw. */
+    get canDraw() {
+        return this.mayDraw(this.options.peerId);
+    }
+    /** Limits who may change the board to the peers `policy` accepts; `undefined` lets everyone. */
+    setDrawPolicy(policy) {
+        this.drawPolicy = policy;
+        if (!this.canDraw) {
+            this.endStroke();
+        }
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    start() {
+        if (this.unsubscribe || this.stopped) {
+            return;
+        }
+        this.startedAt = this.now();
+        this.unsubscribe = this.options.channel.onMessage((message) => this.handleMessage(message));
+        this.pruneTimer = setInterval(() => this.pruneCursors(), CURSOR_IDLE_MS / 6);
+    }
+    stop() {
+        if (this.stopped) {
+            return;
+        }
+        // Before `stopped` is set, which makes `send()` drop everything.
+        this.flushPoints();
+        this.stopped = true;
+        this.unsubscribe?.();
+        this.unsubscribe = undefined;
+        clearTimeout(this.flushTimer);
+        clearTimeout(this.syncTimer);
+        clearTimeout(this.cursorTimer);
+        clearInterval(this.pruneTimer);
+        for (const timer of this.timers) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+        this.listeners.clear();
+    }
+    /** Sends `text` as a chat message. Returns `false`, sending nothing, for blank or overlong text. */
+    sendChat(text) {
+        if (!text.trim() || text.length > MAX_CHAT_LENGTH || this.stopped) {
+            return false;
+        }
+        const payload = { id: this.nextId(), text, sentAt: this.now() };
+        this.send({ kind: "chat", chat: payload });
+        this.addChat({ ...payload, peer: this.options.peerId, name: this.options.selfName }, true);
+        return true;
+    }
+    /** Starts a stroke at (`x`, `y`); returns its id, or `undefined` when the board is full. */
+    beginStroke(pen, color, size, x, y) {
+        const id = this.addElement({ kind: "stroke", id: this.nextElementId(), epoch: this.board.epoch, pen, color, size, points: [clampX(x), clampY(y)] });
+        this.activeStroke = id;
+        return id;
+    }
+    /** Adds a point to this participant's own stroke `id` - sent with the next batch. */
+    extendStroke(id, x, y) {
+        const stroke = this.board.get(id);
+        if (!stroke || stroke.kind !== "stroke" || stroke.points.length >= MAX_STROKE_POINTS * 2 || !this.canDraw) {
+            return;
+        }
+        const point = [clampX(x), clampY(y)];
+        const start = stroke.points.length / 2;
+        if (!this.board.apply({ op: "points", id, start, points: point }, this.options.peerId)) {
+            return;
+        }
+        const batch = this.outgoingPoints.get(id);
+        if (batch) {
+            batch.points.push(...point);
+        }
+        else {
+            this.outgoingPoints.set(id, { start, points: point });
+        }
+        // A batch never outgrows what one op may carry, even if the timer below runs late.
+        if ((batch?.points.length ?? 0) >= MAX_POINTS_PER_OP * 2) {
+            this.flushPoints();
+        }
+        this.flushTimer ?? (this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            this.flushPoints();
+        }, POINT_FLUSH_MS));
+        this.emit({ type: "board" });
+    }
+    /** Finishes a stroke: whatever points are still waiting go out now. */
+    endStroke() {
+        this.activeStroke = undefined;
+        clearTimeout(this.flushTimer);
+        this.flushTimer = undefined;
+        this.flushPoints();
+    }
+    addShape(shape, color, size, x1, y1, x2, y2) {
+        const [a, b, c, d] = [clampX(x1), clampY(y1), clampX(x2), clampY(y2)];
+        return this.addElement({ kind: "shape", id: this.nextElementId(), epoch: this.board.epoch, shape, color, size, x1: a, y1: b, x2: c, y2: d });
+    }
+    addStamp(stamp, size, x, y) {
+        return this.addElement({ kind: "stamp", id: this.nextElementId(), epoch: this.board.epoch, stamp, size, x: clampX(x), y: clampY(y) });
+    }
+    /** Erases `ids` - anyone's elements, see `protocol.ts`. */
+    erase(ids) {
+        const present = ids.filter((id) => this.board.get(id));
+        if (present.length > 0 && this.canDraw) {
+            this.applyAndSend({ op: "remove", ids: present });
+        }
+    }
+    /** Erases this participant's own most recent element still on the board; `false` when there is none. */
+    undo() {
+        while (this.ownIds.length > 0 && this.canDraw) {
+            const id = this.ownIds.pop();
+            if (this.board.get(id)) {
+                this.endStroke();
+                this.applyAndSend({ op: "remove", ids: [id] });
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Clears the board for everyone. */
+    clear() {
+        if (!this.canDraw || this.stopped) {
+            return;
+        }
+        this.endStroke();
+        this.applyAndSend({ op: "clear", epoch: this.board.epoch + 1 });
+    }
+    /** Says this participant's pointer is at (`x`, `y`) on the board, as `tool` in `color` (with `stamp` for the stamp
+     * tool) - sent now, or with the latest position once `CURSOR_INTERVAL_MS` has passed since the last one. */
+    moveCursor(x, y, tool, color, stamp) {
+        if (this.stopped) {
+            return;
+        }
+        this.cursorPending = { x: clampX(x), y: clampY(y), tool, color, ...(stamp ? { stamp } : {}) };
+        if (this.cursorTimer === undefined) {
+            const wait = Math.max(0, this.lastCursorSent + CURSOR_INTERVAL_MS - this.now());
+            this.cursorTimer = setTimeout(() => {
+                this.cursorTimer = undefined;
+                this.flushCursor();
+            }, wait);
+        }
+    }
+    /** Says this participant's pointer has left the board. */
+    hideCursor() {
+        clearTimeout(this.cursorTimer);
+        this.cursorTimer = undefined;
+        this.cursorPending = undefined;
+        if (this.cursorShown) {
+            this.cursorShown = false;
+            this.send({ kind: "whiteboard-cursor", cursor: { hidden: true } });
+        }
+    }
+    flushCursor() {
+        const cursor = this.cursorPending;
+        this.cursorPending = undefined;
+        // Mid-stroke, the stroke's own points show where the pointer is - see this module's doc comment.
+        if (!cursor || this.activeStroke !== undefined) {
+            return;
+        }
+        this.lastCursorSent = this.now();
+        this.cursorShown = true;
+        this.send({ kind: "whiteboard-cursor", cursor });
+    }
+    handleCursor(sender, raw) {
+        const cursor = parseCursor(raw);
+        if (!cursor) {
+            return;
+        }
+        if ("hidden" in cursor) {
+            if (this.remoteCursors.delete(sender)) {
+                this.emit({ type: "cursors" });
+            }
+            return;
+        }
+        this.remoteCursors.set(sender, { peer: sender, name: this.names.get(sender) ?? "Guest", ...cursor, at: this.now() });
+        this.emit({ type: "cursors" });
+    }
+    /** Moves `sender`'s pointer to where their stroke just got to - see this module's doc comment on pointers. */
+    followStroke(sender, op) {
+        const id = op.op === "add" ? op.element.id : op.op === "points" ? op.id : undefined;
+        const stroke = id === undefined ? undefined : this.board.get(id);
+        if (!stroke || stroke.kind !== "stroke") {
+            return;
+        }
+        const previous = this.remoteCursors.get(sender);
+        this.remoteCursors.set(sender, {
+            peer: sender,
+            name: this.names.get(sender) ?? "Guest",
+            tool: stroke.pen,
+            color: stroke.color,
+            x: stroke.points[stroke.points.length - 2],
+            y: stroke.points[stroke.points.length - 1],
+            ...(previous?.tool === stroke.pen && previous.stamp ? { stamp: previous.stamp } : {}),
+            at: this.now(),
+        });
+        this.emit({ type: "cursors" });
+    }
+    pruneCursors() {
+        const cutoff = this.now() - CURSOR_IDLE_MS;
+        let changed = false;
+        for (const [peer, cursor] of this.remoteCursors) {
+            if (cursor.at < cutoff) {
+                this.remoteCursors.delete(peer);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.emit({ type: "cursors" });
+        }
+    }
+    mayDraw(peer) {
+        return !this.drawPolicy || this.drawPolicy(peer);
+    }
+    addElement(element) {
+        if (!this.board.hasRoom || this.stopped || !this.canDraw) {
+            return undefined;
+        }
+        this.endStroke();
+        this.applyAndSend({ op: "add", element: element.kind === "stroke" ? { ...element, points: [...element.points] } : element });
+        this.ownIds.push(element.id);
+        return element.id;
+    }
+    applyAndSend(op) {
+        if (this.board.apply(op, this.options.peerId)) {
+            this.emit({ type: "board" });
+        }
+        this.send({ kind: "whiteboard", whiteboard: op });
+    }
+    flushPoints() {
+        for (const [id, batch] of this.outgoingPoints) {
+            this.send({ kind: "whiteboard", whiteboard: { op: "points", id, start: batch.start, points: batch.points } });
+        }
+        this.outgoingPoints.clear();
+    }
+    handleMessage(message) {
+        if (message.type !== "video-meeting-signal") {
+            return;
+        }
+        const sender = message.peer ?? message.from;
+        if (sender === this.options.peerId || (message.to !== undefined && message.to !== this.options.peerId)) {
+            return;
+        }
+        switch (message.kind) {
+            case "hello":
+                this.handleHello(sender, message.name);
+                return;
+            case "bye":
+                if (this.remoteCursors.delete(sender)) {
+                    this.emit({ type: "cursors" });
+                }
+                return;
+            case "whiteboard-cursor":
+                this.handleCursor(sender, message.cursor);
+                return;
+            case "chat": {
+                const chat = parseChat(message.chat);
+                if (chat) {
+                    this.addChat({ ...chat, peer: sender, name: this.names.get(sender) ?? "Guest" }, false);
+                }
+                return;
+            }
+            case "whiteboard": {
+                const op = parseWhiteboardOp(message.whiteboard);
+                if (op && this.mayDraw(sender) && this.board.apply(op, sender)) {
+                    this.emit({ type: "board" });
+                    this.followStroke(sender, op);
+                }
+                return;
+            }
+            case "collab-sync-request":
+                this.sendSync(sender);
+                return;
+            case "collab-sync":
+                this.receiveSync(sender, message.sync);
+                return;
+        }
+    }
+    handleHello(sender, name) {
+        if (typeof name === "string" && name) {
+            const known = this.names.has(sender);
+            this.names.set(sender, name);
+            // Chat that beat this participant's `hello` was shown as "Guest" - give it their name now.
+            if (!known && this.chatEntries.some((entry) => entry.peer === sender && entry.name === "Guest")) {
+                this.chatEntries = this.chatEntries.map((entry) => (entry.peer === sender && entry.name === "Guest" ? { ...entry, name } : entry));
+                const own = this.chatEntries.filter((entry) => entry.peer === sender);
+                const renamed = own[own.length - 1];
+                this.emit({ type: "chat", entry: renamed, renamed: true });
+            }
+        }
+        if (!this.knownPeers.includes(sender)) {
+            this.knownPeers.push(sender);
+        }
+        if (this.syncTarget === undefined && this.syncTried.size === 0 && this.now() - this.startedAt < SYNC_WINDOW_MS) {
+            this.requestSync(sender);
+        }
+    }
+    requestSync(peer) {
+        this.syncTarget = peer;
+        this.syncTried.add(peer);
+        this.syncReceivedAnything = false;
+        this.send({ kind: "collab-sync-request", to: peer });
+        this.armSyncTimeout();
+    }
+    /** Asks the next participant not yet asked, if any - after a silence or an empty answer. */
+    askNext() {
+        this.syncTarget = undefined;
+        const next = this.knownPeers.find((candidate) => !this.syncTried.has(candidate));
+        if (next) {
+            this.requestSync(next);
+        }
+    }
+    armSyncTimeout() {
+        clearTimeout(this.syncTimer);
+        this.syncTimer = setTimeout(() => {
+            this.syncTimer = undefined;
+            this.askNext();
+        }, SYNC_TIMEOUT_MS);
+    }
+    receiveSync(sender, raw) {
+        if (sender !== this.syncTarget) {
+            return;
+        }
+        const sync = parseSync(raw);
+        if (!sync) {
+            return;
+        }
+        this.syncReceivedAnything || (this.syncReceivedAnything = sync.chat.length > 0 || sync.ops.length > 0 || sync.epoch > 0);
+        let boardChanged = this.board.apply({ op: "clear", epoch: sync.epoch }, null);
+        for (const op of sync.ops) {
+            boardChanged = this.board.apply(op, null) || boardChanged;
+        }
+        if (boardChanged) {
+            this.emit({ type: "board" });
+        }
+        this.mergeHistory(sync.chat);
+        if (sync.part < sync.of - 1) {
+            this.armSyncTimeout();
+            return;
+        }
+        clearTimeout(this.syncTimer);
+        this.syncTimer = undefined;
+        if (this.syncReceivedAnything) {
+            this.syncTarget = undefined;
+        }
+        else {
+            // Nothing at all - likely another newcomer who had nothing yet either. Someone else may have more.
+            this.askNext();
+        }
+    }
+    /** Sends `peer` everything said and drawn so far - see this module's doc comment. */
+    sendSync(peer) {
+        const answeredAt = this.syncAnswered.get(peer);
+        if (answeredAt !== undefined && this.now() - answeredAt < SYNC_ANSWER_COOLDOWN_MS) {
+            return;
+        }
+        this.syncAnswered.set(peer, this.now());
+        const budget = (this.options.channel.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES) - SYNC_ENVELOPE_BYTES;
+        const encoder = new TextEncoder();
+        const parts = [];
+        let current = { chat: [], ops: [] };
+        let used = 0;
+        const place = (item) => {
+            const size = encoder.encode(JSON.stringify(item.chat ?? item.op)).length + 1;
+            if (used + size > budget && used > 0) {
+                parts.push(current);
+                current = { chat: [], ops: [] };
+                used = 0;
+            }
+            if (item.chat) {
+                current.chat.push(item.chat);
+            }
+            else {
+                current.ops.push(item.op);
+            }
+            used += size;
+        };
+        for (const entry of this.chatEntries) {
+            place({ chat: { id: entry.id, peer: entry.peer, name: entry.name, text: entry.text, sentAt: entry.sentAt } });
+        }
+        for (const op of this.board.toOps(SYNC_POINTS_PER_OP)) {
+            place({ op });
+        }
+        parts.push(current);
+        const epoch = this.board.epoch;
+        parts.forEach((part, index) => {
+            const timer = setTimeout(() => {
+                this.timers.delete(timer);
+                this.send({ kind: "collab-sync", to: peer, sync: { part: index, of: parts.length, epoch, ...part } });
+            }, index * SYNC_PACE_MS);
+            this.timers.add(timer);
+        });
+    }
+    mergeHistory(history) {
+        const fresh = [];
+        for (const entry of history) {
+            const key = `${entry.peer}:${entry.id}`;
+            if (!this.chatKeys.has(key)) {
+                this.chatKeys.add(key);
+                fresh.push({ ...entry, key, self: entry.peer === this.options.peerId });
+            }
+        }
+        if (fresh.length === 0) {
+            return;
+        }
+        // History comes before whatever arrived live while it travelled, and after the history of earlier parts.
+        const merged = [...this.chatEntries.slice(0, this.historyCount), ...fresh, ...this.chatEntries.slice(this.historyCount)];
+        this.historyCount += fresh.length;
+        this.setChat(merged);
+        for (const entry of fresh) {
+            this.emit({ type: "chat", entry, history: true });
+        }
+    }
+    addChat(entry, self) {
+        const key = `${entry.peer}:${entry.id}`;
+        if (this.chatKeys.has(key)) {
+            return;
+        }
+        this.chatKeys.add(key);
+        const full = { ...entry, key, self };
+        this.setChat([...this.chatEntries, full]);
+        this.emit({ type: "chat", entry: full });
+    }
+    /** Keeps the latest `MAX_CHAT_HISTORY` of `entries`. */
+    setChat(entries) {
+        const dropped = Math.max(0, entries.length - MAX_CHAT_HISTORY);
+        this.chatEntries = entries.slice(dropped);
+        this.historyCount = Math.max(0, this.historyCount - dropped);
+    }
+    send(partial) {
+        if (this.stopped) {
+            return;
+        }
+        this.options.channel.send({ type: "video-meeting-signal", from: this.options.selfUid, peer: this.options.peerId, ...partial });
+    }
+    emit(event) {
+        for (const listener of [...this.listeners]) {
+            listener(event);
+        }
+    }
+    nextId() {
+        this.seq += 1;
+        return `${this.now().toString(36)}-${this.seq}`;
+    }
+    nextElementId() {
+        return `${this.options.peerId}:${this.nextId()}`;
+    }
+    now() {
+        return (this.options.now ?? Date.now)();
+    }
+}
+function clampX(x) {
+    return clampCoordinate(x, BOARD_WIDTH);
+}
+function clampY(y) {
+    return clampCoordinate(y, BOARD_HEIGHT);
+}

package/dist/apps/shared/collab/WhiteboardModel.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The shared whiteboard's state: its elements in drawing order and its epoch, changed only by `apply()`ing
+ * `WhiteboardOp`s - this participant's own as much as everyone else's, so every participant's board is built the same
+ * way from the same ops. See `protocol.ts` for the rules an op is held to (who may add to which element, what the
+ * epoch is for).
+ *
+ * Ops reach a participant in whatever order the network delivers them, and a newcomer's catch-up races the live ops
+ * sent while it travels, so `apply()` is built to give the same board whatever the order:
+ *
+ * - `points` for a stroke that hasn't arrived yet, or that start past the points it has so far, wait (a bounded
+ * number of them) and are applied the moment the gap is filled. Points already held are kept as they are.
+ * - An `add` for an element already on the board adds only what it has beyond it (more points) - a catch-up repeating
+ * what live ops already brought is harmless.
+ * - A removed element stays removed: its id is remembered, so a catch-up sent before the erase cannot bring it back.
+ */
+import { type BoardElement, type WhiteboardOp } from "./protocol.js";
+/** The most `points` ops held while their stroke, or the points before them, are still missing. */
+export declare const MAX_PENDING_POINT_OPS = 400;
+/** The most removed ids remembered. */
+export declare const MAX_TOMBSTONES = 10000;
+export declare class WhiteboardModel {
+    private readonly byId;
+    private readonly pending;
+    private readonly tombstones;
+    private currentEpoch;
+    /** Bumped on every change, so a view can tell whether it needs to draw again. */
+    private rev;
+    get epoch(): number;
+    get revision(): number;
+    /** Every element, in drawing order (oldest first). */
+    get elements(): BoardElement[];
+    get size(): number;
+    get(id: string): BoardElement | undefined;
+    /** Whether one more element fits on the board. */
+    get hasRoom(): boolean;
+    /**
+     * Applies `op` - sent by peer `author`, or, for `null`, carried by a catch-up on its authors' behalf (it names no
+     * single author; see `CollabSession` on how far a catch-up is trusted). Returns whether the board changed.
+     */
+    apply(op: WhiteboardOp, author: string | null): boolean;
+    /** The ops that rebuild this board from nothing - a newcomer's catch-up. A long stroke is split into an `add` and
+     * `points` ops of at most `pointsPerOp` points each (never more than `MAX_POINTS_PER_OP`). */
+    toOps(pointsPerOp?: number): WhiteboardOp[];
+    private add;
+    private points;
+    /** Writes `points` into `stroke` from point index `start`, then whatever was waiting for them. */
+    private writePoints;
+    private hold;
+    /** Applies every held `points` op for `stroke` that now connects to what it has. */
+    private drainPending;
+    private remove;
+    private clear;
+    private changed;
+}