@mocanvas/sync 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Symbio Digital
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,142 @@
+# @mocanvas/sync
+
+Multiplayer for a mocanvas store: document changes travel as record diffs,
+cursors and selections travel as presence records.
+
+Part of [mocanvas](https://github.com/SYMBIO/mocanvas).
+
+## Install
+
+```bash
+npm install @mocanvas/sync react
+```
+
+`react` (>= 18) is a peer dependency, used by `useSync` and
+`<CollaboratorCursors />`.
+
+## Quick start
+
+```ts
+import { createSyncClient, createBroadcastChannelTransport } from "@mocanvas/sync"
+
+const client = createSyncClient({
+  store: editor.store,
+  roomId: "my-doc",
+  transport: createBroadcastChannelTransport("my-doc"),
+  presence: { editor },
+})
+client.connect()
+```
+
+`getStatus()` returns a signal holding `"offline" | "connecting" | "online"`,
+so it can be read from a reactor or with `useValue`. `dispose()` disconnects
+and closes the transport.
+
+## Integration
+
+Three lines in an app that already renders `<Mocanvas>`:
+
+```tsx
+const { status } = useSync(editor, { roomId, transport: () => createBroadcastChannelTransport(roomId) })
+// ...inside <Mocanvas onMount={setEditor}>:
+{editor ? <CollaboratorCursors editor={editor} /> : null}
+```
+
+`CollaboratorCursors` draws every other person's pointer, name chip and
+selection outlines in screen space. It positions itself absolutely, so it goes
+anywhere inside the canvas container.
+
+## Protocol
+
+Every message is one JSON object on the wire.
+
+| message    | fields                       | meaning                                              |
+| ---------- | ---------------------------- | ---------------------------------------------------- |
+| `hello`    | `clientId`, `version`        | I joined. Established peers answer with a `snapshot`. |
+| `snapshot` | `records`                    | Every document-scope record as the sender sees them.  |
+| `diff`     | `clientId`, `seq`, `diff`    | One squashed `RecordsDiff` of document records.       |
+| `presence` | `clientId`, `record`         | The sender's `instance_presence` record.              |
+| `bye`      | `clientId`                   | I am leaving; drop my presence.                       |
+
+- Outgoing diffs come from `store.listen(cb, { source: "user", scope: "document" })`,
+  so nothing applied from a peer is ever echoed back and nothing in `session`
+  or `presence` scope is persisted into the document stream.
+- Incoming diffs are applied inside
+  `store.mergeRemoteChanges(() => store.applyDiff(diff))`, which marks them
+  `source: "remote"`: they do not enter the local undo stack and do not
+  re-broadcast.
+- A newcomer applies the first `snapshot` it is offered and ignores the rest.
+  Answering a `hello` makes a peer "established", so a snapshot meant for
+  someone else can never overwrite its work.
+- Presence records are derived from the editor's camera,
+  `inputs.currentPagePoint` and selection, throttled to at most 30 Hz, and
+  re-sent on a heartbeat. A collaborator is dropped on `bye` or after 10s of
+  silence.
+- `decodeMessage` returns `null` for anything malformed, so a peer running a
+  different version cannot crash this one. `PROTOCOL_VERSION` is checked on
+  `hello`.
+
+## Conflict policy: last writer wins, per record
+
+There is no operational transform and no CRDT here. Diffs are applied in
+arrival order and the last write to a record id is the one that survives.
+
+What that means in practice:
+
+- Two people dragging **different** shapes is always fine.
+- Two people dragging the **same** shape converge on whoever sent last; the
+  other person's drag is discarded, not merged.
+- Concurrent edits to **different fields of the same record** (one person
+  moves a shape while another recolours it) lose one of the two changes: a
+  record is replaced wholesale, not merged field by field.
+- A delete racing an update can resurrect the record: the update carries the
+  full record and is applied after the removal.
+- Peers that were offline while others edited rejoin with `hello` and take a
+  peer's snapshot, so anything they changed offline is overwritten.
+
+This is enough for cursors-and-shapes collaboration on a small trusted room.
+Anything needing real convergence guarantees wants a server-authoritative log
+or a CRDT under `applyDiff`; the transport and message types here do not have
+to change for that.
+
+## Transports
+
+```ts
+createBroadcastChannelTransport(roomId)              // tabs of one browser, no server
+createWebSocketTransport(url, { reconnect: true })   // a relay; exponential backoff with jitter
+createMemoryTransportPair()                          // two peers in one process (tests)
+createMemoryHub()                                    // n peers in one process (tests)
+```
+
+A `Transport` is `{ send, onMessage, onOpen?, onClose?, close }` and owns its
+own serialization and reconnection. Anything implementing that interface works
+— a WebRTC data channel, a shared worker, a mock.
+
+## Running the relay
+
+The relay forwards messages between the sockets in a room and keeps no state,
+so restarting it is harmless: peers re-share the document with
+`hello`/`snapshot`. The room is the URL path.
+
+```sh
+pnpm --filter @mocanvas/sync relay        # ws://localhost:5858/<room>
+PORT=9000 pnpm --filter @mocanvas/sync relay
+```
+
+```ts
+createWebSocketTransport(`ws://localhost:5858/${roomId}`, { reconnect: true })
+```
+
+The relay script ships in the package but `ws` does not — it is a
+devDependency here, because the relay is a development tool and not part of
+the client. Install `ws` yourself to run it outside this repository.
+
+## Tests
+
+```sh
+pnpm --filter @mocanvas/sync test
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,278 @@
+import { Signal } from '@mocanvas/state';
+import { Store, UnknownRecord, RecordsDiff } from '@mocanvas/store';
+import { InstancePresence, InstancePresenceId, Editor } from '@mocanvas/editor';
+import * as react from 'react';
+
+/** Presence is sent at most this often (30 Hz). */
+declare const DEFAULT_PRESENCE_THROTTLE_MS: number;
+/** A presence record is re-sent this often even when nothing changed. */
+declare const DEFAULT_PRESENCE_HEARTBEAT_MS = 3000;
+/** A collaborator we have not heard from in this long is dropped. */
+declare const DEFAULT_PRESENCE_TIMEOUT_MS = 10000;
+/**
+ * The part of the editor presence reads. Declared structurally so that the
+ * sync layer does not need a live `Editor` (and its WASM engine) to be tested.
+ */
+interface PresenceEditor {
+    readonly store: Store<any, any>;
+    readonly inputs: {
+        readonly currentPagePoint: {
+            x: number;
+            y: number;
+        };
+    };
+    readonly user: {
+        getId(): string;
+        getName(): string;
+        getColor(): string;
+    };
+    getCurrentPageId(): string;
+    getCamera(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    getSelectedShapeIds(): readonly string[];
+    getInstanceState(): {
+        cursor: {
+            type: string;
+            rotation: number;
+        };
+        brush: {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        } | null;
+        scribbles: readonly unknown[];
+        followingUserId: string | null;
+    };
+    /** Optional: used to sample the cursor, which is not itself a signal. */
+    on?(name: "event", fn: () => void): () => void;
+}
+interface PresenceSyncOptions {
+    editor: PresenceEditor;
+    /** Identifies this tab; one user may have several. */
+    clientId: string;
+    send(record: InstancePresence): void;
+    throttleMs?: number;
+    heartbeatMs?: number;
+}
+interface PresenceSync {
+    start(): void;
+    stop(): void;
+    /** Ask for a send; collapses with any other request inside the throttle window. */
+    poke(): void;
+    /** The record last handed to `send`, for tests and debugging. */
+    getLastSent(): InstancePresence | null;
+    dispose(): void;
+}
+/** The id a client's presence record always uses, so updates overwrite in place. */
+declare function presenceIdForClient(clientId: string): InstancePresenceId;
+/**
+ * Watches the editor and pushes the local presence record out, at most once per
+ * throttle window, plus a heartbeat so that idle collaborators do not time out.
+ */
+declare function createPresenceSync(options: PresenceSyncOptions): PresenceSync;
+/** Equal apart from `lastActivityTimestamp`, which always moves. */
+declare function isSamePresence(a: InstancePresence, b: InstancePresence): boolean;
+/**
+ * Holds the presence records of everyone else: puts them in the store as they
+ * arrive, drops them on `bye`, and sweeps clients that went quiet.
+ */
+declare class PresenceRoom<R extends UnknownRecord> {
+    private readonly store;
+    private readonly timeoutMs;
+    private readonly seen;
+    private sweeper;
+    constructor(store: Store<R, any>, timeoutMs?: number);
+    /** Store an incoming presence record and remember when we saw its client. */
+    receive(clientId: string, record: R): void;
+    /** Drop one client's presence (it said goodbye). */
+    remove(clientId: string): void;
+    /** Drop every client we have not heard from within the timeout. */
+    sweep(now?: number): void;
+    startSweeping(intervalMs?: number): void;
+    stopSweeping(): void;
+    /** Remove every record this room put in the store. */
+    clear(): void;
+    private removeRecord;
+}
+
+/** Bumped when the wire format changes incompatibly. */
+declare const PROTOCOL_VERSION = 1;
+/**
+ * Every message is one JSON object with a `type` discriminator.
+ *
+ * ```
+ * hello     a client joined; existing peers answer with a snapshot
+ * snapshot  the document-scope records as the sender currently sees them
+ * diff      one squashed store diff, in document scope
+ * presence  one presence record (cursor, camera, selection)
+ * bye       the client is leaving; drop its presence
+ * ```
+ */
+type SyncMessage<R extends UnknownRecord = UnknownRecord> = HelloMessage | SnapshotMessage<R> | DiffMessage<R> | PresenceMessage<R> | ByeMessage;
+interface HelloMessage {
+    type: "hello";
+    clientId: string;
+    version: number;
+}
+interface SnapshotMessage<R extends UnknownRecord = UnknownRecord> {
+    type: "snapshot";
+    records: R[];
+}
+interface DiffMessage<R extends UnknownRecord = UnknownRecord> {
+    type: "diff";
+    clientId: string;
+    /** Per-client counter; only used for logging and de-duplication. */
+    seq: number;
+    diff: RecordsDiff<R>;
+}
+interface PresenceMessage<R extends UnknownRecord = UnknownRecord> {
+    type: "presence";
+    clientId: string;
+    record: R;
+}
+interface ByeMessage {
+    type: "bye";
+    clientId: string;
+}
+declare function encodeMessage<R extends UnknownRecord>(message: SyncMessage<R>): string;
+/**
+ * Parse a message off the wire. Returns `null` for anything malformed: a peer
+ * on a newer protocol must never be able to crash this one.
+ */
+declare function decodeMessage<R extends UnknownRecord = UnknownRecord>(data: unknown): SyncMessage<R> | null;
+
+/**
+ * A duplex channel that carries `SyncMessage`s between peers in one room.
+ *
+ * The transport owns serialization and reconnection; the client above it only
+ * sees decoded messages. `onOpen` fires every time the channel becomes usable
+ * (including after a reconnect), `onClose` every time it stops being usable.
+ * A transport with neither is treated as open from the moment it is connected.
+ */
+interface Transport<R extends UnknownRecord = UnknownRecord> {
+    send(message: SyncMessage<R>): void;
+    onMessage(callback: (message: SyncMessage<R>) => void): () => void;
+    onOpen?(callback: () => void): () => void;
+    onClose?(callback: () => void): () => void;
+    close(): void;
+}
+interface BroadcastChannelTransportOptions {
+    /** Channel name prefix, so two apps on one origin do not collide. */
+    prefix?: string;
+}
+/**
+ * Same-origin tabs of one browser. There is no server, so every peer is
+ * equally authoritative and the channel is open as soon as it is created.
+ */
+declare function createBroadcastChannelTransport<R extends UnknownRecord = UnknownRecord>(roomId: string, options?: BroadcastChannelTransportOptions): Transport<R>;
+interface WebSocketTransportOptions {
+    /** Reconnect with exponential backoff after an unexpected close. Default `true`. */
+    reconnect?: boolean;
+    /** First backoff delay in ms. Default 500. */
+    minDelayMs?: number;
+    /** Backoff ceiling in ms. Default 15000. */
+    maxDelayMs?: number;
+    /** Injectable for tests and for Node (`ws`). Defaults to `globalThis.WebSocket`. */
+    WebSocketImpl?: typeof WebSocket;
+}
+/**
+ * A WebSocket to a relay (see `scripts/relay.mjs`). Messages sent while the
+ * socket is down are dropped rather than queued: the next `hello`/`snapshot`
+ * exchange re-establishes the document anyway, and presence is re-sent on a
+ * heartbeat.
+ */
+declare function createWebSocketTransport<R extends UnknownRecord = UnknownRecord>(url: string, options?: WebSocketTransportOptions): Transport<R>;
+/**
+ * Two transports wired to each other, going through the same JSON encode and
+ * decode as the real ones. Delivery is asynchronous (a microtask) so that a
+ * peer never observes a message inside its own `send()` call stack.
+ */
+declare function createMemoryTransportPair<R extends UnknownRecord = UnknownRecord>(): [Transport<R>, Transport<R>];
+interface MemoryHub<R extends UnknownRecord = UnknownRecord> {
+    /** Add another peer to the room. */
+    join(): Transport<R>;
+}
+/** A room every joined transport broadcasts into (itself excluded). */
+declare function createMemoryHub<R extends UnknownRecord = UnknownRecord>(): MemoryHub<R>;
+
+type SyncStatus = "offline" | "connecting" | "online";
+interface SyncClientOptions<R extends UnknownRecord = UnknownRecord> {
+    store: Store<R, any>;
+    /** Identifies the document. The transport is expected to be scoped to it too. */
+    roomId: string;
+    transport: Transport<R>;
+    /** Turn on cursor/selection sharing for an editor. */
+    presence?: {
+        editor: PresenceEditor;
+    } | undefined;
+    /** Defaults to a fresh random id; one per tab, not per user. */
+    clientId?: string | undefined;
+    /** Drop a collaborator after this long without a presence message. Default 10s. */
+    presenceTimeoutMs?: number | undefined;
+    /** Upper bound on presence send rate. Default 34ms (~30 Hz). */
+    presenceThrottleMs?: number | undefined;
+    presenceHeartbeatMs?: number | undefined;
+    /** Called for protocol-level problems (a peer on another version, say). */
+    onError?: ((error: Error) => void) | undefined;
+}
+interface SyncClient {
+    readonly clientId: string;
+    readonly roomId: string;
+    connect(): void;
+    disconnect(): void;
+    /** A signal, so React and reactors can follow the connection. */
+    getStatus(): Signal<SyncStatus>;
+    dispose(): void;
+}
+/**
+ * Joins one room over `transport` and keeps `store` in step with its peers.
+ *
+ * Document changes made locally by the user are broadcast as diffs; incoming
+ * diffs are applied as remote changes so they neither echo back nor land in
+ * the undo stack. Conflicts are resolved last-writer-wins per record.
+ */
+declare function createSyncClient<R extends UnknownRecord = UnknownRecord>(options: SyncClientOptions<R>): SyncClient;
+
+interface CollaboratorCursorsProps {
+    editor: Editor;
+    /** Draw what each collaborator has selected. Default `true`. */
+    showSelection?: boolean;
+    /** Draw a name chip next to each cursor. Default `true`. */
+    showNames?: boolean;
+}
+/**
+ * Other people's cursors and selections, drawn in screen space above the
+ * canvas. Drop it inside `<Mocanvas>` or `<Canvas>`; it positions itself.
+ */
+declare const CollaboratorCursors: ({ editor, showSelection, showNames, }: CollaboratorCursorsProps) => react.JSX.Element | null;
+interface UseSyncOptions {
+    roomId: string;
+    /**
+     * The channel to the room. Pass a factory when the transport should be
+     * recreated with the room (the usual case); it is read once per connection.
+     */
+    transport: Transport | (() => Transport);
+    /** Share this editor's cursor and selection. Default `true`. */
+    presence?: boolean;
+    /** Set `false` to stay offline (a read-only view, say). Default `true`. */
+    enabled?: boolean;
+    clientId?: string;
+    presenceTimeoutMs?: number;
+    presenceThrottleMs?: number;
+    onError?: (error: Error) => void;
+}
+interface UseSyncResult {
+    status: SyncStatus;
+    client: SyncClient | null;
+}
+/**
+ * Connect an editor's store to a room for as long as the component is mounted.
+ * Everything is torn down (including the transport) on unmount.
+ */
+declare function useSync(editor: Editor | null, options: UseSyncOptions): UseSyncResult;
+
+export { type BroadcastChannelTransportOptions, type ByeMessage, CollaboratorCursors, type CollaboratorCursorsProps, DEFAULT_PRESENCE_HEARTBEAT_MS, DEFAULT_PRESENCE_THROTTLE_MS, DEFAULT_PRESENCE_TIMEOUT_MS, type DiffMessage, type HelloMessage, type MemoryHub, PROTOCOL_VERSION, type PresenceEditor, type PresenceMessage, PresenceRoom, type PresenceSync, type PresenceSyncOptions, type SnapshotMessage, type SyncClient, type SyncClientOptions, type SyncMessage, type SyncStatus, type Transport, type UseSyncOptions, type UseSyncResult, type WebSocketTransportOptions, createBroadcastChannelTransport, createMemoryHub, createMemoryTransportPair, createPresenceSync, createSyncClient, createWebSocketTransport, decodeMessage, encodeMessage, isSamePresence, presenceIdForClient, useSync };

package/dist/index.js

@@ -0,0 +1,660 @@
+import { react, atom } from '@mocanvas/state';
+import { uniqueId, isRecordsDiffEmpty } from '@mocanvas/store';
+import { InstancePresenceRecordType } from '@mocanvas/editor';
+import { track, useValue } from '@mocanvas/state/react';
+import { useRef, useState, useEffect } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+// src/SyncClient.ts
+var DEFAULT_PRESENCE_THROTTLE_MS = Math.ceil(1e3 / 30);
+var DEFAULT_PRESENCE_HEARTBEAT_MS = 3e3;
+var DEFAULT_PRESENCE_TIMEOUT_MS = 1e4;
+function presenceIdForClient(clientId) {
+  return InstancePresenceRecordType.createId(clientId);
+}
+function createPresenceSync(options) {
+  const { editor, clientId, send } = options;
+  const throttleMs = options.throttleMs ?? DEFAULT_PRESENCE_THROTTLE_MS;
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_PRESENCE_HEARTBEAT_MS;
+  const id = presenceIdForClient(clientId);
+  let timer = null;
+  let heartbeat = null;
+  let stopReactor = null;
+  let stopEvents = null;
+  let last = null;
+  let running = false;
+  const build = () => {
+    const instance = editor.getInstanceState();
+    const point = editor.inputs.currentPagePoint;
+    return InstancePresenceRecordType.create({
+      id,
+      userId: editor.user.getId(),
+      userName: editor.user.getName(),
+      color: editor.user.getColor(),
+      currentPageId: editor.getCurrentPageId(),
+      cursor: { x: point.x, y: point.y, type: instance.cursor.type, rotation: instance.cursor.rotation },
+      camera: { ...editor.getCamera() },
+      selectedShapeIds: [...editor.getSelectedShapeIds()],
+      brush: instance.brush ? { ...instance.brush } : null,
+      scribbles: [...instance.scribbles],
+      followingUserId: instance.followingUserId,
+      lastActivityTimestamp: Date.now(),
+      chatMessage: "",
+      meta: {}
+    });
+  };
+  const flush = (force) => {
+    if (!running) return;
+    const next = build();
+    if (!force && last && isSamePresence(last, next)) return;
+    last = next;
+    send(next);
+  };
+  const poke = () => {
+    if (!running || timer !== null) return;
+    timer = setTimeout(() => {
+      timer = null;
+      flush(false);
+    }, throttleMs);
+  };
+  return {
+    start() {
+      if (running) return;
+      running = true;
+      stopReactor = react("sync.presence", () => {
+        editor.getCamera();
+        editor.getCurrentPageId();
+        editor.getSelectedShapeIds();
+        editor.getInstanceState();
+        editor.user.getName();
+        editor.user.getColor();
+        poke();
+      });
+      stopEvents = editor.on?.("event", poke) ?? null;
+      heartbeat = setInterval(() => flush(true), heartbeatMs);
+      flush(true);
+    },
+    stop() {
+      running = false;
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (heartbeat !== null) {
+        clearInterval(heartbeat);
+        heartbeat = null;
+      }
+      stopReactor?.();
+      stopReactor = null;
+      stopEvents?.();
+      stopEvents = null;
+    },
+    poke,
+    getLastSent: () => last,
+    dispose() {
+      this.stop();
+      last = null;
+    }
+  };
+}
+function isSamePresence(a, b) {
+  return a.userId === b.userId && a.userName === b.userName && a.color === b.color && a.currentPageId === b.currentPageId && a.chatMessage === b.chatMessage && a.followingUserId === b.followingUserId && a.cursor.x === b.cursor.x && a.cursor.y === b.cursor.y && a.cursor.type === b.cursor.type && a.cursor.rotation === b.cursor.rotation && a.camera.x === b.camera.x && a.camera.y === b.camera.y && a.camera.z === b.camera.z && sameIds(a.selectedShapeIds, b.selectedShapeIds) && sameBrush(a.brush, b.brush) && a.scribbles.length === b.scribbles.length && a.scribbles.every((s, i) => s === b.scribbles[i]);
+}
+function sameIds(a, b) {
+  return a.length === b.length && a.every((id, i) => id === b[i]);
+}
+function sameBrush(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+var PresenceRoom = class {
+  constructor(store, timeoutMs = DEFAULT_PRESENCE_TIMEOUT_MS) {
+    this.store = store;
+    this.timeoutMs = timeoutMs;
+  }
+  store;
+  timeoutMs;
+  seen = /* @__PURE__ */ new Map();
+  sweeper = null;
+  /** Store an incoming presence record and remember when we saw its client. */
+  receive(clientId, record) {
+    const previous = this.seen.get(clientId);
+    if (previous && previous.id !== record.id) this.removeRecord(previous.id);
+    this.seen.set(clientId, { id: record.id, at: Date.now() });
+    this.store.mergeRemoteChanges(() => {
+      this.store.put([record]);
+    });
+  }
+  /** Drop one client's presence (it said goodbye). */
+  remove(clientId) {
+    const entry = this.seen.get(clientId);
+    if (!entry) return;
+    this.seen.delete(clientId);
+    this.removeRecord(entry.id);
+  }
+  /** Drop every client we have not heard from within the timeout. */
+  sweep(now = Date.now()) {
+    const stale = [];
+    for (const [clientId, entry] of this.seen) {
+      if (now - entry.at > this.timeoutMs) stale.push(clientId);
+    }
+    for (const clientId of stale) this.remove(clientId);
+  }
+  startSweeping(intervalMs = Math.max(1e3, Math.floor(this.timeoutMs / 4))) {
+    if (this.sweeper !== null) return;
+    this.sweeper = setInterval(() => this.sweep(), intervalMs);
+  }
+  stopSweeping() {
+    if (this.sweeper === null) return;
+    clearInterval(this.sweeper);
+    this.sweeper = null;
+  }
+  /** Remove every record this room put in the store. */
+  clear() {
+    const ids = Array.from(this.seen.values(), (entry) => entry.id);
+    this.seen.clear();
+    for (const id of ids) this.removeRecord(id);
+  }
+  removeRecord(id) {
+    const recordId = id;
+    if (!this.store.unsafeGetWithoutCapture(recordId)) return;
+    this.store.mergeRemoteChanges(() => {
+      this.store.remove([recordId]);
+    });
+  }
+};
+
+// src/protocol.ts
+var PROTOCOL_VERSION = 1;
+function encodeMessage(message) {
+  return JSON.stringify(message);
+}
+function decodeMessage(data) {
+  let value = data;
+  if (typeof data === "string") {
+    try {
+      value = JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  if (typeof value !== "object" || value === null) return null;
+  const message = value;
+  switch (message["type"]) {
+    case "hello":
+      if (typeof message["clientId"] !== "string") return null;
+      if (typeof message["version"] !== "number") return null;
+      return { type: "hello", clientId: message["clientId"], version: message["version"] };
+    case "snapshot": {
+      const records = message["records"];
+      if (!Array.isArray(records)) return null;
+      if (!records.every(isRecordLike)) return null;
+      return { type: "snapshot", records };
+    }
+    case "diff": {
+      if (typeof message["clientId"] !== "string") return null;
+      if (typeof message["seq"] !== "number") return null;
+      if (!isDiffLike(message["diff"])) return null;
+      return {
+        type: "diff",
+        clientId: message["clientId"],
+        seq: message["seq"],
+        diff: message["diff"]
+      };
+    }
+    case "presence": {
+      if (typeof message["clientId"] !== "string") return null;
+      if (!isRecordLike(message["record"])) return null;
+      return { type: "presence", clientId: message["clientId"], record: message["record"] };
+    }
+    case "bye":
+      if (typeof message["clientId"] !== "string") return null;
+      return { type: "bye", clientId: message["clientId"] };
+    default:
+      return null;
+  }
+}
+function isRecordLike(value) {
+  return typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.typeName === "string";
+}
+function isDiffLike(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const diff = value;
+  for (const key of ["added", "updated", "removed"]) {
+    const part = diff[key];
+    if (typeof part !== "object" || part === null || Array.isArray(part)) return false;
+  }
+  return true;
+}
+
+// src/SyncClient.ts
+function createSyncClient(options) {
+  const { store, roomId, transport } = options;
+  const clientId = options.clientId ?? uniqueId(12);
+  const status = atom(`sync.status:${roomId}`, "offline");
+  const room = new PresenceRoom(store, options.presenceTimeoutMs ?? DEFAULT_PRESENCE_TIMEOUT_MS);
+  const unsubscribes = [];
+  let presence = null;
+  let seq = 0;
+  let awaitingSnapshot = false;
+  let connected = false;
+  let disposed = false;
+  const send = (message) => {
+    try {
+      transport.send(message);
+    } catch (error) {
+      options.onError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  };
+  const handle = (message) => {
+    if (disposed) return;
+    switch (message.type) {
+      case "hello": {
+        if (message.clientId === clientId) return;
+        if (message.version !== PROTOCOL_VERSION) {
+          options.onError?.(
+            new Error(`Peer ${message.clientId} speaks protocol ${message.version}, we speak ${PROTOCOL_VERSION}`)
+          );
+          return;
+        }
+        awaitingSnapshot = false;
+        send({ type: "snapshot", records: Object.values(store.serialize("document")) });
+        presence?.poke();
+        return;
+      }
+      case "snapshot": {
+        if (!awaitingSnapshot) return;
+        awaitingSnapshot = false;
+        store.mergeRemoteChanges(() => {
+          store.put(message.records);
+        });
+        return;
+      }
+      case "diff": {
+        if (message.clientId === clientId) return;
+        if (isRecordsDiffEmpty(message.diff)) return;
+        store.mergeRemoteChanges(() => {
+          store.applyDiff(message.diff);
+        });
+        return;
+      }
+      case "presence": {
+        if (message.clientId === clientId) return;
+        room.receive(message.clientId, message.record);
+        return;
+      }
+      case "bye": {
+        if (message.clientId === clientId) return;
+        room.remove(message.clientId);
+        return;
+      }
+    }
+  };
+  const onOpen = () => {
+    if (disposed || !connected) return;
+    status.set("online");
+    send({ type: "hello", clientId, version: PROTOCOL_VERSION });
+    presence?.poke();
+  };
+  const onClose = () => {
+    if (disposed || !connected) return;
+    status.set("connecting");
+  };
+  return {
+    clientId,
+    roomId,
+    connect() {
+      if (disposed || connected) return;
+      connected = true;
+      awaitingSnapshot = true;
+      status.set("connecting");
+      unsubscribes.push(transport.onMessage(handle));
+      if (transport.onOpen) unsubscribes.push(transport.onOpen(onOpen));
+      if (transport.onClose) unsubscribes.push(transport.onClose(onClose));
+      unsubscribes.push(
+        store.listen(
+          (entry) => {
+            if (isRecordsDiffEmpty(entry.changes)) return;
+            send({ type: "diff", clientId, seq: seq++, diff: entry.changes });
+          },
+          { source: "user", scope: "document" }
+        )
+      );
+      if (options.presence) {
+        presence = createPresenceSync({
+          editor: options.presence.editor,
+          clientId,
+          send: (record) => send({ type: "presence", clientId, record }),
+          ...options.presenceThrottleMs !== void 0 ? { throttleMs: options.presenceThrottleMs } : {},
+          ...options.presenceHeartbeatMs !== void 0 ? { heartbeatMs: options.presenceHeartbeatMs } : {}
+        });
+        presence.start();
+      }
+      room.startSweeping();
+      if (!transport.onOpen) onOpen();
+    },
+    disconnect() {
+      if (!connected) return;
+      connected = false;
+      send({ type: "bye", clientId });
+      presence?.stop();
+      presence = null;
+      room.stopSweeping();
+      room.clear();
+      for (const off of unsubscribes.splice(0)) off();
+      awaitingSnapshot = false;
+      status.set("offline");
+    },
+    getStatus() {
+      return status;
+    },
+    dispose() {
+      if (disposed) return;
+      this.disconnect();
+      disposed = true;
+      transport.close();
+    }
+  };
+}
+
+// src/transport.ts
+function createEmitter() {
+  const callbacks = /* @__PURE__ */ new Set();
+  return {
+    add(cb) {
+      callbacks.add(cb);
+      return () => {
+        callbacks.delete(cb);
+      };
+    },
+    emit() {
+      for (const cb of Array.from(callbacks)) cb();
+    },
+    clear() {
+      callbacks.clear();
+    }
+  };
+}
+function createBroadcastChannelTransport(roomId, options = {}) {
+  const name = `${options.prefix ?? "mocanvas-sync"}:${roomId}`;
+  const channel = new BroadcastChannel(name);
+  const listeners = /* @__PURE__ */ new Set();
+  let closed = false;
+  channel.onmessage = (event) => {
+    const message = decodeMessage(event.data);
+    if (!message) return;
+    for (const listener of Array.from(listeners)) listener(message);
+  };
+  return {
+    send(message) {
+      if (closed) return;
+      channel.postMessage(encodeMessage(message));
+    },
+    onMessage(callback) {
+      listeners.add(callback);
+      return () => {
+        listeners.delete(callback);
+      };
+    },
+    onOpen(callback) {
+      let cancelled = false;
+      queueMicrotask(() => {
+        if (!cancelled && !closed) callback();
+      });
+      return () => {
+        cancelled = true;
+      };
+    },
+    close() {
+      closed = true;
+      listeners.clear();
+      channel.onmessage = null;
+      channel.close();
+    }
+  };
+}
+function createWebSocketTransport(url, options = {}) {
+  const reconnect = options.reconnect ?? true;
+  const minDelay = options.minDelayMs ?? 500;
+  const maxDelay = options.maxDelayMs ?? 15e3;
+  const Impl = options.WebSocketImpl ?? globalThis.WebSocket;
+  if (!Impl) throw new Error("No WebSocket implementation available; pass options.WebSocketImpl");
+  const listeners = /* @__PURE__ */ new Set();
+  const open = createEmitter();
+  const close = createEmitter();
+  let socket = null;
+  let attempt = 0;
+  let timer = null;
+  let disposed = false;
+  const connect = () => {
+    if (disposed) return;
+    const ws = new Impl(url);
+    socket = ws;
+    ws.onopen = () => {
+      attempt = 0;
+      open.emit();
+    };
+    ws.onmessage = (event) => {
+      const message = decodeMessage(event.data);
+      if (!message) return;
+      for (const listener of Array.from(listeners)) listener(message);
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = () => {
+      if (socket === ws) socket = null;
+      close.emit();
+      if (!disposed && reconnect) schedule();
+    };
+  };
+  const schedule = () => {
+    if (timer !== null) return;
+    const ceiling = Math.min(maxDelay, minDelay * 2 ** attempt);
+    attempt++;
+    const delay = Math.random() * ceiling;
+    timer = setTimeout(() => {
+      timer = null;
+      connect();
+    }, delay);
+  };
+  connect();
+  return {
+    send(message) {
+      if (!socket || socket.readyState !== 1) return;
+      socket.send(encodeMessage(message));
+    },
+    onMessage(callback) {
+      listeners.add(callback);
+      return () => {
+        listeners.delete(callback);
+      };
+    },
+    onOpen(callback) {
+      const remove = open.add(callback);
+      if (socket && socket.readyState === 1) queueMicrotask(callback);
+      return remove;
+    },
+    onClose(callback) {
+      return close.add(callback);
+    },
+    close() {
+      disposed = true;
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      listeners.clear();
+      open.clear();
+      close.clear();
+      const ws = socket;
+      socket = null;
+      if (ws) {
+        ws.onopen = null;
+        ws.onmessage = null;
+        ws.onerror = null;
+        ws.onclose = null;
+        if (ws.readyState === 0 || ws.readyState === 1) ws.close();
+      }
+    }
+  };
+}
+function createMemoryTransportPair() {
+  const hub = createMemoryHub();
+  return [hub.join(), hub.join()];
+}
+function createMemoryHub() {
+  const peers = /* @__PURE__ */ new Set();
+  return {
+    join() {
+      const listeners = /* @__PURE__ */ new Set();
+      let closed = false;
+      const peer = {
+        deliver(data) {
+          if (closed) return;
+          const message = decodeMessage(data);
+          if (!message) return;
+          for (const listener of Array.from(listeners)) listener(message);
+        }
+      };
+      peers.add(peer);
+      return {
+        send(message) {
+          if (closed) return;
+          const data = encodeMessage(message);
+          for (const other of Array.from(peers)) {
+            if (other === peer) continue;
+            queueMicrotask(() => other.deliver(data));
+          }
+        },
+        onMessage(callback) {
+          listeners.add(callback);
+          return () => {
+            listeners.delete(callback);
+          };
+        },
+        onOpen(callback) {
+          let cancelled = false;
+          queueMicrotask(() => {
+            if (!cancelled && !closed) callback();
+          });
+          return () => {
+            cancelled = true;
+          };
+        },
+        close() {
+          closed = true;
+          listeners.clear();
+          peers.delete(peer);
+        }
+      };
+    }
+  };
+}
+var layerStyle = {
+  position: "absolute",
+  inset: 0,
+  width: "100%",
+  height: "100%",
+  pointerEvents: "none",
+  overflow: "visible"
+};
+var CollaboratorCursors = track(function CollaboratorCursors2({
+  editor,
+  showSelection = true,
+  showNames = true
+}) {
+  const collaborators = editor.getCollaboratorsOnCurrentPage();
+  if (collaborators.length === 0) return null;
+  return /* @__PURE__ */ jsx("svg", { className: "mocanvas-collaborators", style: layerStyle, children: collaborators.map((presence) => /* @__PURE__ */ jsxs("g", { children: [
+    showSelection ? /* @__PURE__ */ jsx(CollaboratorSelection, { editor, presence }) : null,
+    /* @__PURE__ */ jsx(CollaboratorCursor, { editor, presence, showName: showNames })
+  ] }, presence.id)) });
+});
+var CollaboratorCursor = track(function CollaboratorCursor2({
+  editor,
+  presence,
+  showName
+}) {
+  const point = editor.pageToScreen(presence.cursor);
+  const name = presence.userName || "Anonymous";
+  return /* @__PURE__ */ jsxs("g", { transform: `translate(${point.x}, ${point.y}) rotate(${presence.cursor.rotation})`, children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M0 0 L0 17.3 L4.3 13.4 L7 19.4 L9.9 18 L7.2 12.2 L12.8 12 Z",
+        fill: presence.color,
+        stroke: "#fff",
+        strokeWidth: 1,
+        strokeLinejoin: "round"
+      }
+    ),
+    showName ? /* @__PURE__ */ jsxs("g", { transform: "translate(11, 18)", children: [
+      /* @__PURE__ */ jsx("rect", { rx: 4, ry: 4, width: Math.max(24, name.length * 7 + 12), height: 18, fill: presence.color }),
+      /* @__PURE__ */ jsx("text", { x: 6, y: 13, fontSize: 11, fontFamily: "system-ui, sans-serif", fill: "#fff", children: name })
+    ] }) : null
+  ] });
+});
+var CollaboratorSelection = track(function CollaboratorSelection2({
+  editor,
+  presence
+}) {
+  const outlines = [];
+  for (const id of presence.selectedShapeIds) {
+    const shape = editor.getShape(id);
+    if (!shape) continue;
+    const bounds = editor.getShapeGeometryBounds(shape);
+    if (!bounds) continue;
+    const m = editor.getShapePageTransform(shape);
+    const corners = [
+      [bounds.x, bounds.y],
+      [bounds.maxX, bounds.y],
+      [bounds.maxX, bounds.maxY],
+      [bounds.x, bounds.maxY]
+    ];
+    const points = corners.map(([x, y]) => {
+      const screen = editor.pageToScreen({ x: m.a * x + m.c * y + m.e, y: m.b * x + m.d * y + m.f });
+      return `${screen.x},${screen.y}`;
+    });
+    outlines.push(points.join(" "));
+  }
+  if (outlines.length === 0) return null;
+  return /* @__PURE__ */ jsx(Fragment, { children: outlines.map((points, i) => /* @__PURE__ */ jsx("polygon", { points, fill: "none", stroke: presence.color, strokeWidth: 1.5, opacity: 0.8 }, i)) });
+});
+function useSync(editor, options) {
+  const { roomId, enabled = true, presence = true } = options;
+  const latest = useRef(options);
+  latest.current = options;
+  const [client, setClient] = useState(null);
+  useEffect(() => {
+    if (!editor || !enabled) {
+      setClient(null);
+      return;
+    }
+    const current = latest.current;
+    const transport = typeof current.transport === "function" ? current.transport() : current.transport;
+    const clientOptions = {
+      store: editor.store,
+      roomId,
+      transport,
+      ...presence ? { presence: { editor } } : {},
+      ...current.clientId !== void 0 ? { clientId: current.clientId } : {},
+      ...current.presenceTimeoutMs !== void 0 ? { presenceTimeoutMs: current.presenceTimeoutMs } : {},
+      ...current.presenceThrottleMs !== void 0 ? { presenceThrottleMs: current.presenceThrottleMs } : {},
+      onError: (error) => latest.current.onError?.(error)
+    };
+    const next = createSyncClient(clientOptions);
+    setClient(next);
+    next.connect();
+    return () => {
+      setClient(null);
+      next.dispose();
+    };
+  }, [editor, roomId, enabled, presence]);
+  const status = useValue("sync.status", () => client?.getStatus().get() ?? "offline", [client]);
+  return { status, client };
+}
+
+export { CollaboratorCursors, DEFAULT_PRESENCE_HEARTBEAT_MS, DEFAULT_PRESENCE_THROTTLE_MS, DEFAULT_PRESENCE_TIMEOUT_MS, PROTOCOL_VERSION, PresenceRoom, createBroadcastChannelTransport, createMemoryHub, createMemoryTransportPair, createPresenceSync, createSyncClient, createWebSocketTransport, decodeMessage, encodeMessage, isSamePresence, presenceIdForClient, useSync };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/presence.ts","../src/protocol.ts","../src/SyncClient.ts","../src/transport.ts","../src/react.tsx"],"names":["CollaboratorCursors","CollaboratorCursor","CollaboratorSelection"],"mappings":"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","file":"index.js","sourcesContent":["import { react } from \"@mocanvas/state\"\nimport {\n  InstancePresenceRecordType,\n  type Editor,\n  type InstancePresence,\n  type InstancePresenceId,\n} from \"@mocanvas/editor\"\nimport type { IdOf, Store, UnknownRecord } from \"@mocanvas/store\"\n\n/** Presence is sent at most this often (30 Hz). */\nexport const DEFAULT_PRESENCE_THROTTLE_MS = Math.ceil(1000 / 30)\n/** A presence record is re-sent this often even when nothing changed. */\nexport const DEFAULT_PRESENCE_HEARTBEAT_MS = 3000\n/** A collaborator we have not heard from in this long is dropped. */\nexport const DEFAULT_PRESENCE_TIMEOUT_MS = 10_000\n\n/**\n * The part of the editor presence reads. Declared structurally so that the\n * sync layer does not need a live `Editor` (and its WASM engine) to be tested.\n */\nexport interface PresenceEditor {\n  readonly store: Store<any, any>\n  readonly inputs: { readonly currentPagePoint: { x: number; y: number } }\n  readonly user: { getId(): string; getName(): string; getColor(): string }\n  getCurrentPageId(): string\n  getCamera(): { x: number; y: number; z: number }\n  getSelectedShapeIds(): readonly string[]\n  getInstanceState(): {\n    cursor: { type: string; rotation: number }\n    brush: { x: number; y: number; w: number; h: number } | null\n    scribbles: readonly unknown[]\n    followingUserId: string | null\n  }\n  /** Optional: used to sample the cursor, which is not itself a signal. */\n  on?(name: \"event\", fn: () => void): () => void\n}\n\n// A real Editor must satisfy the structural interface above; this fails to\n// compile if the two ever drift apart.\ntype Assert<T extends true> = T\nexport type EditorIsPresenceEditor = Assert<Editor extends PresenceEditor ? true : false>\n\nexport interface PresenceSyncOptions {\n  editor: PresenceEditor\n  /** Identifies this tab; one user may have several. */\n  clientId: string\n  send(record: InstancePresence): void\n  throttleMs?: number\n  heartbeatMs?: number\n}\n\nexport interface PresenceSync {\n  start(): void\n  stop(): void\n  /** Ask for a send; collapses with any other request inside the throttle window. */\n  poke(): void\n  /** The record last handed to `send`, for tests and debugging. */\n  getLastSent(): InstancePresence | null\n  dispose(): void\n}\n\n/** The id a client's presence record always uses, so updates overwrite in place. */\nexport function presenceIdForClient(clientId: string): InstancePresenceId {\n  return InstancePresenceRecordType.createId(clientId) as InstancePresenceId\n}\n\n/**\n * Watches the editor and pushes the local presence record out, at most once per\n * throttle window, plus a heartbeat so that idle collaborators do not time out.\n */\nexport function createPresenceSync(options: PresenceSyncOptions): PresenceSync {\n  const { editor, clientId, send } = options\n  const throttleMs = options.throttleMs ?? DEFAULT_PRESENCE_THROTTLE_MS\n  const heartbeatMs = options.heartbeatMs ?? DEFAULT_PRESENCE_HEARTBEAT_MS\n  const id = presenceIdForClient(clientId)\n\n  let timer: ReturnType<typeof setTimeout> | null = null\n  let heartbeat: ReturnType<typeof setInterval> | null = null\n  let stopReactor: (() => void) | null = null\n  let stopEvents: (() => void) | null = null\n  let last: InstancePresence | null = null\n  let running = false\n\n  const build = (): InstancePresence => {\n    const instance = editor.getInstanceState()\n    const point = editor.inputs.currentPagePoint\n    return InstancePresenceRecordType.create({\n      id,\n      userId: editor.user.getId(),\n      userName: editor.user.getName(),\n      color: editor.user.getColor(),\n      currentPageId: editor.getCurrentPageId() as InstancePresence[\"currentPageId\"],\n      cursor: { x: point.x, y: point.y, type: instance.cursor.type, rotation: instance.cursor.rotation },\n      camera: { ...editor.getCamera() },\n      selectedShapeIds: [...editor.getSelectedShapeIds()] as InstancePresence[\"selectedShapeIds\"],\n      brush: instance.brush ? { ...instance.brush } : null,\n      scribbles: [...instance.scribbles] as InstancePresence[\"scribbles\"],\n      followingUserId: instance.followingUserId,\n      lastActivityTimestamp: Date.now(),\n      chatMessage: \"\",\n      meta: {},\n    })\n  }\n\n  const flush = (force: boolean) => {\n    if (!running) return\n    const next = build()\n    if (!force && last && isSamePresence(last, next)) return\n    last = next\n    send(next)\n  }\n\n  const poke = () => {\n    if (!running || timer !== null) return\n    timer = setTimeout(() => {\n      timer = null\n      flush(false)\n    }, throttleMs)\n  }\n\n  return {\n    start() {\n      if (running) return\n      running = true\n      // Camera, page and selection are signals, so a reactor covers them.\n      stopReactor = react(\"sync.presence\", () => {\n        editor.getCamera()\n        editor.getCurrentPageId()\n        editor.getSelectedShapeIds()\n        editor.getInstanceState()\n        editor.user.getName()\n        editor.user.getColor()\n        poke()\n      })\n      // The pointer position lives on `inputs`, which is not reactive.\n      stopEvents = editor.on?.(\"event\", poke) ?? null\n      heartbeat = setInterval(() => flush(true), heartbeatMs)\n      flush(true)\n    },\n    stop() {\n      running = false\n      if (timer !== null) {\n        clearTimeout(timer)\n        timer = null\n      }\n      if (heartbeat !== null) {\n        clearInterval(heartbeat)\n        heartbeat = null\n      }\n      stopReactor?.()\n      stopReactor = null\n      stopEvents?.()\n      stopEvents = null\n    },\n    poke,\n    getLastSent: () => last,\n    dispose() {\n      this.stop()\n      last = null\n    },\n  }\n}\n\n/** Equal apart from `lastActivityTimestamp`, which always moves. */\nexport function isSamePresence(a: InstancePresence, b: InstancePresence): boolean {\n  return (\n    a.userId === b.userId &&\n    a.userName === b.userName &&\n    a.color === b.color &&\n    a.currentPageId === b.currentPageId &&\n    a.chatMessage === b.chatMessage &&\n    a.followingUserId === b.followingUserId &&\n    a.cursor.x === b.cursor.x &&\n    a.cursor.y === b.cursor.y &&\n    a.cursor.type === b.cursor.type &&\n    a.cursor.rotation === b.cursor.rotation &&\n    a.camera.x === b.camera.x &&\n    a.camera.y === b.camera.y &&\n    a.camera.z === b.camera.z &&\n    sameIds(a.selectedShapeIds, b.selectedShapeIds) &&\n    sameBrush(a.brush, b.brush) &&\n    a.scribbles.length === b.scribbles.length &&\n    a.scribbles.every((s, i) => s === b.scribbles[i])\n  )\n}\n\nfunction sameIds(a: readonly string[], b: readonly string[]): boolean {\n  return a.length === b.length && a.every((id, i) => id === b[i])\n}\n\nfunction sameBrush(a: InstancePresence[\"brush\"], b: InstancePresence[\"brush\"]): boolean {\n  if (a === b) return true\n  if (!a || !b) return false\n  return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h\n}\n\n/**\n * Holds the presence records of everyone else: puts them in the store as they\n * arrive, drops them on `bye`, and sweeps clients that went quiet.\n */\nexport class PresenceRoom<R extends UnknownRecord> {\n  private readonly seen = new Map<string, { id: string; at: number }>()\n  private sweeper: ReturnType<typeof setInterval> | null = null\n\n  constructor(\n    private readonly store: Store<R, any>,\n    private readonly timeoutMs: number = DEFAULT_PRESENCE_TIMEOUT_MS,\n  ) {}\n\n  /** Store an incoming presence record and remember when we saw its client. */\n  receive(clientId: string, record: R): void {\n    const previous = this.seen.get(clientId)\n    if (previous && previous.id !== record.id) this.removeRecord(previous.id)\n    this.seen.set(clientId, { id: record.id, at: Date.now() })\n    this.store.mergeRemoteChanges(() => {\n      this.store.put([record])\n    })\n  }\n\n  /** Drop one client's presence (it said goodbye). */\n  remove(clientId: string): void {\n    const entry = this.seen.get(clientId)\n    if (!entry) return\n    this.seen.delete(clientId)\n    this.removeRecord(entry.id)\n  }\n\n  /** Drop every client we have not heard from within the timeout. */\n  sweep(now: number = Date.now()): void {\n    const stale: string[] = []\n    for (const [clientId, entry] of this.seen) {\n      if (now - entry.at > this.timeoutMs) stale.push(clientId)\n    }\n    for (const clientId of stale) this.remove(clientId)\n  }\n\n  startSweeping(intervalMs: number = Math.max(1000, Math.floor(this.timeoutMs / 4))): void {\n    if (this.sweeper !== null) return\n    this.sweeper = setInterval(() => this.sweep(), intervalMs)\n  }\n\n  stopSweeping(): void {\n    if (this.sweeper === null) return\n    clearInterval(this.sweeper)\n    this.sweeper = null\n  }\n\n  /** Remove every record this room put in the store. */\n  clear(): void {\n    const ids = Array.from(this.seen.values(), (entry) => entry.id)\n    this.seen.clear()\n    for (const id of ids) this.removeRecord(id)\n  }\n\n  private removeRecord(id: string): void {\n    const recordId = id as IdOf<R>\n    if (!this.store.unsafeGetWithoutCapture(recordId)) return\n    this.store.mergeRemoteChanges(() => {\n      this.store.remove([recordId])\n    })\n  }\n}\n","import type { RecordsDiff, UnknownRecord } from \"@mocanvas/store\"\n\n/** Bumped when the wire format changes incompatibly. */\nexport const PROTOCOL_VERSION = 1\n\n/**\n * Every message is one JSON object with a `type` discriminator.\n *\n * ```\n * hello     a client joined; existing peers answer with a snapshot\n * snapshot  the document-scope records as the sender currently sees them\n * diff      one squashed store diff, in document scope\n * presence  one presence record (cursor, camera, selection)\n * bye       the client is leaving; drop its presence\n * ```\n */\nexport type SyncMessage<R extends UnknownRecord = UnknownRecord> =\n  | HelloMessage\n  | SnapshotMessage<R>\n  | DiffMessage<R>\n  | PresenceMessage<R>\n  | ByeMessage\n\nexport interface HelloMessage {\n  type: \"hello\"\n  clientId: string\n  version: number\n}\n\nexport interface SnapshotMessage<R extends UnknownRecord = UnknownRecord> {\n  type: \"snapshot\"\n  records: R[]\n}\n\nexport interface DiffMessage<R extends UnknownRecord = UnknownRecord> {\n  type: \"diff\"\n  clientId: string\n  /** Per-client counter; only used for logging and de-duplication. */\n  seq: number\n  diff: RecordsDiff<R>\n}\n\nexport interface PresenceMessage<R extends UnknownRecord = UnknownRecord> {\n  type: \"presence\"\n  clientId: string\n  record: R\n}\n\nexport interface ByeMessage {\n  type: \"bye\"\n  clientId: string\n}\n\nexport function encodeMessage<R extends UnknownRecord>(message: SyncMessage<R>): string {\n  return JSON.stringify(message)\n}\n\n/**\n * Parse a message off the wire. Returns `null` for anything malformed: a peer\n * on a newer protocol must never be able to crash this one.\n */\nexport function decodeMessage<R extends UnknownRecord = UnknownRecord>(data: unknown): SyncMessage<R> | null {\n  let value: unknown = data\n  if (typeof data === \"string\") {\n    try {\n      value = JSON.parse(data)\n    } catch {\n      return null\n    }\n  }\n  if (typeof value !== \"object\" || value === null) return null\n  const message = value as Record<string, unknown>\n  switch (message[\"type\"]) {\n    case \"hello\":\n      if (typeof message[\"clientId\"] !== \"string\") return null\n      if (typeof message[\"version\"] !== \"number\") return null\n      return { type: \"hello\", clientId: message[\"clientId\"], version: message[\"version\"] }\n    case \"snapshot\": {\n      const records = message[\"records\"]\n      if (!Array.isArray(records)) return null\n      if (!records.every(isRecordLike)) return null\n      return { type: \"snapshot\", records: records as R[] }\n    }\n    case \"diff\": {\n      if (typeof message[\"clientId\"] !== \"string\") return null\n      if (typeof message[\"seq\"] !== \"number\") return null\n      if (!isDiffLike(message[\"diff\"])) return null\n      return {\n        type: \"diff\",\n        clientId: message[\"clientId\"],\n        seq: message[\"seq\"],\n        diff: message[\"diff\"] as RecordsDiff<R>,\n      }\n    }\n    case \"presence\": {\n      if (typeof message[\"clientId\"] !== \"string\") return null\n      if (!isRecordLike(message[\"record\"])) return null\n      return { type: \"presence\", clientId: message[\"clientId\"], record: message[\"record\"] as R }\n    }\n    case \"bye\":\n      if (typeof message[\"clientId\"] !== \"string\") return null\n      return { type: \"bye\", clientId: message[\"clientId\"] }\n    default:\n      return null\n  }\n}\n\nfunction isRecordLike(value: unknown): boolean {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as { id?: unknown }).id === \"string\" &&\n    typeof (value as { typeName?: unknown }).typeName === \"string\"\n  )\n}\n\nfunction isDiffLike(value: unknown): boolean {\n  if (typeof value !== \"object\" || value === null) return false\n  const diff = value as Record<string, unknown>\n  for (const key of [\"added\", \"updated\", \"removed\"]) {\n    const part = diff[key]\n    if (typeof part !== \"object\" || part === null || Array.isArray(part)) return false\n  }\n  return true\n}\n","import { atom, type Signal } from \"@mocanvas/state\"\nimport { isRecordsDiffEmpty, uniqueId, type Store, type UnknownRecord } from \"@mocanvas/store\"\nimport {\n  createPresenceSync,\n  DEFAULT_PRESENCE_TIMEOUT_MS,\n  PresenceRoom,\n  type PresenceEditor,\n  type PresenceSync,\n} from \"./presence\"\nimport { PROTOCOL_VERSION, type SyncMessage } from \"./protocol\"\nimport type { Transport } from \"./transport\"\n\nexport type SyncStatus = \"offline\" | \"connecting\" | \"online\"\n\nexport interface SyncClientOptions<R extends UnknownRecord = UnknownRecord> {\n  store: Store<R, any>\n  /** Identifies the document. The transport is expected to be scoped to it too. */\n  roomId: string\n  transport: Transport<R>\n  /** Turn on cursor/selection sharing for an editor. */\n  presence?: { editor: PresenceEditor } | undefined\n  /** Defaults to a fresh random id; one per tab, not per user. */\n  clientId?: string | undefined\n  /** Drop a collaborator after this long without a presence message. Default 10s. */\n  presenceTimeoutMs?: number | undefined\n  /** Upper bound on presence send rate. Default 34ms (~30 Hz). */\n  presenceThrottleMs?: number | undefined\n  presenceHeartbeatMs?: number | undefined\n  /** Called for protocol-level problems (a peer on another version, say). */\n  onError?: ((error: Error) => void) | undefined\n}\n\nexport interface SyncClient {\n  readonly clientId: string\n  readonly roomId: string\n  connect(): void\n  disconnect(): void\n  /** A signal, so React and reactors can follow the connection. */\n  getStatus(): Signal<SyncStatus>\n  dispose(): void\n}\n\n/**\n * Joins one room over `transport` and keeps `store` in step with its peers.\n *\n * Document changes made locally by the user are broadcast as diffs; incoming\n * diffs are applied as remote changes so they neither echo back nor land in\n * the undo stack. Conflicts are resolved last-writer-wins per record.\n */\nexport function createSyncClient<R extends UnknownRecord = UnknownRecord>(\n  options: SyncClientOptions<R>,\n): SyncClient {\n  const { store, roomId, transport } = options\n  const clientId = options.clientId ?? uniqueId(12)\n  const status = atom<SyncStatus>(`sync.status:${roomId}`, \"offline\")\n  const room = new PresenceRoom<R>(store, options.presenceTimeoutMs ?? DEFAULT_PRESENCE_TIMEOUT_MS)\n\n  const unsubscribes: (() => void)[] = []\n  let presence: PresenceSync | null = null\n  let seq = 0\n  /** True between joining and either receiving a snapshot or serving one. */\n  let awaitingSnapshot = false\n  let connected = false\n  let disposed = false\n\n  const send = (message: SyncMessage<R>) => {\n    try {\n      transport.send(message)\n    } catch (error) {\n      options.onError?.(error instanceof Error ? error : new Error(String(error)))\n    }\n  }\n\n  const handle = (message: SyncMessage<R>) => {\n    if (disposed) return\n    switch (message.type) {\n      case \"hello\": {\n        if (message.clientId === clientId) return\n        if (message.version !== PROTOCOL_VERSION) {\n          options.onError?.(\n            new Error(`Peer ${message.clientId} speaks protocol ${message.version}, we speak ${PROTOCOL_VERSION}`),\n          )\n          return\n        }\n        // A newcomer needs the document; every established peer answers and the\n        // newcomer keeps the first answer. Answering also makes us established,\n        // so a snapshot meant for that newcomer cannot overwrite what we have.\n        awaitingSnapshot = false\n        send({ type: \"snapshot\", records: Object.values(store.serialize(\"document\")) as R[] })\n        // Re-announce our presence so the newcomer sees us immediately.\n        presence?.poke()\n        return\n      }\n      case \"snapshot\": {\n        // Only a newcomer applies a snapshot; otherwise a late peer would\n        // clobber work done since we joined.\n        if (!awaitingSnapshot) return\n        awaitingSnapshot = false\n        store.mergeRemoteChanges(() => {\n          store.put(message.records)\n        })\n        return\n      }\n      case \"diff\": {\n        if (message.clientId === clientId) return\n        if (isRecordsDiffEmpty(message.diff)) return\n        store.mergeRemoteChanges(() => {\n          store.applyDiff(message.diff)\n        })\n        return\n      }\n      case \"presence\": {\n        if (message.clientId === clientId) return\n        room.receive(message.clientId, message.record)\n        return\n      }\n      case \"bye\": {\n        if (message.clientId === clientId) return\n        room.remove(message.clientId)\n        return\n      }\n    }\n  }\n\n  const onOpen = () => {\n    if (disposed || !connected) return\n    status.set(\"online\")\n    send({ type: \"hello\", clientId, version: PROTOCOL_VERSION })\n    presence?.poke()\n  }\n\n  const onClose = () => {\n    if (disposed || !connected) return\n    // The transport reconnects on its own; from here it is just \"not online\".\n    status.set(\"connecting\")\n  }\n\n  return {\n    clientId,\n    roomId,\n\n    connect() {\n      if (disposed || connected) return\n      connected = true\n      awaitingSnapshot = true\n      status.set(\"connecting\")\n\n      unsubscribes.push(transport.onMessage(handle))\n      if (transport.onOpen) unsubscribes.push(transport.onOpen(onOpen))\n      if (transport.onClose) unsubscribes.push(transport.onClose(onClose))\n\n      // Outgoing document changes: only what this user did, never what we\n      // applied from a peer (those arrive with source \"remote\").\n      unsubscribes.push(\n        store.listen(\n          (entry) => {\n            if (isRecordsDiffEmpty(entry.changes)) return\n            send({ type: \"diff\", clientId, seq: seq++, diff: entry.changes })\n          },\n          { source: \"user\", scope: \"document\" },\n        ),\n      )\n\n      if (options.presence) {\n        presence = createPresenceSync({\n          editor: options.presence.editor,\n          clientId,\n          send: (record) => send({ type: \"presence\", clientId, record: record as unknown as R }),\n          ...(options.presenceThrottleMs !== undefined ? { throttleMs: options.presenceThrottleMs } : {}),\n          ...(options.presenceHeartbeatMs !== undefined ? { heartbeatMs: options.presenceHeartbeatMs } : {}),\n        })\n        presence.start()\n      }\n      room.startSweeping()\n\n      if (!transport.onOpen) onOpen()\n    },\n\n    disconnect() {\n      if (!connected) return\n      connected = false\n      send({ type: \"bye\", clientId })\n      presence?.stop()\n      presence = null\n      room.stopSweeping()\n      room.clear()\n      for (const off of unsubscribes.splice(0)) off()\n      awaitingSnapshot = false\n      status.set(\"offline\")\n    },\n\n    getStatus() {\n      return status\n    },\n\n    dispose() {\n      if (disposed) return\n      this.disconnect()\n      disposed = true\n      transport.close()\n    },\n  }\n}\n","import type { UnknownRecord } from \"@mocanvas/store\"\nimport { decodeMessage, encodeMessage, type SyncMessage } from \"./protocol\"\n\n/**\n * A duplex channel that carries `SyncMessage`s between peers in one room.\n *\n * The transport owns serialization and reconnection; the client above it only\n * sees decoded messages. `onOpen` fires every time the channel becomes usable\n * (including after a reconnect), `onClose` every time it stops being usable.\n * A transport with neither is treated as open from the moment it is connected.\n */\nexport interface Transport<R extends UnknownRecord = UnknownRecord> {\n  send(message: SyncMessage<R>): void\n  onMessage(callback: (message: SyncMessage<R>) => void): () => void\n  onOpen?(callback: () => void): () => void\n  onClose?(callback: () => void): () => void\n  close(): void\n}\n\n/** @internal A tiny callback set with an unsubscribe function. */\nexport function createEmitter(): {\n  add(cb: () => void): () => void\n  emit(): void\n  clear(): void\n} {\n  const callbacks = new Set<() => void>()\n  return {\n    add(cb) {\n      callbacks.add(cb)\n      return () => {\n        callbacks.delete(cb)\n      }\n    },\n    emit() {\n      for (const cb of Array.from(callbacks)) cb()\n    },\n    clear() {\n      callbacks.clear()\n    },\n  }\n}\n\n/* -------------------------------------------------------------------------- */\n/* BroadcastChannel                                                           */\n/* -------------------------------------------------------------------------- */\n\nexport interface BroadcastChannelTransportOptions {\n  /** Channel name prefix, so two apps on one origin do not collide. */\n  prefix?: string\n}\n\n/**\n * Same-origin tabs of one browser. There is no server, so every peer is\n * equally authoritative and the channel is open as soon as it is created.\n */\nexport function createBroadcastChannelTransport<R extends UnknownRecord = UnknownRecord>(\n  roomId: string,\n  options: BroadcastChannelTransportOptions = {},\n): Transport<R> {\n  const name = `${options.prefix ?? \"mocanvas-sync\"}:${roomId}`\n  const channel = new BroadcastChannel(name)\n  const listeners = new Set<(message: SyncMessage<R>) => void>()\n  let closed = false\n\n  channel.onmessage = (event: MessageEvent) => {\n    const message = decodeMessage<R>(event.data)\n    if (!message) return\n    for (const listener of Array.from(listeners)) listener(message)\n  }\n\n  return {\n    send(message) {\n      if (closed) return\n      channel.postMessage(encodeMessage(message))\n    },\n    onMessage(callback) {\n      listeners.add(callback)\n      return () => {\n        listeners.delete(callback)\n      }\n    },\n    onOpen(callback) {\n      // Already usable; hand control back to the caller before firing so that\n      // `connect()` has finished wiring itself up.\n      let cancelled = false\n      queueMicrotask(() => {\n        if (!cancelled && !closed) callback()\n      })\n      return () => {\n        cancelled = true\n      }\n    },\n    close() {\n      closed = true\n      listeners.clear()\n      channel.onmessage = null\n      channel.close()\n    },\n  }\n}\n\n/* -------------------------------------------------------------------------- */\n/* WebSocket                                                                  */\n/* -------------------------------------------------------------------------- */\n\nexport interface WebSocketTransportOptions {\n  /** Reconnect with exponential backoff after an unexpected close. Default `true`. */\n  reconnect?: boolean\n  /** First backoff delay in ms. Default 500. */\n  minDelayMs?: number\n  /** Backoff ceiling in ms. Default 15000. */\n  maxDelayMs?: number\n  /** Injectable for tests and for Node (`ws`). Defaults to `globalThis.WebSocket`. */\n  WebSocketImpl?: typeof WebSocket\n}\n\n/**\n * A WebSocket to a relay (see `scripts/relay.mjs`). Messages sent while the\n * socket is down are dropped rather than queued: the next `hello`/`snapshot`\n * exchange re-establishes the document anyway, and presence is re-sent on a\n * heartbeat.\n */\nexport function createWebSocketTransport<R extends UnknownRecord = UnknownRecord>(\n  url: string,\n  options: WebSocketTransportOptions = {},\n): Transport<R> {\n  const reconnect = options.reconnect ?? true\n  const minDelay = options.minDelayMs ?? 500\n  const maxDelay = options.maxDelayMs ?? 15_000\n  const Impl = options.WebSocketImpl ?? (globalThis as { WebSocket?: typeof WebSocket }).WebSocket\n  if (!Impl) throw new Error(\"No WebSocket implementation available; pass options.WebSocketImpl\")\n\n  const listeners = new Set<(message: SyncMessage<R>) => void>()\n  const open = createEmitter()\n  const close = createEmitter()\n\n  let socket: WebSocket | null = null\n  let attempt = 0\n  let timer: ReturnType<typeof setTimeout> | null = null\n  let disposed = false\n\n  const connect = () => {\n    if (disposed) return\n    const ws = new Impl(url)\n    socket = ws\n    ws.onopen = () => {\n      attempt = 0\n      open.emit()\n    }\n    ws.onmessage = (event: MessageEvent) => {\n      const message = decodeMessage<R>(event.data)\n      if (!message) return\n      for (const listener of Array.from(listeners)) listener(message)\n    }\n    ws.onerror = () => {\n      // `onclose` always follows; the retry is scheduled there.\n    }\n    ws.onclose = () => {\n      if (socket === ws) socket = null\n      close.emit()\n      if (!disposed && reconnect) schedule()\n    }\n  }\n\n  const schedule = () => {\n    if (timer !== null) return\n    // Exponential backoff with full jitter, so a relay restart does not get a\n    // thundering herd from every open tab.\n    const ceiling = Math.min(maxDelay, minDelay * 2 ** attempt)\n    attempt++\n    const delay = Math.random() * ceiling\n    timer = setTimeout(() => {\n      timer = null\n      connect()\n    }, delay)\n  }\n\n  connect()\n\n  return {\n    send(message) {\n      if (!socket || socket.readyState !== 1 /* OPEN */) return\n      socket.send(encodeMessage(message))\n    },\n    onMessage(callback) {\n      listeners.add(callback)\n      return () => {\n        listeners.delete(callback)\n      }\n    },\n    onOpen(callback) {\n      const remove = open.add(callback)\n      if (socket && socket.readyState === 1) queueMicrotask(callback)\n      return remove\n    },\n    onClose(callback) {\n      return close.add(callback)\n    },\n    close() {\n      disposed = true\n      if (timer !== null) {\n        clearTimeout(timer)\n        timer = null\n      }\n      listeners.clear()\n      open.clear()\n      close.clear()\n      const ws = socket\n      socket = null\n      if (ws) {\n        ws.onopen = null\n        ws.onmessage = null\n        ws.onerror = null\n        ws.onclose = null\n        if (ws.readyState === 0 || ws.readyState === 1) ws.close()\n      }\n    },\n  }\n}\n\n/* -------------------------------------------------------------------------- */\n/* in-memory                                                                  */\n/* -------------------------------------------------------------------------- */\n\n/**\n * Two transports wired to each other, going through the same JSON encode and\n * decode as the real ones. Delivery is asynchronous (a microtask) so that a\n * peer never observes a message inside its own `send()` call stack.\n */\nexport function createMemoryTransportPair<R extends UnknownRecord = UnknownRecord>(): [Transport<R>, Transport<R>] {\n  const hub = createMemoryHub<R>()\n  return [hub.join(), hub.join()]\n}\n\nexport interface MemoryHub<R extends UnknownRecord = UnknownRecord> {\n  /** Add another peer to the room. */\n  join(): Transport<R>\n}\n\n/** A room every joined transport broadcasts into (itself excluded). */\nexport function createMemoryHub<R extends UnknownRecord = UnknownRecord>(): MemoryHub<R> {\n  const peers = new Set<{ deliver(data: string): void }>()\n  return {\n    join(): Transport<R> {\n      const listeners = new Set<(message: SyncMessage<R>) => void>()\n      let closed = false\n      const peer = {\n        deliver(data: string) {\n          if (closed) return\n          const message = decodeMessage<R>(data)\n          if (!message) return\n          for (const listener of Array.from(listeners)) listener(message)\n        },\n      }\n      peers.add(peer)\n      return {\n        send(message) {\n          if (closed) return\n          const data = encodeMessage(message)\n          for (const other of Array.from(peers)) {\n            if (other === peer) continue\n            queueMicrotask(() => other.deliver(data))\n          }\n        },\n        onMessage(callback) {\n          listeners.add(callback)\n          return () => {\n            listeners.delete(callback)\n          }\n        },\n        onOpen(callback) {\n          let cancelled = false\n          queueMicrotask(() => {\n            if (!cancelled && !closed) callback()\n          })\n          return () => {\n            cancelled = true\n          }\n        },\n        close() {\n          closed = true\n          listeners.clear()\n          peers.delete(peer)\n        },\n      }\n    },\n  }\n}\n","import { track, useValue } from \"@mocanvas/state/react\"\nimport type { Editor, EditorRecord, InstancePresence, UnknownShape } from \"@mocanvas/editor\"\nimport { useEffect, useRef, useState, type CSSProperties } from \"react\"\nimport { createSyncClient, type SyncClient, type SyncClientOptions, type SyncStatus } from \"./SyncClient\"\nimport type { Transport } from \"./transport\"\n\nconst layerStyle: CSSProperties = {\n  position: \"absolute\",\n  inset: 0,\n  width: \"100%\",\n  height: \"100%\",\n  pointerEvents: \"none\",\n  overflow: \"visible\",\n}\n\nexport interface CollaboratorCursorsProps {\n  editor: Editor\n  /** Draw what each collaborator has selected. Default `true`. */\n  showSelection?: boolean\n  /** Draw a name chip next to each cursor. Default `true`. */\n  showNames?: boolean\n}\n\n/**\n * Other people's cursors and selections, drawn in screen space above the\n * canvas. Drop it inside `<Mocanvas>` or `<Canvas>`; it positions itself.\n */\nexport const CollaboratorCursors = track(function CollaboratorCursors({\n  editor,\n  showSelection = true,\n  showNames = true,\n}: CollaboratorCursorsProps) {\n  const collaborators = editor.getCollaboratorsOnCurrentPage()\n  if (collaborators.length === 0) return null\n  return (\n    <svg className=\"mocanvas-collaborators\" style={layerStyle}>\n      {collaborators.map((presence) => (\n        <g key={presence.id}>\n          {showSelection ? <CollaboratorSelection editor={editor} presence={presence} /> : null}\n          <CollaboratorCursor editor={editor} presence={presence} showName={showNames} />\n        </g>\n      ))}\n    </svg>\n  )\n})\n\nconst CollaboratorCursor = track(function CollaboratorCursor({\n  editor,\n  presence,\n  showName,\n}: {\n  editor: Editor\n  presence: InstancePresence\n  showName: boolean\n}) {\n  const point = editor.pageToScreen(presence.cursor)\n  const name = presence.userName || \"Anonymous\"\n  // A 16x22 arrow drawn from the hotspot, then the name chip below it.\n  return (\n    <g transform={`translate(${point.x}, ${point.y}) rotate(${presence.cursor.rotation})`}>\n      <path\n        d=\"M0 0 L0 17.3 L4.3 13.4 L7 19.4 L9.9 18 L7.2 12.2 L12.8 12 Z\"\n        fill={presence.color}\n        stroke=\"#fff\"\n        strokeWidth={1}\n        strokeLinejoin=\"round\"\n      />\n      {showName ? (\n        <g transform=\"translate(11, 18)\">\n          <rect rx={4} ry={4} width={Math.max(24, name.length * 7 + 12)} height={18} fill={presence.color} />\n          <text x={6} y={13} fontSize={11} fontFamily=\"system-ui, sans-serif\" fill=\"#fff\">\n            {name}\n          </text>\n        </g>\n      ) : null}\n    </g>\n  )\n})\n\nconst CollaboratorSelection = track(function CollaboratorSelection({\n  editor,\n  presence,\n}: {\n  editor: Editor\n  presence: InstancePresence\n}) {\n  const outlines: string[] = []\n  for (const id of presence.selectedShapeIds) {\n    const shape: UnknownShape | undefined = editor.getShape(id)\n    if (!shape) continue\n    const bounds = editor.getShapeGeometryBounds(shape)\n    if (!bounds) continue\n    const m = editor.getShapePageTransform(shape)\n    // Transform the local corners to page space, then to screen space, so the\n    // outline follows rotation without a nested SVG transform.\n    const corners: [number, number][] = [\n      [bounds.x, bounds.y],\n      [bounds.maxX, bounds.y],\n      [bounds.maxX, bounds.maxY],\n      [bounds.x, bounds.maxY],\n    ]\n    const points = corners.map(([x, y]) => {\n      const screen = editor.pageToScreen({ x: m.a * x + m.c * y + m.e, y: m.b * x + m.d * y + m.f })\n      return `${screen.x},${screen.y}`\n    })\n    outlines.push(points.join(\" \"))\n  }\n  if (outlines.length === 0) return null\n  return (\n    <>\n      {outlines.map((points, i) => (\n        <polygon key={i} points={points} fill=\"none\" stroke={presence.color} strokeWidth={1.5} opacity={0.8} />\n      ))}\n    </>\n  )\n})\n\nexport interface UseSyncOptions {\n  roomId: string\n  /**\n   * The channel to the room. Pass a factory when the transport should be\n   * recreated with the room (the usual case); it is read once per connection.\n   */\n  transport: Transport | (() => Transport)\n  /** Share this editor's cursor and selection. Default `true`. */\n  presence?: boolean\n  /** Set `false` to stay offline (a read-only view, say). Default `true`. */\n  enabled?: boolean\n  clientId?: string\n  presenceTimeoutMs?: number\n  presenceThrottleMs?: number\n  onError?: (error: Error) => void\n}\n\nexport interface UseSyncResult {\n  status: SyncStatus\n  client: SyncClient | null\n}\n\n/**\n * Connect an editor's store to a room for as long as the component is mounted.\n * Everything is torn down (including the transport) on unmount.\n */\nexport function useSync(editor: Editor | null, options: UseSyncOptions): UseSyncResult {\n  const { roomId, enabled = true, presence = true } = options\n  // Kept in a ref so that inline factories and callbacks do not reconnect.\n  const latest = useRef(options)\n  latest.current = options\n\n  const [client, setClient] = useState<SyncClient | null>(null)\n\n  useEffect(() => {\n    if (!editor || !enabled) {\n      setClient(null)\n      return\n    }\n    const current = latest.current\n    const transport = typeof current.transport === \"function\" ? current.transport() : current.transport\n    const clientOptions: SyncClientOptions<EditorRecord> = {\n      store: editor.store,\n      roomId,\n      transport: transport as Transport<EditorRecord>,\n      ...(presence ? { presence: { editor } } : {}),\n      ...(current.clientId !== undefined ? { clientId: current.clientId } : {}),\n      ...(current.presenceTimeoutMs !== undefined ? { presenceTimeoutMs: current.presenceTimeoutMs } : {}),\n      ...(current.presenceThrottleMs !== undefined ? { presenceThrottleMs: current.presenceThrottleMs } : {}),\n      onError: (error: Error) => latest.current.onError?.(error),\n    }\n    const next = createSyncClient<EditorRecord>(clientOptions)\n    setClient(next)\n    next.connect()\n    return () => {\n      setClient(null)\n      next.dispose()\n    }\n  }, [editor, roomId, enabled, presence])\n\n  const status = useValue(\"sync.status\", () => client?.getStatus().get() ?? \"offline\", [client])\n  return { status, client }\n}\n"]}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@mocanvas/sync",
+  "version": "1.0.0",
+  "description": "Multiplayer for a mocanvas store: record diffs over a transport, plus presence and cursors.",
+  "license": "MIT",
+  "author": "Symbio Digital",
+  "homepage": "https://github.com/SYMBIO/mocanvas/tree/main/packages/sync#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SYMBIO/mocanvas.git",
+    "directory": "packages/sync"
+  },
+  "bugs": {
+    "url": "https://github.com/SYMBIO/mocanvas/issues"
+  },
+  "keywords": [
+    "multiplayer",
+    "collaboration",
+    "presence",
+    "websocket",
+    "sync",
+    "mocanvas"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "scripts",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@mocanvas/state": "1.0.0",
+    "@mocanvas/store": "1.0.0",
+    "@mocanvas/editor": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.0",
+    "@types/ws": "^8.5.0",
+    "react": "^19.1.0",
+    "ws": "^8.18.0"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "relay": "node scripts/relay.mjs"
+  }
+}

