@kolosal-ai/rivet 0.2.0 → 0.3.0

package/dist/anchor/index.d.ts

@@ -1,6 +1,6 @@
 import { CSSProperties, ReactNode } from 'react';
-export { A as ANCHOR_SIDES, a as AnchorGeometry, b as AnchorOptions, c as AnchorPoint, d as AnchorRecord, e as AnchorRegistration, f as AnchorRegistrationOptions, g as AnchorStrayPolicy, D as DEFAULT_ANCHOR_OPTIONS, R as ResolvedAnchorOptions, h as anchorAutoHandleId, i as anchorDotHandleId, j as anchorHandleId, k as computeAnchorGeometry, n as normalizeAnchorConnection, p as parseAnchorAutoHandleId, l as parseAnchorDotHandleId, m as parseAnchorHandleId, s as strayPlacementPct } from '../registry-t5ldbviG.js';
-import '../types-CQqnm4yW.js';
+export { A as ANCHOR_SIDES, a as AnchorGeometry, b as AnchorOptions, c as AnchorPoint, d as AnchorRecord, e as AnchorRegistration, f as AnchorRegistrationOptions, g as AnchorStrayPolicy, D as DEFAULT_ANCHOR_OPTIONS, R as ResolvedAnchorOptions, h as anchorAutoHandleId, i as anchorDotHandleId, j as anchorHandleId, k as computeAnchorGeometry, n as normalizeAnchorConnection, p as parseAnchorAutoHandleId, l as parseAnchorDotHandleId, m as parseAnchorHandleId, s as strayPlacementPct } from '../registry-CCBgd7FN.js';
+import '../types-C9Vn1rzy.js';
 
 type AnchorProps = {
     /**

package/dist/{chunk-RG5ALD3X.js → chunk-A52HZWLH.js}

@@ -104,11 +104,11 @@ function declarationEqual(a, b) {
   return a.name === b.name && a.color === b.color && samePoint(a.cursor, b.cursor) && sameIds(a.selection, b.selection) && sameIds(a.holding, b.holding);
 }
 var Registry2 = class {
-  /** Called on every change, roster or hot-path — the canvas has to repaint either way. */
-  constructor(requestRender) {
-    this.requestRender = requestRender;
+  /** Called on every change, roster or hot-path — something has to repaint either way. */
+  constructor(requests) {
+    this.requests = requests;
   }
-  requestRender;
+  requests;
   peers = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   snapshot = [];
@@ -121,7 +121,15 @@ var Registry2 = class {
   lastStep = -1;
   touch() {
     this.stale = true;
-    this.requestRender();
+    this.requests.requestRender();
+  }
+  /**
+   * A change only the cursor layer can see. Same snapshot invalidation, but the
+   * frame it asks for repaints one canvas instead of all of them.
+   */
+  touchCursor() {
+    this.stale = true;
+    this.requests.requestCursorRender();
   }
   /** A change React needs to know about, as well as the canvas. */
   touchRoster() {
@@ -176,7 +184,7 @@ var Registry2 = class {
     if (state.live !== void 0 && samePoint(state.live, point)) return;
     state.live = point;
     if (point === null) this.prune(state);
-    this.touch();
+    this.touchCursor();
   };
   setPeerNodeTransform = (peerId, nodeId, rect) => {
     const state = this.peer(peerId);
@@ -285,8 +293,8 @@ var Registry2 = class {
     };
   };
 };
-function createPresenceRegistry(requestRender) {
-  return new Registry2(requestRender);
+function createPresenceRegistry(requests) {
+  return new Registry2(requests);
 }
 var UNLOCKED = { locked: false };
 function useNodeLock(id) {
@@ -302,5 +310,5 @@ function useNodeLockAllows(id, intent) {
 }
 
 export { DEFAULT_PRESENCE_OPTIONS, LOCK_DEFAULT_REFUSED, PEER_COLORS, createLockRegistry, createPresenceRegistry, peerColor, useNodeLock, useNodeLockAllows };
-//# sourceMappingURL=chunk-RG5ALD3X.js.map
-//# sourceMappingURL=chunk-RG5ALD3X.js.map
+//# sourceMappingURL=chunk-A52HZWLH.js.map
+//# sourceMappingURL=chunk-A52HZWLH.js.map

package/dist/chunk-A52HZWLH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/locks/registry.ts","../src/presence/registry.ts","../src/hooks/use-node-lock.ts"],"names":["Registry"],"mappings":"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","file":"chunk-A52HZWLH.js","sourcesContent":["/**\n * Locks — nodes a peer has claimed, and what this client may still do to them.\n *\n * A lock is policy where presence is description. `Peer.holding` says \"they\n * have their pointer on this\"; a lock says \"hands off\", and rivet acts on it.\n * The two render identically on purpose — to whoever is looking, they mean the\n * same thing — but only a lock refuses anything.\n *\n * Locks come in whole, as the `lockedNodes` prop, because the transport already\n * has to hold them: a lock outlives the tab that took it (that's the point of\n * taking one), so the server owns the lifetime and rivet only reads it. Nothing\n * here enters the graph, the change stream, or history — a lock is no more a\n * fact about the document than a cursor is.\n *\n * What a lock refuses is a default, not a rule. {@link LOCK_DEFAULT_REFUSED} is\n * rivet's opinion; `canInteractWithLocked` is the consumer's, and it wins on\n * every intent it's asked about.\n */\n\nimport type { NodeId } from \"../types\"\n\n/**\n * A thing this client might try to do to a locked node.\n *\n * Granular because the answer genuinely differs per app: a design tool wants a\n * locked node inspectable, a form builder wants it untouchable, and a pipeline\n * editor usually wants to keep wiring around one while a colleague renames it.\n */\nexport type LockIntent =\n  /** Click it, or sweep it up in a marquee. */\n  | \"select\"\n  /** Move it — pointer drag, group drag, keyboard grab or arrow nudge. */\n  | \"drag\"\n  /** Change its box through {@link NodeResizer}. */\n  | \"resize\"\n  /** Remove it as part of deleting the selection. */\n  | \"delete\"\n  /** Start or land an edge on one of its handles. */\n  | \"connect\"\n\n/** What {@link CanInteractWithLocked} is asked about. */\nexport type LockInteraction = {\n  nodeId: NodeId\n  /** The peer holding the lock — the `lockedNodes` value for this node. */\n  holderId: string\n  intent: LockIntent\n}\n\n/**\n * Consumer override for rivet's default refusals, consulted once per attempt.\n * Return `true` to allow the intent, `false` to refuse it — the default is\n * replaced, not consulted, so a handler owns the whole policy.\n */\nexport type CanInteractWithLocked = (event: LockInteraction) => boolean\n\n/** A node's lock as {@link useNodeLock} reports it. */\nexport type NodeLock = {\n  locked: boolean\n  /** The peer holding it, or `undefined` when the node isn't locked. */\n  holderId?: string\n}\n\n/**\n * The intents rivet refuses on a locked node when no policy is given.\n *\n * `connect` is deliberately absent. A lock claims the node, not the graph\n * around it: an edge is its own row with its own id, and refusing to wire one\n * would make a locked node an island for as long as somebody holds it — a far\n * heavier lock than \"someone is editing this\" warrants. Consumers who want that\n * can say so through {@link CanInteractWithLocked}.\n */\nexport const LOCK_DEFAULT_REFUSED: ReadonlySet<LockIntent> = new Set<LockIntent>([\n  \"select\",\n  \"drag\",\n  \"resize\",\n  \"delete\",\n])\n\n/**\n * The lock registry — one per graph, reachable as `store.locks`.\n *\n * Reads are hot: every marquee frame and every mover loop asks\n * {@link LockRegistry.allows}, so it stays a map lookup plus at most one\n * consumer call, with no allocation on the common (nothing locked) path.\n */\nexport type LockRegistry = {\n  /**\n   * Replace the lock table (the `lockedNodes` prop). Returns the nodes that\n   * weren't locked before and are now — the store scans those for conflicts\n   * with a live local gesture.\n   */\n  setLocks: (locks: Record<NodeId, string> | undefined) => NodeId[]\n  /** Install the consumer's policy, or `null` to fall back to the defaults. */\n  setPolicy: (policy: CanInteractWithLocked | null) => void\n  isLocked: (id: NodeId) => boolean\n  /** Who holds this node's lock, or `null` when it isn't locked. */\n  getHolder: (id: NodeId) => string | null\n  /** The whole table. The renderer walks it once a frame. */\n  getLocks: () => ReadonlyMap<NodeId, string>\n  /** How many nodes are locked — the render loop's early-out. */\n  size: () => number\n  /**\n   * Whether this client may act on a node. Always `true` for an unlocked node,\n   * so callers can ask unconditionally.\n   */\n  allows: (id: NodeId, intent: LockIntent) => boolean\n  /** Bumped on every table change, for `useSyncExternalStore`. */\n  getVersion: () => number\n  /** Subscribe to the table changing — locks move at human rate, so this is React-safe. */\n  subscribe: (listener: () => void) => () => void\n}\n\n/** Whether two lock tables hold the same node→holder pairs. */\nfunction locksEqual(current: ReadonlyMap<NodeId, string>, next: Record<NodeId, string>): boolean {\n  const keys = Object.keys(next)\n  if (keys.length !== current.size) return false\n  return keys.every((id) => current.get(id) === next[id])\n}\n\nclass Registry implements LockRegistry {\n  private locks = new Map<NodeId, string>()\n  private policy: CanInteractWithLocked | null = null\n  private version = 0\n  private readonly listeners = new Set<() => void>()\n\n  /** Marks the canvas dirty — a lock is paint as well as policy. */\n  constructor(private readonly requestRender: () => void) {}\n\n  setLocks = (locks: Record<NodeId, string> | undefined): NodeId[] => {\n    const next = locks ?? {}\n    // An unchanged table is the common case (any prop change re-runs the\n    // effect), and re-publishing it would re-fire every conflict.\n    if (locksEqual(this.locks, next)) return []\n    const opened: NodeId[] = []\n    for (const [id, holderId] of Object.entries(next)) {\n      if (this.locks.get(id) !== holderId) opened.push(id)\n    }\n    this.locks = new Map(Object.entries(next))\n    this.version += 1\n    this.requestRender()\n    for (const listener of this.listeners) listener()\n    return opened\n  }\n\n  setPolicy = (policy: CanInteractWithLocked | null): void => {\n    this.policy = policy\n  }\n\n  isLocked = (id: NodeId): boolean => this.locks.has(id)\n\n  getHolder = (id: NodeId): string | null => this.locks.get(id) ?? null\n\n  getLocks = (): ReadonlyMap<NodeId, string> => this.locks\n\n  size = (): number => this.locks.size\n\n  allows = (id: NodeId, intent: LockIntent): boolean => {\n    // Fast path: nothing locked at all, which is every single-player frame.\n    if (this.locks.size === 0) return true\n    const holderId = this.locks.get(id)\n    if (holderId === undefined) return true\n    if (this.policy) return this.policy({ nodeId: id, holderId, intent })\n    return !LOCK_DEFAULT_REFUSED.has(intent)\n  }\n\n  getVersion = (): number => this.version\n\n  subscribe = (listener: () => void): (() => void) => {\n    this.listeners.add(listener)\n    return () => {\n      this.listeners.delete(listener)\n    }\n  }\n}\n\n/** Create a lock registry. `requestRender` repaints the holder outlines. */\nexport function createLockRegistry(requestRender: () => void): LockRegistry {\n  return new Registry(requestRender)\n}\n","/**\n * Presence — who else is in the document, and where they are.\n *\n * Presence is ephemeral by construction. Nothing here enters the graph, the\n * change stream, or history: a peer's cursor is not a fact about the document,\n * it's a fact about a person, and it stops being true the moment they move. So\n * the registry is imperative, painted straight from the render loop, and thrown\n * away when the tab closes.\n *\n * Two doors write to it, at deliberately different speeds:\n *\n *  - the `peers` prop — the roster. Identity (name, colour) and the slow\n *    fields (selection, holding). React-rate.\n *  - {@link PresenceRegistry.setPeerCursor} / `setPeerNodeTransform` — the hot\n *    path off your ephemeral channel, called as fast as frames arrive. These\n *    never touch React: they mark the canvas dirty and nothing else. A cursor\n *    dirties only the cursor layer; a transform moves a real node, so it\n *    dirties the frame.\n *\n * A peer the roster has never mentioned is still legitimate — a cursor frame\n * can beat the join event, and dropping it would blink the cursor. Such a peer\n * lives until its cursor clears (see {@link PresenceRegistry.setPeerCursor}),\n * and its colour is derived from its id, so the record can be rebuilt any\n * number of times without the colour ever flickering.\n */\n\nimport type { NodeId, Rect, Vec2 } from \"../types\"\n\n/**\n * A participant other than this client, as your transport describes them.\n *\n * Everything is optional but `id`: presence degrades field by field, and a peer\n * you know nothing about except that they exist is still worth an avatar.\n */\nexport type Peer = {\n  id: string\n  /** Display name, drawn beside their cursor. Unnamed peers get no label. */\n  name?: string\n  /** Any CSS colour. Defaults to a stable colour derived from {@link Peer.id}. */\n  color?: string\n  /**\n   * Cursor in **world** coordinates — peers pan and zoom independently, so a\n   * screen point means nothing to anyone else. `null` when their pointer is\n   * off the canvas. Only a seed: once {@link PresenceRegistry.setPeerCursor}\n   * has been called for a peer, the imperative value owns the cursor.\n   */\n  cursor?: Vec2 | null\n  /** Nodes they have selected. Outlined in their colour. */\n  selection?: NodeId[]\n  /** Nodes under one of their live gestures (their `onNodeDragStart`). */\n  holding?: NodeId[]\n}\n\n/**\n * A peer as the registry holds it: identity resolved, live overlays merged in.\n * What the renderer and {@link usePeers} both read.\n */\nexport type PeerRecord = {\n  id: string\n  name?: string\n  /** Always set — {@link peerColor} fills in for a peer that declared none. */\n  color: string\n  cursor: Vec2 | null\n  selection: readonly NodeId[]\n  holding: readonly NodeId[]\n  /**\n   * Where this peer currently has each node they're dragging, in world space —\n   * the frame-rate overlay from `setPeerNodeTransform`. The node renders there\n   * until they let go; the graph keeps its own position until their commit\n   * arrives as a real change.\n   */\n  transforms: ReadonlyMap<NodeId, Rect>\n}\n\n/** Presence policy, set via the `presenceOptions` prop. */\nexport type PresenceOptions = {\n  /**\n   * Smallest gap between outbound `onLocalPresence` snapshots, in ms. Cursor\n   * movement is coalesced to this rate; selection and gesture changes ignore it\n   * and go out at once (a lock signal that waits is a lock signal that races).\n   * Default `50`.\n   */\n  throttleMs?: number\n  /**\n   * Give peer cursors their own canvas layer. Turn off to render your own from\n   * {@link usePeers} — avatars, follow buttons, anything the canvas can't do —\n   * and the layer is never created at all. Node outlines and peers' live boxes\n   * are unaffected: they live with the geometry they annotate. Default `true`.\n   */\n  renderCursors?: boolean\n}\n\nexport type ResolvedPresenceOptions = Required<PresenceOptions>\n\nexport const DEFAULT_PRESENCE_OPTIONS: ResolvedPresenceOptions = {\n  throttleMs: 50,\n  renderCursors: true,\n}\n\n/**\n * Default peer colours. Spaced around the wheel and mid-toned, so they read on\n * a light or dark canvas and stay distinguishable side by side.\n */\nexport const PEER_COLORS = [\n  \"#6366f1\",\n  \"#ec4899\",\n  \"#f59e0b\",\n  \"#10b981\",\n  \"#3b82f6\",\n  \"#8b5cf6\",\n  \"#ef4444\",\n  \"#14b8a6\",\n] as const\n\n/**\n * A stable colour for a peer id. Deterministic, so the same person is the same\n * colour on every client and across a record being pruned and rebuilt — nobody\n * coordinates a palette, and nobody's cursor changes colour mid-session.\n */\nexport function peerColor(id: string): string {\n  let hash = 0\n  for (let i = 0; i < id.length; i += 1) hash = (hash * 31 + id.charCodeAt(i)) | 0\n  // Modulo of a negative hash is negative; normalize before indexing.\n  const index = ((hash % PEER_COLORS.length) + PEER_COLORS.length) % PEER_COLORS.length\n  return PEER_COLORS[index] ?? PEER_COLORS[0]\n}\n\n/**\n * The presence registry — one per graph, reachable as `store.presence`.\n *\n * Reads are snapshot-based: {@link getPeers} returns a cached array rebuilt\n * only when something actually changed, so the render loop can call it every\n * frame and `useSyncExternalStore` can compare identities.\n */\nexport type PresenceRegistry = {\n  /**\n   * Replace the roster (the `peers` prop). Peers that were in the previous\n   * roster and aren't in this one are dropped outright — leaving the roster is\n   * how a peer leaves. Peers this registry only knows imperatively are kept.\n   */\n  setPeers: (peers: Peer[]) => void\n  /**\n   * Move a peer's cursor, in world coordinates. The hot path: call it as fast\n   * as your channel delivers frames — it dirties the cursor layer and nothing\n   * else, so the cost doesn't scale into the rest of the canvas.\n   *\n   * `null` parks the cursor. For a peer the roster never declared, that leaves\n   * nothing to draw, so the record is dropped — the next frame recreates it\n   * with the same colour.\n   */\n  setPeerCursor: (peerId: string, point: Vec2 | null) => void\n  /**\n   * Where a peer currently has a node, in world space — their drag, mid-flight.\n   * The node itself moves there: it's painted, hit-tested and wired at the peer's\n   * live box, while the graph underneath is untouched until their commit lands.\n   * `null` releases it, which is what their drop should do just before their\n   * real change arrives.\n   */\n  setPeerNodeTransform: (peerId: string, nodeId: NodeId, rect: Rect | null) => void\n  /**\n   * Every node a peer currently has under a gesture, at its *rendered* position\n   * — the interpolated one, not the last frame that arrived. What the store\n   * folds into world positions.\n   */\n  getNodeTransforms: () => ReadonlyMap<NodeId, Rect>\n  /**\n   * Bumped whenever a rendered transform moves. Lets the store cache world\n   * positions across frames where peers are idle.\n   */\n  getTransformVersion: () => number\n  /**\n   * Advance the interpolation toward the values that arrived, and report\n   * whether anything is still in motion (i.e. whether another frame is owed).\n   *\n   * Frames arrive at whatever rate a transport manages — 20Hz is normal, and\n   * stepping straight to each one makes a cursor stutter and a dragged node\n   * jump. Easing between them costs one lerp per peer and buys motion that\n   * reads as somebody moving rather than as packets landing.\n   */\n  step: (now: number) => boolean\n  /** Forget a peer entirely — cursor, held nodes and all. Use it when they disconnect. */\n  removePeer: (peerId: string) => void\n  /** Every known peer. A cached snapshot; identity only changes when the data does. */\n  getPeers: () => readonly PeerRecord[]\n  /** True when nobody else is here — the render loop's early-out. */\n  isEmpty: () => boolean\n  /**\n   * Subscribe to **roster** changes: peers arriving or leaving, and their\n   * identity, selection or holding changing. Cursor and transform frames\n   * deliberately don't notify — they'd re-render React at pointer rate, and\n   * they're already painted on the canvas. Read them from {@link getPeers} on\n   * the frame channel if you need them in the DOM.\n   */\n  subscribe: (listener: () => void) => () => void\n}\n\n/** Internal peer state: what the roster declared, plus the imperative overlays. */\ntype PeerState = {\n  id: string\n  /** The roster's entry, or null for a peer only known through cursor frames. */\n  declared: Peer | null\n  /** `undefined` until an imperative write; after that it owns the cursor. */\n  live: Vec2 | null | undefined\n  /** Where the cursor is being drawn, easing toward {@link live}. */\n  renderCursor: Vec2 | null\n  /** Latest frame per node — the target the rendered box is easing toward. */\n  transforms: Map<NodeId, Rect>\n  /** Where each box is actually drawn this frame. */\n  renderTransforms: Map<NodeId, Rect>\n}\n\n/**\n * Time constant for peer interpolation, in ms: the gap to the target closes by\n * ~63% every `SMOOTHING_MS`. Short enough that a cursor never trails visibly\n * behind the frames arriving, long enough to absorb a 20Hz channel.\n */\nconst SMOOTHING_MS = 45\n/** Assumed frame length for the very first step, which has no interval to measure. */\nconst NOMINAL_FRAME_MS = 16\n/** Below this (px, world or screen) the ease is over and the value snaps. */\nconst SETTLED_EPSILON = 0.05\n\n/** Ease `from` toward `to` by `t`, or snap when it's close enough to be done. */\nfunction approach(from: number, to: number, t: number): number {\n  const next = from + (to - from) * t\n  return Math.abs(to - next) < SETTLED_EPSILON ? to : next\n}\n\nconst EMPTY_IDS: readonly NodeId[] = []\n\nconst samePoint = (a: Vec2 | null | undefined, b: Vec2 | null | undefined): boolean =>\n  a === b || (a != null && b != null && a.x === b.x && a.y === b.y)\n\nconst sameRect = (a: Rect | undefined, b: Rect): boolean =>\n  a !== undefined && a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height\n\nconst sameIds = (a: readonly NodeId[] | undefined, b: readonly NodeId[] | undefined): boolean => {\n  const left = a ?? EMPTY_IDS\n  const right = b ?? EMPTY_IDS\n  return left.length === right.length && left.every((id, i) => id === right[i])\n}\n\n/** Whether two roster entries carry the same identity and slow fields. */\nfunction declarationEqual(a: Peer | null, b: Peer | null): boolean {\n  if (a === b) return true\n  if (!a || !b) return false\n  return (\n    a.name === b.name &&\n    a.color === b.color &&\n    samePoint(a.cursor, b.cursor) &&\n    sameIds(a.selection, b.selection) &&\n    sameIds(a.holding, b.holding)\n  )\n}\n\nclass Registry implements PresenceRegistry {\n  private readonly peers = new Map<string, PeerState>()\n  private readonly listeners = new Set<() => void>()\n  private snapshot: readonly PeerRecord[] = []\n  private stale = false\n  /** Merged rendered transforms across peers, rebuilt when {@link version} moves. */\n  private transforms: Map<NodeId, Rect> = new Map()\n  private transformsStale = false\n  private version = 0\n  /** Timestamp of the last {@link step}, so the ease is frame-rate independent. */\n  private lastStep = -1\n\n  /** Called on every change, roster or hot-path — something has to repaint either way. */\n  constructor(private readonly requests: PresenceRenderRequests) {}\n\n  private touch(): void {\n    this.stale = true\n    this.requests.requestRender()\n  }\n\n  /**\n   * A change only the cursor layer can see. Same snapshot invalidation, but the\n   * frame it asks for repaints one canvas instead of all of them.\n   */\n  private touchCursor(): void {\n    this.stale = true\n    this.requests.requestCursorRender()\n  }\n\n  /** A change React needs to know about, as well as the canvas. */\n  private touchRoster(): void {\n    this.touch()\n    for (const listener of this.listeners) listener()\n  }\n\n  private peer(id: string): PeerState {\n    let state = this.peers.get(id)\n    if (!state) {\n      state = {\n        id,\n        declared: null,\n        live: undefined,\n        renderCursor: null,\n        transforms: new Map(),\n        renderTransforms: new Map(),\n      }\n      this.peers.set(id, state)\n    }\n    return state\n  }\n\n  /** Drop a peer the roster doesn't claim and that has nothing left to draw. */\n  private prune(state: PeerState): void {\n    if (state.declared || state.live || state.transforms.size > 0) return\n    this.peers.delete(state.id)\n    this.invalidateTransforms()\n  }\n\n  private invalidateTransforms(): void {\n    this.transformsStale = true\n    this.version += 1\n  }\n\n  setPeers = (peers: Peer[]): void => {\n    let changed = false\n    const incoming = new Set<string>()\n    for (const peer of peers) {\n      incoming.add(peer.id)\n      const state = this.peer(peer.id)\n      if (declarationEqual(state.declared, peer)) continue\n      state.declared = peer\n      changed = true\n    }\n    for (const state of [...this.peers.values()]) {\n      if (incoming.has(state.id)) continue\n      // Declared before, absent now: they left. A peer the roster never\n      // mentioned is none of its business and survives.\n      if (!state.declared) continue\n      this.peers.delete(state.id)\n      changed = true\n    }\n    if (changed) this.touchRoster()\n  }\n\n  setPeerCursor = (peerId: string, point: Vec2 | null): void => {\n    const state = this.peer(peerId)\n    if (state.live !== undefined && samePoint(state.live, point)) return\n    state.live = point\n    if (point === null) this.prune(state)\n    // Cursor-only: a peer this registry knows nothing else about is pruned here\n    // too, but pruning one is only ever the erasure of a cursor — a record with\n    // a roster entry or a live transform doesn't qualify (see `prune`).\n    this.touchCursor()\n  }\n\n  setPeerNodeTransform = (peerId: string, nodeId: NodeId, rect: Rect | null): void => {\n    const state = this.peer(peerId)\n    if (rect === null) {\n      const had = state.transforms.delete(nodeId)\n      // The rendered box goes with the target: a released node snaps back to\n      // wherever the graph says it is, which by then is where their commit put it.\n      state.renderTransforms.delete(nodeId)\n      this.prune(state)\n      if (!had) return\n      this.invalidateTransforms()\n      this.touch()\n      return\n    }\n    if (sameRect(state.transforms.get(nodeId), rect)) return\n    state.transforms.set(nodeId, rect)\n    // The first frame for a node places it outright — there's nothing to ease\n    // from, and easing from the graph position would slide it across the canvas.\n    if (!state.renderTransforms.has(nodeId)) {\n      state.renderTransforms.set(nodeId, rect)\n      this.invalidateTransforms()\n    }\n    this.touch()\n  }\n\n  removePeer = (peerId: string): void => {\n    if (!this.peers.delete(peerId)) return\n    this.invalidateTransforms()\n    this.touchRoster()\n  }\n\n  getNodeTransforms = (): ReadonlyMap<NodeId, Rect> => {\n    if (this.transformsStale) {\n      this.transformsStale = false\n      this.transforms = new Map()\n      for (const state of this.peers.values()) {\n        for (const [nodeId, rect] of state.renderTransforms) this.transforms.set(nodeId, rect)\n      }\n    }\n    return this.transforms\n  }\n\n  getTransformVersion = (): number => this.version\n\n  step = (now: number): boolean => {\n    // Exponential ease, sampled at whatever interval this frame actually took,\n    // so the motion looks the same on a 60Hz and a 120Hz display. The first\n    // step has no interval to measure and assumes one ordinary frame.\n    const elapsed = this.lastStep < 0 ? NOMINAL_FRAME_MS : Math.max(0, now - this.lastStep)\n    this.lastStep = now\n    const t = 1 - Math.exp(-elapsed / SMOOTHING_MS)\n    let moving = false\n    let transformsMoved = false\n\n    for (const state of this.peers.values()) {\n      const target = state.live !== undefined ? state.live : (state.declared?.cursor ?? null)\n      if (target === null) {\n        state.renderCursor = null\n      } else if (!state.renderCursor) {\n        state.renderCursor = target\n      } else if (!samePoint(state.renderCursor, target)) {\n        state.renderCursor = {\n          x: approach(state.renderCursor.x, target.x, t),\n          y: approach(state.renderCursor.y, target.y, t),\n        }\n        moving = true\n      }\n\n      for (const [nodeId, rect] of state.transforms) {\n        const current = state.renderTransforms.get(nodeId)\n        if (!current) {\n          state.renderTransforms.set(nodeId, rect)\n          transformsMoved = true\n          continue\n        }\n        if (sameRect(current, rect)) continue\n        state.renderTransforms.set(nodeId, {\n          x: approach(current.x, rect.x, t),\n          y: approach(current.y, rect.y, t),\n          // Size comes from a resize rather than a drag and rarely differs\n          // frame to frame, but easing it keeps a live resize as smooth.\n          width: approach(current.width, rect.width, t),\n          height: approach(current.height, rect.height, t),\n        })\n        transformsMoved = true\n        moving = true\n      }\n    }\n\n    if (transformsMoved) this.invalidateTransforms()\n    if (moving) this.stale = true\n    return moving\n  }\n\n  getPeers = (): readonly PeerRecord[] => {\n    if (this.stale) {\n      this.stale = false\n      this.snapshot = [...this.peers.values()].map((state) => {\n        const declared = state.declared\n        // An imperative write, once made, owns the cursor; the roster's is a seed.\n        const target = (state.live !== undefined ? state.live : declared?.cursor) ?? null\n        return {\n          id: state.id,\n          name: declared?.name,\n          color: declared?.color ?? peerColor(state.id),\n          // Rendered, not raw: what {@link step} has eased to. Falls back to the\n          // target so a registry nobody steps still paints something sensible.\n          cursor: target === null ? null : (state.renderCursor ?? target),\n          selection: declared?.selection ?? EMPTY_IDS,\n          holding: declared?.holding ?? EMPTY_IDS,\n          transforms: state.renderTransforms,\n        }\n      })\n    }\n    return this.snapshot\n  }\n\n  isEmpty = (): boolean => this.peers.size === 0\n\n  subscribe = (listener: () => void): (() => void) => {\n    this.listeners.add(listener)\n    return () => {\n      this.listeners.delete(listener)\n    }\n  }\n}\n\n/**\n * How the registry asks for paint. Every write is a repaint — presence exists\n * only as paint — but they don't all cost the same canvas.\n */\nexport type PresenceRenderRequests = {\n  /** Repaint the frame: roster changes and peers' live boxes move real geometry. */\n  requestRender: () => void\n  /** Repaint the cursor layer alone. */\n  requestCursorRender: () => void\n}\n\n/** Create a presence registry. */\nexport function createPresenceRegistry(requests: PresenceRenderRequests): PresenceRegistry {\n  return new Registry(requests)\n}\n","import { useCallback, useSyncExternalStore } from \"react\"\nimport { useRivetContext } from \"../context\"\nimport type { LockIntent, NodeLock } from \"../locks/registry\"\nimport type { NodeId } from \"../types\"\n\nconst UNLOCKED: NodeLock = { locked: false }\n\n/**\n * Whether a node is locked, and by whom — for the chrome rivet can't draw for\n * you: a padlock in the node's header, a \"Ada is editing\" line, a disabled\n * form inside the node body.\n *\n * rivet already refuses the interactions it owns (see the `lockedNodes` prop),\n * so this is for *your* controls. Re-renders only when this node changes hands,\n * not when any lock in the document moves.\n *\n * ```tsx\n * function MyNode({ id }: NodeProps) {\n *   const { locked, holderId } = useNodeLock(id)\n *   return <input disabled={locked} title={locked ? `${holderId} is editing` : \"\"} />\n * }\n * ```\n */\nexport function useNodeLock(id: NodeId): NodeLock {\n  const { store } = useRivetContext()\n  const getHolder = useCallback(() => store.locks.getHolder(id), [store, id])\n  // Snapshot the holder id, not an object: `useSyncExternalStore` compares with\n  // Object.is, so a fresh `{ locked, holderId }` every call would re-render on\n  // any lock change anywhere. The record is built after the comparison.\n  const holderId = useSyncExternalStore(store.locks.subscribe, getHolder, getHolder)\n  return holderId === null ? UNLOCKED : { locked: true, holderId }\n}\n\n/**\n * Whether this client may do `intent` to a node right now — the same question\n * every rivet input path asks, answered through the same policy.\n *\n * Use it to keep your own affordances honest: hide a delete button on a node a\n * peer has locked, rather than letting it be pressed and refused. Always `true`\n * for an unlocked node.\n */\nexport function useNodeLockAllows(id: NodeId, intent: LockIntent): boolean {\n  const { store } = useRivetContext()\n  const allows = useCallback(() => store.locks.allows(id, intent), [store, id, intent])\n  return useSyncExternalStore(store.locks.subscribe, allows, allows)\n}\n"]}

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import { R as Rect, V as Vec2, A as AlignmentGuide, E as EdgeChange, a as RivetEdge, b as NodeChange, c as RivetNode, N as NodeId, d as NodeProps, e as NodeTypes, f as HandleType, H as HandlePosition, S as Size, g as ChangeOrigin, h as EdgeId, i as HandleRecord, j as ChangeMeta, k as Viewport, l as NodeGestureEvent, m as NodeLockConflictEvent, n as RivetSelection, o as ReconnectDelegate, C as Connection, P as PendingConnection, p as EdgeTypes, D as DefaultEdgeOptions, q as EdgeRendererFactory, r as SwimlaneGroup, s as SwimlaneMargin, t as SwimlaneHeaderProps, u as SwimlaneLabelProps, v as SwimlaneSizeChange, L as LaneChange, w as RivetControls, x as RivetSnapshot, y as EdgeRenderer, z as EdgeRendererOptions, B as EdgeDrawExtras, F as EdgeEnd, G as EdgePathFn } from './types-CQqnm4yW.js';
-export { I as CenterNodeOptions, J as EdgeMarker, K as EdgePath, M as EdgePathParams, O as EdgeStyle, Q as FitViewOptions, T as NodeComponent } from './types-CQqnm4yW.js';
+import { R as Rect, V as Vec2, A as AlignmentGuide, E as EdgeChange, b as RivetEdge, a as NodeChange, c as RivetNode, N as NodeId, d as NodeProps, e as NodeTypes, f as HandleType, H as HandlePosition, S as Size, g as ChangeOrigin, h as EdgeId, i as HandleRecord, j as ChangeMeta, k as Viewport, l as NodeGestureEvent, m as NodeLockConflictEvent, n as RivetSelection, o as ReconnectDelegate, C as Connection, P as PendingConnection, p as EdgeTypes, D as DefaultEdgeOptions, q as EdgeRendererFactory, r as SwimlaneGroup, s as SwimlaneMargin, t as SwimlaneHeaderProps, u as SwimlaneLabelProps, v as SwimlaneSizeChange, L as LaneChange, w as RivetControls, x as RivetSnapshot, y as EdgeRenderer, z as EdgeRendererOptions, B as EdgeDrawExtras, F as EdgeEnd, G as EdgePathFn } from './types-C9Vn1rzy.js';
+export { I as CenterNodeOptions, J as EdgeMarker, K as EdgePath, M as EdgePathParams, O as EdgeStyle, Q as FitViewOptions, T as NodeComponent } from './types-C9Vn1rzy.js';
 import { ReactNode, CSSProperties, MouseEvent, RefObject } from 'react';
-import { d as AnchorRecord, f as AnchorRegistrationOptions, b as AnchorOptions, R as ResolvedAnchorOptions, e as AnchorRegistration } from './registry-t5ldbviG.js';
-import { h as PresenceRegistry, d as LockRegistry, f as Peer, a as LocalPresence, g as PresenceOptions, C as CanInteractWithLocked } from './use-node-lock-Csg9pUeC.js';
-export { L as LOCK_DEFAULT_REFUSED, b as LockIntent, c as LockInteraction, N as NodeLock, u as useNodeLock, i as useNodeLockAllows } from './use-node-lock-Csg9pUeC.js';
+import { d as AnchorRecord, f as AnchorRegistrationOptions, b as AnchorOptions, R as ResolvedAnchorOptions, e as AnchorRegistration } from './registry-CCBgd7FN.js';
+import { h as PresenceRegistry, d as LockRegistry, f as Peer, a as LocalPresence, g as PresenceOptions, C as CanInteractWithLocked } from './use-node-lock-DH0dB1yA.js';
+export { L as LOCK_DEFAULT_REFUSED, b as LockIntent, c as LockInteraction, N as NodeLock, u as useNodeLock, i as useNodeLockAllows } from './use-node-lock-DH0dB1yA.js';
 import { ResolvedLane, ViewportElements, ResolvedSwimlaneGroup, ResolvedMargin } from './swimlane/index.js';
 
 /**
@@ -559,6 +559,13 @@ type RivetStore = {
     /** Ask the runtime to schedule a canvas frame. */
     requestRender: () => void;
     bindRenderRequester: (fn: () => void) => void;
+    /**
+     * Ask the runtime to repaint the peer-cursor layer only — everything else on
+     * screen keeps last frame's pixels. Degrades to {@link requestRender} while
+     * no runtime has claimed the layer, so a caller never has to check.
+     */
+    requestCursorRender: () => void;
+    bindCursorRenderRequester: (fn: (() => void) | null) => void;
 };
 /** Create a graph store. The public entry point; the class is an implementation detail. */
 declare function createRivetStore(init: RivetStoreInit): RivetStore;
@@ -1066,6 +1073,20 @@ type RivetInstance<TNodeData = unknown, TEdgeData = unknown> = RivetControls & {
     toObject: () => RivetSnapshot<TNodeData, TEdgeData>;
     getNodes: () => RivetNode<TNodeData>[];
     getNode: (id: NodeId) => RivetNode<TNodeData> | undefined;
+    /**
+     * A node's box in **world** coordinates — its `parentId` chain resolved, and
+     * its explicit or measured size applied. `null` for an id that isn't in the
+     * graph.
+     *
+     * This is where the node currently *is on screen*, not what the document
+     * says: a node a peer is dragging or resizing reports the box they last sent
+     * (see {@link setPeerNodeTransform}), which is what anything painting over
+     * the graph wants. Reach for {@link getNode} instead when you're computing a
+     * mutation — that position is the one the document will agree with.
+     *
+     * Reads once; never subscribes. Call it inside your own frame loop.
+     */
+    getNodeRect: (id: NodeId) => Rect | null;
     setNodes: (nodes: Updater<RivetNode<TNodeData>[]>) => void;
     addNodes: (nodes: RivetNode<TNodeData> | RivetNode<TNodeData>[]) => void;
     updateNode: (id: NodeId, patch: Updater<RivetNode<TNodeData>>) => void;

package/dist/index.js

@@ -1,9 +1,9 @@
 import { parseAnchorHandleId, ANCHOR_SIDES, anchorDotHandleId, strayPlacementPct, anchorHandleId, anchorAutoHandleId, parseAnchorAutoHandleId, normalizeAnchorConnection, computeAnchorGeometry, anchorGeometryEqual, DEFAULT_ANCHOR_OPTIONS } from './chunk-AXT35ZJV.js';
-import { createPresenceRegistry, createLockRegistry, DEFAULT_PRESENCE_OPTIONS, peerColor } from './chunk-RG5ALD3X.js';
-export { LOCK_DEFAULT_REFUSED, useNodeLock, useNodeLockAllows } from './chunk-RG5ALD3X.js';
-import { clamp, clampNodeToLanes, swimlaneChromeAt, SWIMLANE_LABEL_WIDTH, resolveSwimlanes, flattenLanes, resolveMargin, requiredLaneHeight, withAlpha } from './chunk-6XRQSAQT.js';
+import { createPresenceRegistry, createLockRegistry, DEFAULT_PRESENCE_OPTIONS, peerColor } from './chunk-A52HZWLH.js';
+export { LOCK_DEFAULT_REFUSED, useNodeLock, useNodeLockAllows } from './chunk-A52HZWLH.js';
 import { useRivetContext, RivetNodeContext, useRivetNodeContext, useRivetControls, RivetContext, useRivetViewport } from './chunk-VQYN27OK.js';
 export { useRivetContext, useRivetControls, useRivetFocusedNode, useRivetHistory, useRivetViewport } from './chunk-VQYN27OK.js';
+import { clamp, clampNodeToLanes, swimlaneChromeAt, SWIMLANE_LABEL_WIDTH, resolveSwimlanes, flattenLanes, resolveMargin, requiredLaneHeight, withAlpha } from './chunk-6XRQSAQT.js';
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { memo, useRef, useState, useCallback, useSyncExternalStore, useMemo, useEffect, Fragment as Fragment$1, useId, useLayoutEffect } from 'react';
 
@@ -1025,7 +1025,10 @@ var RivetGraphStore = class {
   anchors = /* @__PURE__ */ new Map();
   // Arrow-wrapped so the (later-initialized) requestRender field is looked up
   // at call time, not while this field is being constructed.
-  presence = createPresenceRegistry(() => this.requestRender());
+  presence = createPresenceRegistry({
+    requestRender: () => this.requestRender(),
+    requestCursorRender: () => this.requestCursorRender()
+  });
   locks = createLockRegistry(() => this.requestRender());
   viewport;
   viewportClamp = null;
@@ -1072,6 +1075,12 @@ var RivetGraphStore = class {
   peerWorldVersion = -1;
   renderRequester = () => {
   };
+  /**
+   * Null until a runtime claims it, and then `requestCursorRender` narrows to
+   * the cursor layer. Falling back to a full frame is the safe default: a
+   * consumer without the layer mounted still gets its paint.
+   */
+  cursorRenderRequester = null;
   constructor(init) {
     this.viewport = init.viewport;
     for (const node of init.nodes) this.writeNode(node.id, node);
@@ -1419,8 +1428,14 @@ var RivetGraphStore = class {
   getNodeRect = (id) => {
     const origin = this.getNodeWorldPosition(id);
     const live = this.heldNodeIds.has(id) ? void 0 : this.presence.getNodeTransforms().get(id);
-    const size = live ?? this.nodes.get(id)?.size ?? DEFAULT_NODE_SIZE;
-    return { x: origin.x, y: origin.y, width: size.width, height: size.height };
+    if (live) return { x: origin.x, y: origin.y, width: live.width, height: live.height };
+    const node = this.nodes.get(id);
+    return {
+      x: origin.x,
+      y: origin.y,
+      width: node?.width ?? node?.size?.width ?? DEFAULT_NODE_SIZE.width,
+      height: node?.height ?? node?.size?.height ?? DEFAULT_NODE_SIZE.height
+    };
   };
   getNodeDepth = (id) => nodeDepth(this.nodes, id);
   getDescendantIds = (id) => descendantIds(this.nodes, id);
@@ -2010,6 +2025,13 @@ var RivetGraphStore = class {
   bindRenderRequester = (fn) => {
     this.renderRequester = fn;
   };
+  requestCursorRender = () => {
+    if (this.cursorRenderRequester) this.cursorRenderRequester();
+    else this.renderRequester();
+  };
+  bindCursorRenderRequester = (fn) => {
+    this.cursorRenderRequester = fn;
+  };
   // --- reconnect gateway (runtime-bound; consulted by <Handle>) ------------
   reconnectDelegate = null;
   getSelectedEdge = () => this.selectedEdgeId;
@@ -3043,7 +3065,7 @@ function createPanController(deps) {
 
 // src/input/resize-controller.ts
 function createResizeController(deps) {
-  const { pane, bgCanvas, size, edgeRenderer, foregroundRenderer, schedule } = deps;
+  const { pane, bgCanvas, size, edgeRenderer, foregroundRenderer, onResize, schedule } = deps;
   const resize = () => {
     const rect = pane.getBoundingClientRect();
     size.width = rect.width;
@@ -3055,6 +3077,7 @@ function createResizeController(deps) {
     bgCanvas.style.height = `${rect.height}px`;
     edgeRenderer.resize(rect.width, rect.height, size.dpr);
     foregroundRenderer.resize(rect.width, rect.height, size.dpr);
+    onResize?.();
     schedule();
   };
   const observer = new ResizeObserver(resize);
@@ -3199,7 +3222,7 @@ function drawCursor(ctx, point, color, name) {
   ctx.fillStyle = "#ffffff";
   ctx.fillText(name, x + LABEL_PADDING_X, y + LABEL_HEIGHT / 2);
 }
-function drawPresence(ctx, peers, { viewport, size, getNodeRect, renderCursors, locks }) {
+function drawPeerOutlines(ctx, peers, { viewport, size, getNodeRect, locks }) {
   if (peers.length === 0 && locks.size === 0) return;
   ctx.save();
   ctx.setTransform(size.dpr, 0, 0, size.dpr, 0, 0);
@@ -3232,16 +3255,18 @@ function drawPresence(ctx, peers, { viewport, size, getNodeRect, renderCursors,
       drawNodeOutline(ctx, screen, declared.get(holderId) ?? peerColor(holderId), "held");
     }
   }
-  if (renderCursors) {
-    for (const peer of peers) {
-      if (!peer.cursor) continue;
-      const point = worldToScreen(peer.cursor, viewport);
-      if (!onScreen({ ...point, width: 0, height: 0 }, size)) continue;
-      drawCursor(ctx, point, peer.color, peer.name);
-    }
-  }
   ctx.restore();
 }
+function drawPeerCursors(ctx, peers, { viewport, size }) {
+  ctx.setTransform(size.dpr, 0, 0, size.dpr, 0, 0);
+  ctx.clearRect(0, 0, size.width, size.height);
+  for (const peer of peers) {
+    if (!peer.cursor) continue;
+    const point = worldToScreen(peer.cursor, viewport);
+    if (!onScreen({ ...point, width: 0, height: 0 }, size)) continue;
+    drawCursor(ctx, point, peer.color, peer.name);
+  }
+}
 
 // src/renderer/swimlane.ts
 var DEFAULTS = {
@@ -3318,7 +3343,7 @@ function drawEndpointBubbles(ctx, ends, size) {
 }
 function useRivetRuntime(params) {
   const { store, paneRef, nodeContainerRef } = params;
-  const { backgroundCanvasRef, edgeCanvasRef, foregroundCanvasRef } = params;
+  const { backgroundCanvasRef, edgeCanvasRef, foregroundCanvasRef, cursorCanvasRef } = params;
   const { swimlaneLanes, scrollToPan, zoomSpeed } = params;
   const { minZoom, maxZoom, gridGap, edgeTypes, defaultEdgeOptions, anchorOptions } = params;
   const { edgeRenderer: createEdgeRenderer } = params;
@@ -3357,6 +3382,7 @@ function useRivetRuntime(params) {
     const size = sizeRef.current;
     let frame = 0;
     let dirty = true;
+    let cursorsDirty = true;
     let hoveredEdgeId = null;
     let peerPositioned = /* @__PURE__ */ new Set();
     const positionPeerNodes = (worldPositions) => {
@@ -3383,6 +3409,39 @@ function useRivetRuntime(params) {
       }
       peerPositioned = current;
     };
+    let cursorCanvas = null;
+    let cursorCtx = null;
+    let cursorAllocated = false;
+    const sizeCursorLayer = () => {
+      if (!cursorCanvas || !cursorAllocated) return;
+      cursorCanvas.width = Math.max(1, Math.round(size.width * size.dpr));
+      cursorCanvas.height = Math.max(1, Math.round(size.height * size.dpr));
+      cursorCanvas.style.width = `${size.width}px`;
+      cursorCanvas.style.height = `${size.height}px`;
+    };
+    const drawCursorLayer = () => {
+      const canvas = cursorCanvasRef.current;
+      if (canvas !== cursorCanvas) {
+        cursorCanvas = canvas;
+        cursorCtx = canvas?.getContext("2d") ?? null;
+        cursorAllocated = false;
+      }
+      if (!cursorCtx) return;
+      const peers = store.presence.getPeers();
+      const wanted = peers.some((peer) => peer.cursor);
+      if (!wanted && !cursorAllocated) return;
+      if (!cursorAllocated) {
+        cursorAllocated = true;
+        sizeCursorLayer();
+      }
+      drawPeerCursors(cursorCtx, peers, { viewport: store.getViewport(), size });
+    };
+    const stepPresence = () => {
+      const version = store.presence.getTransformVersion();
+      if (!store.presence.step(performance.now())) return;
+      if (store.presence.getTransformVersion() !== version) schedule();
+      else scheduleCursors();
+    };
     const anchorPlacement = (nodeId, anchorId, side) => {
       const record = store.anchors.get(handleKey(nodeId, anchorId));
       return record?.geometry ? strayPlacementPct(record.geometry, side, anchorOptions) : null;
@@ -3400,7 +3459,7 @@ function useRivetRuntime(params) {
     });
     const render = () => {
       zoom.step();
-      if (store.presence.step(performance.now())) schedule();
+      stepPresence();
       const viewport = store.getViewport();
       layerHint.apply(viewportToCss(viewport));
       bgCtx.setTransform(size.dpr, 0, 0, size.dpr, 0, 0);
@@ -3438,14 +3497,14 @@ function useRivetRuntime(params) {
         }
       }
       if (fgCtx && (!store.presence.isEmpty() || store.locks.size() > 0)) {
-        drawPresence(fgCtx, store.presence.getPeers(), {
+        drawPeerOutlines(fgCtx, store.presence.getPeers(), {
           viewport,
           size,
           getNodeRect: (id) => store.nodes.has(id) ? store.getNodeRect(id) : null,
-          renderCursors: reconnectRef.current.presenceOptions.renderCursors,
           locks: store.locks.getLocks()
         });
       }
+      drawCursorLayer();
       if (edgeList.some((edge) => edge.animated ?? defaultEdgeOptions?.animated)) schedule();
       const rect = visibleWorldRect(viewport, size.width, size.height);
       const margin = CULL_MARGIN_PX2 / viewport.zoom;
@@ -3477,16 +3536,29 @@ function useRivetRuntime(params) {
     };
     const tick = () => {
       frame = 0;
-      if (!dirty) return;
-      dirty = false;
-      render();
+      if (dirty) {
+        dirty = false;
+        cursorsDirty = false;
+        render();
+        return;
+      }
+      if (!cursorsDirty) return;
+      cursorsDirty = false;
+      stepPresence();
+      drawCursorLayer();
     };
     const schedule = () => {
       dirty = true;
       if (frame) return;
       frame = requestAnimationFrame(tick);
     };
+    const scheduleCursors = () => {
+      cursorsDirty = true;
+      if (frame) return;
+      frame = requestAnimationFrame(tick);
+    };
     store.bindRenderRequester(schedule);
+    store.bindCursorRenderRequester(scheduleCursors);
     const setEdgeHover = (id) => {
       if (hoveredEdgeId === id) return;
       hoveredEdgeId = id;
@@ -3696,6 +3768,7 @@ function useRivetRuntime(params) {
       size,
       edgeRenderer,
       foregroundRenderer,
+      onResize: sizeCursorLayer,
       schedule
     });
     pane.addEventListener("wheel", zoom.onWheel, { passive: false });
@@ -3712,6 +3785,7 @@ function useRivetRuntime(params) {
       resizer.dispose();
       store.bindRenderRequester(() => {
       });
+      store.bindCursorRenderRequester(null);
       store.bindReconnectDelegate(null);
       unsubscribeFocus();
       if (focusRetryFrame) cancelAnimationFrame(focusRetryFrame);
@@ -3739,6 +3813,7 @@ function useRivetRuntime(params) {
     backgroundCanvasRef,
     edgeCanvasRef,
     foregroundCanvasRef,
+    cursorCanvasRef,
     scrollToPan,
     zoomSpeed,
     minZoom,
@@ -5189,6 +5264,7 @@ function Rivet({
   const backgroundCanvasRef = useRef(null);
   const edgeCanvasRef = useRef(null);
   const foregroundCanvasRef = useRef(null);
+  const cursorCanvasRef = useRef(null);
   useEffect(() => {
     if (peers === void 0) return;
     store.presence.setPeers(peers);
@@ -5213,11 +5289,11 @@ function Rivet({
     backgroundCanvasRef,
     edgeCanvasRef,
     foregroundCanvasRef,
+    cursorCanvasRef,
     swimlaneLanes: swimlanes.lanes,
     edgeTypes: cfg.edgeTypes,
     defaultEdgeOptions: cfg.defaultEdgeOptions,
     anchorOptions: cfg.anchorOptions,
-    presenceOptions: cfg.presenceOptions,
     edgeRenderer: renderer,
     edgesReconnectable,
     isValidConnection: cfg.isValidConnection,
@@ -5306,6 +5382,7 @@ function Rivet({
         /* @__PURE__ */ jsx("canvas", { ref: edgeCanvasRef, style: canvasStyle }),
         /* @__PURE__ */ jsx(NodeLayer, { containerRef: nodeContainerRef, visibleIds }),
         /* @__PURE__ */ jsx("canvas", { ref: foregroundCanvasRef, style: canvasStyle }),
+        cfg.presenceOptions.renderCursors && /* @__PURE__ */ jsx("canvas", { ref: cursorCanvasRef, style: canvasStyle }),
         /* @__PURE__ */ jsx(EdgeLabelLayer, {}),
         /* @__PURE__ */ jsx(SwimlaneOverlay, {}),
         children,
@@ -5365,6 +5442,10 @@ function buildInstance(store, controls, getViewportElements) {
     ),
     getNodes,
     getNode: (id) => store.nodes.get(id),
+    // The store's own `getNodeRect` answers for any id, falling back to the
+    // origin and the default size; a public caller needs to tell "it's there,
+    // at 0,0" from "it isn't there".
+    getNodeRect: (id) => store.nodes.has(id) ? store.getNodeRect(id) : null,
     setNodes,
     addNodes: (nodes) => {
       for (const node of Array.isArray(nodes) ? nodes : [nodes]) store.addNode(node);