package/scripts/relay.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// A room relay for @mocanvas/sync: every message received on a socket is
+// forwarded verbatim to the other sockets in the same room. The room is the
+// URL path, so ws://localhost:5858/my-doc is one room and /other is another.
+//
+// It keeps no document state. Peers hand each other the document with the
+// hello/snapshot exchange, so the relay can be restarted at any time.
+//
+//   node scripts/relay.mjs            # port 5858
+//   PORT=9000 node scripts/relay.mjs
+import { WebSocketServer } from "ws"
+
+const port = Number(process.env["PORT"] ?? 5858)
+const server = new WebSocketServer({ port })
+/** @type {Map<string, Set<import("ws").WebSocket>>} */
+const rooms = new Map()
+
+server.on("connection", (socket, request) => {
+  const room = new URL(request.url ?? "/", "http://localhost").pathname || "/"
+  let peers = rooms.get(room)
+  if (!peers) {
+    peers = new Set()
+    rooms.set(room, peers)
+  }
+  peers.add(socket)
+  log(`+ ${room} (${peers.size} peer${peers.size === 1 ? "" : "s"})`)
+
+  socket.on("message", (data, isBinary) => {
+    if (isBinary) return
+    const text = data.toString()
+    for (const peer of peers) {
+      if (peer === socket) continue
+      if (peer.readyState !== peer.OPEN) continue
+      peer.send(text)
+    }
+  })
+
+  socket.on("error", () => socket.close())
+
+  socket.on("close", () => {
+    peers.delete(socket)
+    if (peers.size === 0) rooms.delete(room)
+    log(`- ${room} (${peers.size} peer${peers.size === 1 ? "" : "s"})`)
+  })
+})
+
+server.on("listening", () => log(`relay listening on ws://localhost:${port}/<room>`))
+
+function log(message) {
+  process.stdout.write(`[mocanvas-relay] ${message}\n`)
+}
+
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    server.close(() => process.exit(0))
+  })
+}