@kolosal-ai/rivet 0.1.1 → 0.3.0

package/README.md

@@ -36,6 +36,10 @@ export function App() {
   node, measured live (`@kolosal-ai/rivet/anchor`).
 - **SVG artwork nodes** — parse and render SVG inside nodes, with anchors on
   elements inside the artwork (`@kolosal-ai/rivet/svg`).
+- **Multiplayer seams** — origin-tagged change batches with `applyRemote`, local
+  gestures that own their geometry, presence (peer cursors, selections and the
+  nodes they're moving), and locks that refuse local interaction on a node a peer has
+  claimed (`@kolosal-ai/rivet/presence`).
 - **Pluggable edge renderer** — swap the Canvas2D backend through the
   `renderer` prop (`EdgeRendererFactory`).
 - **Keyboard + ARIA** — roving node focus, grab-to-move, keyboard connect, live

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-Dkk4ZKt-.js';
-import '../types-B8AAJ60T.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-A52HZWLH.js

@@ -0,0 +1,314 @@
+import { useRivetContext } from './chunk-VQYN27OK.js';
+import { useCallback, useSyncExternalStore } from 'react';
+
+// src/locks/registry.ts
+var LOCK_DEFAULT_REFUSED = /* @__PURE__ */ new Set([
+  "select",
+  "drag",
+  "resize",
+  "delete"
+]);
+function locksEqual(current, next) {
+  const keys = Object.keys(next);
+  if (keys.length !== current.size) return false;
+  return keys.every((id) => current.get(id) === next[id]);
+}
+var Registry = class {
+  /** Marks the canvas dirty — a lock is paint as well as policy. */
+  constructor(requestRender) {
+    this.requestRender = requestRender;
+  }
+  requestRender;
+  locks = /* @__PURE__ */ new Map();
+  policy = null;
+  version = 0;
+  listeners = /* @__PURE__ */ new Set();
+  setLocks = (locks) => {
+    const next = locks ?? {};
+    if (locksEqual(this.locks, next)) return [];
+    const opened = [];
+    for (const [id, holderId] of Object.entries(next)) {
+      if (this.locks.get(id) !== holderId) opened.push(id);
+    }
+    this.locks = new Map(Object.entries(next));
+    this.version += 1;
+    this.requestRender();
+    for (const listener of this.listeners) listener();
+    return opened;
+  };
+  setPolicy = (policy) => {
+    this.policy = policy;
+  };
+  isLocked = (id) => this.locks.has(id);
+  getHolder = (id) => this.locks.get(id) ?? null;
+  getLocks = () => this.locks;
+  size = () => this.locks.size;
+  allows = (id, intent) => {
+    if (this.locks.size === 0) return true;
+    const holderId = this.locks.get(id);
+    if (holderId === void 0) return true;
+    if (this.policy) return this.policy({ nodeId: id, holderId, intent });
+    return !LOCK_DEFAULT_REFUSED.has(intent);
+  };
+  getVersion = () => this.version;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+};
+function createLockRegistry(requestRender) {
+  return new Registry(requestRender);
+}
+
+// src/presence/registry.ts
+var DEFAULT_PRESENCE_OPTIONS = {
+  throttleMs: 50,
+  renderCursors: true
+};
+var PEER_COLORS = [
+  "#6366f1",
+  "#ec4899",
+  "#f59e0b",
+  "#10b981",
+  "#3b82f6",
+  "#8b5cf6",
+  "#ef4444",
+  "#14b8a6"
+];
+function peerColor(id) {
+  let hash = 0;
+  for (let i = 0; i < id.length; i += 1) hash = hash * 31 + id.charCodeAt(i) | 0;
+  const index = (hash % PEER_COLORS.length + PEER_COLORS.length) % PEER_COLORS.length;
+  return PEER_COLORS[index] ?? PEER_COLORS[0];
+}
+var SMOOTHING_MS = 45;
+var NOMINAL_FRAME_MS = 16;
+var SETTLED_EPSILON = 0.05;
+function approach(from, to, t) {
+  const next = from + (to - from) * t;
+  return Math.abs(to - next) < SETTLED_EPSILON ? to : next;
+}
+var EMPTY_IDS = [];
+var samePoint = (a, b) => a === b || a != null && b != null && a.x === b.x && a.y === b.y;
+var sameRect = (a, b) => a !== void 0 && a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+var sameIds = (a, b) => {
+  const left = a ?? EMPTY_IDS;
+  const right = b ?? EMPTY_IDS;
+  return left.length === right.length && left.every((id, i) => id === right[i]);
+};
+function declarationEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  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 — something has to repaint either way. */
+  constructor(requests) {
+    this.requests = requests;
+  }
+  requests;
+  peers = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  snapshot = [];
+  stale = false;
+  /** Merged rendered transforms across peers, rebuilt when {@link version} moves. */
+  transforms = /* @__PURE__ */ new Map();
+  transformsStale = false;
+  version = 0;
+  /** Timestamp of the last {@link step}, so the ease is frame-rate independent. */
+  lastStep = -1;
+  touch() {
+    this.stale = true;
+    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() {
+    this.touch();
+    for (const listener of this.listeners) listener();
+  }
+  peer(id) {
+    let state = this.peers.get(id);
+    if (!state) {
+      state = {
+        id,
+        declared: null,
+        live: void 0,
+        renderCursor: null,
+        transforms: /* @__PURE__ */ new Map(),
+        renderTransforms: /* @__PURE__ */ new Map()
+      };
+      this.peers.set(id, state);
+    }
+    return state;
+  }
+  /** Drop a peer the roster doesn't claim and that has nothing left to draw. */
+  prune(state) {
+    if (state.declared || state.live || state.transforms.size > 0) return;
+    this.peers.delete(state.id);
+    this.invalidateTransforms();
+  }
+  invalidateTransforms() {
+    this.transformsStale = true;
+    this.version += 1;
+  }
+  setPeers = (peers) => {
+    let changed = false;
+    const incoming = /* @__PURE__ */ new Set();
+    for (const peer of peers) {
+      incoming.add(peer.id);
+      const state = this.peer(peer.id);
+      if (declarationEqual(state.declared, peer)) continue;
+      state.declared = peer;
+      changed = true;
+    }
+    for (const state of [...this.peers.values()]) {
+      if (incoming.has(state.id)) continue;
+      if (!state.declared) continue;
+      this.peers.delete(state.id);
+      changed = true;
+    }
+    if (changed) this.touchRoster();
+  };
+  setPeerCursor = (peerId, point) => {
+    const state = this.peer(peerId);
+    if (state.live !== void 0 && samePoint(state.live, point)) return;
+    state.live = point;
+    if (point === null) this.prune(state);
+    this.touchCursor();
+  };
+  setPeerNodeTransform = (peerId, nodeId, rect) => {
+    const state = this.peer(peerId);
+    if (rect === null) {
+      const had = state.transforms.delete(nodeId);
+      state.renderTransforms.delete(nodeId);
+      this.prune(state);
+      if (!had) return;
+      this.invalidateTransforms();
+      this.touch();
+      return;
+    }
+    if (sameRect(state.transforms.get(nodeId), rect)) return;
+    state.transforms.set(nodeId, rect);
+    if (!state.renderTransforms.has(nodeId)) {
+      state.renderTransforms.set(nodeId, rect);
+      this.invalidateTransforms();
+    }
+    this.touch();
+  };
+  removePeer = (peerId) => {
+    if (!this.peers.delete(peerId)) return;
+    this.invalidateTransforms();
+    this.touchRoster();
+  };
+  getNodeTransforms = () => {
+    if (this.transformsStale) {
+      this.transformsStale = false;
+      this.transforms = /* @__PURE__ */ new Map();
+      for (const state of this.peers.values()) {
+        for (const [nodeId, rect] of state.renderTransforms) this.transforms.set(nodeId, rect);
+      }
+    }
+    return this.transforms;
+  };
+  getTransformVersion = () => this.version;
+  step = (now) => {
+    const elapsed = this.lastStep < 0 ? NOMINAL_FRAME_MS : Math.max(0, now - this.lastStep);
+    this.lastStep = now;
+    const t = 1 - Math.exp(-elapsed / SMOOTHING_MS);
+    let moving = false;
+    let transformsMoved = false;
+    for (const state of this.peers.values()) {
+      const target = state.live !== void 0 ? state.live : state.declared?.cursor ?? null;
+      if (target === null) {
+        state.renderCursor = null;
+      } else if (!state.renderCursor) {
+        state.renderCursor = target;
+      } else if (!samePoint(state.renderCursor, target)) {
+        state.renderCursor = {
+          x: approach(state.renderCursor.x, target.x, t),
+          y: approach(state.renderCursor.y, target.y, t)
+        };
+        moving = true;
+      }
+      for (const [nodeId, rect] of state.transforms) {
+        const current = state.renderTransforms.get(nodeId);
+        if (!current) {
+          state.renderTransforms.set(nodeId, rect);
+          transformsMoved = true;
+          continue;
+        }
+        if (sameRect(current, rect)) continue;
+        state.renderTransforms.set(nodeId, {
+          x: approach(current.x, rect.x, t),
+          y: approach(current.y, rect.y, t),
+          // Size comes from a resize rather than a drag and rarely differs
+          // frame to frame, but easing it keeps a live resize as smooth.
+          width: approach(current.width, rect.width, t),
+          height: approach(current.height, rect.height, t)
+        });
+        transformsMoved = true;
+        moving = true;
+      }
+    }
+    if (transformsMoved) this.invalidateTransforms();
+    if (moving) this.stale = true;
+    return moving;
+  };
+  getPeers = () => {
+    if (this.stale) {
+      this.stale = false;
+      this.snapshot = [...this.peers.values()].map((state) => {
+        const declared = state.declared;
+        const target = (state.live !== void 0 ? state.live : declared?.cursor) ?? null;
+        return {
+          id: state.id,
+          name: declared?.name,
+          color: declared?.color ?? peerColor(state.id),
+          // Rendered, not raw: what {@link step} has eased to. Falls back to the
+          // target so a registry nobody steps still paints something sensible.
+          cursor: target === null ? null : state.renderCursor ?? target,
+          selection: declared?.selection ?? EMPTY_IDS,
+          holding: declared?.holding ?? EMPTY_IDS,
+          transforms: state.renderTransforms
+        };
+      });
+    }
+    return this.snapshot;
+  };
+  isEmpty = () => this.peers.size === 0;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+};
+function createPresenceRegistry(requests) {
+  return new Registry2(requests);
+}
+var UNLOCKED = { locked: false };
+function useNodeLock(id) {
+  const { store } = useRivetContext();
+  const getHolder = useCallback(() => store.locks.getHolder(id), [store, id]);
+  const holderId = useSyncExternalStore(store.locks.subscribe, getHolder, getHolder);
+  return holderId === null ? UNLOCKED : { locked: true, holderId };
+}
+function useNodeLockAllows(id, intent) {
+  const { store } = useRivetContext();
+  const allows = useCallback(() => store.locks.allows(id, intent), [store, id, intent]);
+  return useSyncExternalStore(store.locks.subscribe, allows, allows);
+}
+
+export { DEFAULT_PRESENCE_OPTIONS, LOCK_DEFAULT_REFUSED, PEER_COLORS, createLockRegistry, createPresenceRegistry, peerColor, useNodeLock, useNodeLockAllows };
+//# 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":";;;;AAuEO,IAAM,oBAAA,uBAAoD,GAAA,CAAgB;AAAA,EAC/E,QAAA;AAAA,EACA,MAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAC;AAqCD,SAAS,UAAA,CAAW,SAAsC,IAAA,EAAuC;AAC/F,EAAA,MAAM,IAAA,GAAO,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA;AAC7B,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,OAAA,CAAQ,IAAA,EAAM,OAAO,KAAA;AACzC,EAAA,OAAO,IAAA,CAAK,KAAA,CAAM,CAAC,EAAA,KAAO,OAAA,CAAQ,IAAI,EAAE,CAAA,KAAM,IAAA,CAAK,EAAE,CAAC,CAAA;AACxD;AAEA,IAAM,WAAN,MAAuC;AAAA;AAAA,EAOrC,YAA6B,aAAA,EAA2B;AAA3B,IAAA,IAAA,CAAA,aAAA,GAAA,aAAA;AAAA,EAA4B;AAAA,EAA5B,aAAA;AAAA,EANrB,KAAA,uBAAY,GAAA,EAAoB;AAAA,EAChC,MAAA,GAAuC,IAAA;AAAA,EACvC,OAAA,GAAU,CAAA;AAAA,EACD,SAAA,uBAAgB,GAAA,EAAgB;AAAA,EAKjD,QAAA,GAAW,CAAC,KAAA,KAAwD;AAClE,IAAA,MAAM,IAAA,GAAO,SAAS,EAAC;AAGvB,IAAA,IAAI,WAAW,IAAA,CAAK,KAAA,EAAO,IAAI,CAAA,SAAU,EAAC;AAC1C,IAAA,MAAM,SAAmB,EAAC;AAC1B,IAAA,KAAA,MAAW,CAAC,EAAA,EAAI,QAAQ,KAAK,MAAA,CAAO,OAAA,CAAQ,IAAI,CAAA,EAAG;AACjD,MAAA,IAAI,IAAA,CAAK,MAAM,GAAA,CAAI,EAAE,MAAM,QAAA,EAAU,MAAA,CAAO,KAAK,EAAE,CAAA;AAAA,IACrD;AACA,IAAA,IAAA,CAAK,QAAQ,IAAI,GAAA,CAAI,MAAA,CAAO,OAAA,CAAQ,IAAI,CAAC,CAAA;AACzC,IAAA,IAAA,CAAK,OAAA,IAAW,CAAA;AAChB,IAAA,IAAA,CAAK,aAAA,EAAc;AACnB,IAAA,KAAA,MAAW,QAAA,IAAY,IAAA,CAAK,SAAA,EAAW,QAAA,EAAS;AAChD,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAAA,EAEA,SAAA,GAAY,CAAC,MAAA,KAA+C;AAC1D,IAAA,IAAA,CAAK,MAAA,GAAS,MAAA;AAAA,EAChB,CAAA;AAAA,EAEA,WAAW,CAAC,EAAA,KAAwB,IAAA,CAAK,KAAA,CAAM,IAAI,EAAE,CAAA;AAAA,EAErD,YAAY,CAAC,EAAA,KAA8B,KAAK,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA,IAAK,IAAA;AAAA,EAEjE,QAAA,GAAW,MAAmC,IAAA,CAAK,KAAA;AAAA,EAEnD,IAAA,GAAO,MAAc,IAAA,CAAK,KAAA,CAAM,IAAA;AAAA,EAEhC,MAAA,GAAS,CAAC,EAAA,EAAY,MAAA,KAAgC;AAEpD,IAAA,IAAI,IAAA,CAAK,KAAA,CAAM,IAAA,KAAS,CAAA,EAAG,OAAO,IAAA;AAClC,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA;AAClC,IAAA,IAAI,QAAA,KAAa,QAAW,OAAO,IAAA;AACnC,IAAA,IAAI,IAAA,CAAK,MAAA,EAAQ,OAAO,IAAA,CAAK,MAAA,CAAO,EAAE,MAAA,EAAQ,EAAA,EAAI,QAAA,EAAU,MAAA,EAAQ,CAAA;AACpE,IAAA,OAAO,CAAC,oBAAA,CAAqB,GAAA,CAAI,MAAM,CAAA;AAAA,EACzC,CAAA;AAAA,EAEA,UAAA,GAAa,MAAc,IAAA,CAAK,OAAA;AAAA,EAEhC,SAAA,GAAY,CAAC,QAAA,KAAuC;AAClD,IAAA,IAAA,CAAK,SAAA,CAAU,IAAI,QAAQ,CAAA;AAC3B,IAAA,OAAO,MAAM;AACX,MAAA,IAAA,CAAK,SAAA,CAAU,OAAO,QAAQ,CAAA;AAAA,IAChC,CAAA;AAAA,EACF,CAAA;AACF,CAAA;AAGO,SAAS,mBAAmB,aAAA,EAAyC;AAC1E,EAAA,OAAO,IAAI,SAAS,aAAa,CAAA;AACnC;;;ACpFO,IAAM,wBAAA,GAAoD;AAAA,EAC/D,UAAA,EAAY,EAAA;AAAA,EACZ,aAAA,EAAe;AACjB;AAMO,IAAM,WAAA,GAAc;AAAA,EACzB,SAAA;AAAA,EACA,SAAA;AAAA,EACA,SAAA;AAAA,EACA,SAAA;AAAA,EACA,SAAA;AAAA,EACA,SAAA;AAAA,EACA,SAAA;AAAA,EACA;AACF;AAOO,SAAS,UAAU,EAAA,EAAoB;AAC5C,EAAA,IAAI,IAAA,GAAO,CAAA;AACX,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,EAAA,CAAG,MAAA,EAAQ,CAAA,IAAK,CAAA,EAAG,IAAA,GAAQ,IAAA,GAAO,EAAA,GAAK,EAAA,CAAG,UAAA,CAAW,CAAC,CAAA,GAAK,CAAA;AAE/E,EAAA,MAAM,SAAU,IAAA,GAAO,WAAA,CAAY,MAAA,GAAU,WAAA,CAAY,UAAU,WAAA,CAAY,MAAA;AAC/E,EAAA,OAAO,WAAA,CAAY,KAAK,CAAA,IAAK,WAAA,CAAY,CAAC,CAAA;AAC5C;AA2FA,IAAM,YAAA,GAAe,EAAA;AAErB,IAAM,gBAAA,GAAmB,EAAA;AAEzB,IAAM,eAAA,GAAkB,IAAA;AAGxB,SAAS,QAAA,CAAS,IAAA,EAAc,EAAA,EAAY,CAAA,EAAmB;AAC7D,EAAA,MAAM,IAAA,GAAO,IAAA,GAAA,CAAQ,EAAA,GAAK,IAAA,IAAQ,CAAA;AAClC,EAAA,OAAO,KAAK,GAAA,CAAI,EAAA,GAAK,IAAI,CAAA,GAAI,kBAAkB,EAAA,GAAK,IAAA;AACtD;AAEA,IAAM,YAA+B,EAAC;AAEtC,IAAM,YAAY,CAAC,CAAA,EAA4B,CAAA,KAC7C,CAAA,KAAM,KAAM,CAAA,IAAK,IAAA,IAAQ,CAAA,IAAK,IAAA,IAAQ,EAAE,CAAA,KAAM,CAAA,CAAE,CAAA,IAAK,CAAA,CAAE,MAAM,CAAA,CAAE,CAAA;AAEjE,IAAM,QAAA,GAAW,CAAC,CAAA,EAAqB,CAAA,KACrC,MAAM,MAAA,IAAa,CAAA,CAAE,MAAM,CAAA,CAAE,CAAA,IAAK,EAAE,CAAA,KAAM,CAAA,CAAE,KAAK,CAAA,CAAE,KAAA,KAAU,EAAE,KAAA,IAAS,CAAA,CAAE,WAAW,CAAA,CAAE,MAAA;AAEzF,IAAM,OAAA,GAAU,CAAC,CAAA,EAAkC,CAAA,KAA8C;AAC/F,EAAA,MAAM,OAAO,CAAA,IAAK,SAAA;AAClB,EAAA,MAAM,QAAQ,CAAA,IAAK,SAAA;AACnB,EAAA,OAAO,IAAA,CAAK,MAAA,KAAW,KAAA,CAAM,MAAA,IAAU,IAAA,CAAK,KAAA,CAAM,CAAC,EAAA,EAAI,CAAA,KAAM,EAAA,KAAO,KAAA,CAAM,CAAC,CAAC,CAAA;AAC9E,CAAA;AAGA,SAAS,gBAAA,CAAiB,GAAgB,CAAA,EAAyB;AACjE,EAAA,IAAI,CAAA,KAAM,GAAG,OAAO,IAAA;AACpB,EAAA,IAAI,CAAC,CAAA,IAAK,CAAC,CAAA,EAAG,OAAO,KAAA;AACrB,EAAA,OACE,CAAA,CAAE,IAAA,KAAS,CAAA,CAAE,IAAA,IACb,CAAA,CAAE,UAAU,CAAA,CAAE,KAAA,IACd,SAAA,CAAU,CAAA,CAAE,MAAA,EAAQ,CAAA,CAAE,MAAM,CAAA,IAC5B,OAAA,CAAQ,CAAA,CAAE,SAAA,EAAW,CAAA,CAAE,SAAS,KAChC,OAAA,CAAQ,CAAA,CAAE,OAAA,EAAS,CAAA,CAAE,OAAO,CAAA;AAEhC;AAEA,IAAMA,YAAN,MAA2C;AAAA;AAAA,EAazC,YAA6B,QAAA,EAAkC;AAAlC,IAAA,IAAA,CAAA,QAAA,GAAA,QAAA;AAAA,EAAmC;AAAA,EAAnC,QAAA;AAAA,EAZZ,KAAA,uBAAY,GAAA,EAAuB;AAAA,EACnC,SAAA,uBAAgB,GAAA,EAAgB;AAAA,EACzC,WAAkC,EAAC;AAAA,EACnC,KAAA,GAAQ,KAAA;AAAA;AAAA,EAER,UAAA,uBAAoC,GAAA,EAAI;AAAA,EACxC,eAAA,GAAkB,KAAA;AAAA,EAClB,OAAA,GAAU,CAAA;AAAA;AAAA,EAEV,QAAA,GAAW,EAAA;AAAA,EAKX,KAAA,GAAc;AACpB,IAAA,IAAA,CAAK,KAAA,GAAQ,IAAA;AACb,IAAA,IAAA,CAAK,SAAS,aAAA,EAAc;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,WAAA,GAAoB;AAC1B,IAAA,IAAA,CAAK,KAAA,GAAQ,IAAA;AACb,IAAA,IAAA,CAAK,SAAS,mBAAA,EAAoB;AAAA,EACpC;AAAA;AAAA,EAGQ,WAAA,GAAoB;AAC1B,IAAA,IAAA,CAAK,KAAA,EAAM;AACX,IAAA,KAAA,MAAW,QAAA,IAAY,IAAA,CAAK,SAAA,EAAW,QAAA,EAAS;AAAA,EAClD;AAAA,EAEQ,KAAK,EAAA,EAAuB;AAClC,IAAA,IAAI,KAAA,GAAQ,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,EAAE,CAAA;AAC7B,IAAA,IAAI,CAAC,KAAA,EAAO;AACV,MAAA,KAAA,GAAQ;AAAA,QACN,EAAA;AAAA,QACA,QAAA,EAAU,IAAA;AAAA,QACV,IAAA,EAAM,MAAA;AAAA,QACN,YAAA,EAAc,IAAA;AAAA,QACd,UAAA,sBAAgB,GAAA,EAAI;AAAA,QACpB,gBAAA,sBAAsB,GAAA;AAAI,OAC5B;AACA,MAAA,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,EAAA,EAAI,KAAK,CAAA;AAAA,IAC1B;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA,EAGQ,MAAM,KAAA,EAAwB;AACpC,IAAA,IAAI,MAAM,QAAA,IAAY,KAAA,CAAM,QAAQ,KAAA,CAAM,UAAA,CAAW,OAAO,CAAA,EAAG;AAC/D,IAAA,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,KAAA,CAAM,EAAE,CAAA;AAC1B,IAAA,IAAA,CAAK,oBAAA,EAAqB;AAAA,EAC5B;AAAA,EAEQ,oBAAA,GAA6B;AACnC,IAAA,IAAA,CAAK,eAAA,GAAkB,IAAA;AACvB,IAAA,IAAA,CAAK,OAAA,IAAW,CAAA;AAAA,EAClB;AAAA,EAEA,QAAA,GAAW,CAAC,KAAA,KAAwB;AAClC,IAAA,IAAI,OAAA,GAAU,KAAA;AACd,IAAA,MAAM,QAAA,uBAAe,GAAA,EAAY;AACjC,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,QAAA,CAAS,GAAA,CAAI,KAAK,EAAE,CAAA;AACpB,MAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,IAAA,CAAK,IAAA,CAAK,EAAE,CAAA;AAC/B,MAAA,IAAI,gBAAA,CAAiB,KAAA,CAAM,QAAA,EAAU,IAAI,CAAA,EAAG;AAC5C,MAAA,KAAA,CAAM,QAAA,GAAW,IAAA;AACjB,MAAA,OAAA,GAAU,IAAA;AAAA,IACZ;AACA,IAAA,KAAA,MAAW,SAAS,CAAC,GAAG,KAAK,KAAA,CAAM,MAAA,EAAQ,CAAA,EAAG;AAC5C,MAAA,IAAI,QAAA,CAAS,GAAA,CAAI,KAAA,CAAM,EAAE,CAAA,EAAG;AAG5B,MAAA,IAAI,CAAC,MAAM,QAAA,EAAU;AACrB,MAAA,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,KAAA,CAAM,EAAE,CAAA;AAC1B,MAAA,OAAA,GAAU,IAAA;AAAA,IACZ;AACA,IAAA,IAAI,OAAA,OAAc,WAAA,EAAY;AAAA,EAChC,CAAA;AAAA,EAEA,aAAA,GAAgB,CAAC,MAAA,EAAgB,KAAA,KAA6B;AAC5D,IAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,IAAA,CAAK,MAAM,CAAA;AAC9B,IAAA,IAAI,MAAM,IAAA,KAAS,MAAA,IAAa,UAAU,KAAA,CAAM,IAAA,EAAM,KAAK,CAAA,EAAG;AAC9D,IAAA,KAAA,CAAM,IAAA,GAAO,KAAA;AACb,IAAA,IAAI,KAAA,KAAU,IAAA,EAAM,IAAA,CAAK,KAAA,CAAM,KAAK,CAAA;AAIpC,IAAA,IAAA,CAAK,WAAA,EAAY;AAAA,EACnB,CAAA;AAAA,EAEA,oBAAA,GAAuB,CAAC,MAAA,EAAgB,MAAA,EAAgB,IAAA,KAA4B;AAClF,IAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,IAAA,CAAK,MAAM,CAAA;AAC9B,IAAA,IAAI,SAAS,IAAA,EAAM;AACjB,MAAA,MAAM,GAAA,GAAM,KAAA,CAAM,UAAA,CAAW,MAAA,CAAO,MAAM,CAAA;AAG1C,MAAA,KAAA,CAAM,gBAAA,CAAiB,OAAO,MAAM,CAAA;AACpC,MAAA,IAAA,CAAK,MAAM,KAAK,CAAA;AAChB,MAAA,IAAI,CAAC,GAAA,EAAK;AACV,MAAA,IAAA,CAAK,oBAAA,EAAqB;AAC1B,MAAA,IAAA,CAAK,KAAA,EAAM;AACX,MAAA;AAAA,IACF;AACA,IAAA,IAAI,SAAS,KAAA,CAAM,UAAA,CAAW,IAAI,MAAM,CAAA,EAAG,IAAI,CAAA,EAAG;AAClD,IAAA,KAAA,CAAM,UAAA,CAAW,GAAA,CAAI,MAAA,EAAQ,IAAI,CAAA;AAGjC,IAAA,IAAI,CAAC,KAAA,CAAM,gBAAA,CAAiB,GAAA,CAAI,MAAM,CAAA,EAAG;AACvC,MAAA,KAAA,CAAM,gBAAA,CAAiB,GAAA,CAAI,MAAA,EAAQ,IAAI,CAAA;AACvC,MAAA,IAAA,CAAK,oBAAA,EAAqB;AAAA,IAC5B;AACA,IAAA,IAAA,CAAK,KAAA,EAAM;AAAA,EACb,CAAA;AAAA,EAEA,UAAA,GAAa,CAAC,MAAA,KAAyB;AACrC,IAAA,IAAI,CAAC,IAAA,CAAK,KAAA,CAAM,MAAA,CAAO,MAAM,CAAA,EAAG;AAChC,IAAA,IAAA,CAAK,oBAAA,EAAqB;AAC1B,IAAA,IAAA,CAAK,WAAA,EAAY;AAAA,EACnB,CAAA;AAAA,EAEA,oBAAoB,MAAiC;AACnD,IAAA,IAAI,KAAK,eAAA,EAAiB;AACxB,MAAA,IAAA,CAAK,eAAA,GAAkB,KAAA;AACvB,MAAA,IAAA,CAAK,UAAA,uBAAiB,GAAA,EAAI;AAC1B,MAAA,KAAA,MAAW,KAAA,IAAS,IAAA,CAAK,KAAA,CAAM,MAAA,EAAO,EAAG;AACvC,QAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,IAAI,CAAA,IAAK,KAAA,CAAM,kBAAkB,IAAA,CAAK,UAAA,CAAW,GAAA,CAAI,MAAA,EAAQ,IAAI,CAAA;AAAA,MACvF;AAAA,IACF;AACA,IAAA,OAAO,IAAA,CAAK,UAAA;AAAA,EACd,CAAA;AAAA,EAEA,mBAAA,GAAsB,MAAc,IAAA,CAAK,OAAA;AAAA,EAEzC,IAAA,GAAO,CAAC,GAAA,KAAyB;AAI/B,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,QAAA,GAAW,CAAA,GAAI,gBAAA,GAAmB,KAAK,GAAA,CAAI,CAAA,EAAG,GAAA,GAAM,IAAA,CAAK,QAAQ,CAAA;AACtF,IAAA,IAAA,CAAK,QAAA,GAAW,GAAA;AAChB,IAAA,MAAM,IAAI,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,CAAC,UAAU,YAAY,CAAA;AAC9C,IAAA,IAAI,MAAA,GAAS,KAAA;AACb,IAAA,IAAI,eAAA,GAAkB,KAAA;AAEtB,IAAA,KAAA,MAAW,KAAA,IAAS,IAAA,CAAK,KAAA,CAAM,MAAA,EAAO,EAAG;AACvC,MAAA,MAAM,MAAA,GAAS,MAAM,IAAA,KAAS,MAAA,GAAY,MAAM,IAAA,GAAQ,KAAA,CAAM,UAAU,MAAA,IAAU,IAAA;AAClF,MAAA,IAAI,WAAW,IAAA,EAAM;AACnB,QAAA,KAAA,CAAM,YAAA,GAAe,IAAA;AAAA,MACvB,CAAA,MAAA,IAAW,CAAC,KAAA,CAAM,YAAA,EAAc;AAC9B,QAAA,KAAA,CAAM,YAAA,GAAe,MAAA;AAAA,MACvB,WAAW,CAAC,SAAA,CAAU,KAAA,CAAM,YAAA,EAAc,MAAM,CAAA,EAAG;AACjD,QAAA,KAAA,CAAM,YAAA,GAAe;AAAA,UACnB,GAAG,QAAA,CAAS,KAAA,CAAM,aAAa,CAAA,EAAG,MAAA,CAAO,GAAG,CAAC,CAAA;AAAA,UAC7C,GAAG,QAAA,CAAS,KAAA,CAAM,aAAa,CAAA,EAAG,MAAA,CAAO,GAAG,CAAC;AAAA,SAC/C;AACA,QAAA,MAAA,GAAS,IAAA;AAAA,MACX;AAEA,MAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,IAAI,CAAA,IAAK,MAAM,UAAA,EAAY;AAC7C,QAAA,MAAM,OAAA,GAAU,KAAA,CAAM,gBAAA,CAAiB,GAAA,CAAI,MAAM,CAAA;AACjD,QAAA,IAAI,CAAC,OAAA,EAAS;AACZ,UAAA,KAAA,CAAM,gBAAA,CAAiB,GAAA,CAAI,MAAA,EAAQ,IAAI,CAAA;AACvC,UAAA,eAAA,GAAkB,IAAA;AAClB,UAAA;AAAA,QACF;AACA,QAAA,IAAI,QAAA,CAAS,OAAA,EAAS,IAAI,CAAA,EAAG;AAC7B,QAAA,KAAA,CAAM,gBAAA,CAAiB,IAAI,MAAA,EAAQ;AAAA,UACjC,GAAG,QAAA,CAAS,OAAA,CAAQ,CAAA,EAAG,IAAA,CAAK,GAAG,CAAC,CAAA;AAAA,UAChC,GAAG,QAAA,CAAS,OAAA,CAAQ,CAAA,EAAG,IAAA,CAAK,GAAG,CAAC,CAAA;AAAA;AAAA;AAAA,UAGhC,OAAO,QAAA,CAAS,OAAA,CAAQ,KAAA,EAAO,IAAA,CAAK,OAAO,CAAC,CAAA;AAAA,UAC5C,QAAQ,QAAA,CAAS,OAAA,CAAQ,MAAA,EAAQ,IAAA,CAAK,QAAQ,CAAC;AAAA,SAChD,CAAA;AACD,QAAA,eAAA,GAAkB,IAAA;AAClB,QAAA,MAAA,GAAS,IAAA;AAAA,MACX;AAAA,IACF;AAEA,IAAA,IAAI,eAAA,OAAsB,oBAAA,EAAqB;AAC/C,IAAA,IAAI,MAAA,OAAa,KAAA,GAAQ,IAAA;AACzB,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAAA,EAEA,WAAW,MAA6B;AACtC,IAAA,IAAI,KAAK,KAAA,EAAO;AACd,MAAA,IAAA,CAAK,KAAA,GAAQ,KAAA;AACb,MAAA,IAAA,CAAK,QAAA,GAAW,CAAC,GAAG,IAAA,CAAK,KAAA,CAAM,QAAQ,CAAA,CAAE,GAAA,CAAI,CAAC,KAAA,KAAU;AACtD,QAAA,MAAM,WAAW,KAAA,CAAM,QAAA;AAEvB,QAAA,MAAM,UAAU,KAAA,CAAM,IAAA,KAAS,SAAY,KAAA,CAAM,IAAA,GAAO,UAAU,MAAA,KAAW,IAAA;AAC7E,QAAA,OAAO;AAAA,UACL,IAAI,KAAA,CAAM,EAAA;AAAA,UACV,MAAM,QAAA,EAAU,IAAA;AAAA,UAChB,KAAA,EAAO,QAAA,EAAU,KAAA,IAAS,SAAA,CAAU,MAAM,EAAE,CAAA;AAAA;AAAA;AAAA,UAG5C,MAAA,EAAQ,MAAA,KAAW,IAAA,GAAO,IAAA,GAAQ,MAAM,YAAA,IAAgB,MAAA;AAAA,UACxD,SAAA,EAAW,UAAU,SAAA,IAAa,SAAA;AAAA,UAClC,OAAA,EAAS,UAAU,OAAA,IAAW,SAAA;AAAA,UAC9B,YAAY,KAAA,CAAM;AAAA,SACpB;AAAA,MACF,CAAC,CAAA;AAAA,IACH;AACA,IAAA,OAAO,IAAA,CAAK,QAAA;AAAA,EACd,CAAA;AAAA,EAEA,OAAA,GAAU,MAAe,IAAA,CAAK,KAAA,CAAM,IAAA,KAAS,CAAA;AAAA,EAE7C,SAAA,GAAY,CAAC,QAAA,KAAuC;AAClD,IAAA,IAAA,CAAK,SAAA,CAAU,IAAI,QAAQ,CAAA;AAC3B,IAAA,OAAO,MAAM;AACX,MAAA,IAAA,CAAK,SAAA,CAAU,OAAO,QAAQ,CAAA;AAAA,IAChC,CAAA;AAAA,EACF,CAAA;AACF,CAAA;AAcO,SAAS,uBAAuB,QAAA,EAAoD;AACzF,EAAA,OAAO,IAAIA,UAAS,QAAQ,CAAA;AAC9B;ACreA,IAAM,QAAA,GAAqB,EAAE,MAAA,EAAQ,KAAA,EAAM;AAkBpC,SAAS,YAAY,EAAA,EAAsB;AAChD,EAAA,MAAM,EAAE,KAAA,EAAM,GAAI,eAAA,EAAgB;AAClC,EAAA,MAAM,SAAA,GAAY,WAAA,CAAY,MAAM,KAAA,CAAM,KAAA,CAAM,SAAA,CAAU,EAAE,CAAA,EAAG,CAAC,KAAA,EAAO,EAAE,CAAC,CAAA;AAI1E,EAAA,MAAM,WAAW,oBAAA,CAAqB,KAAA,CAAM,KAAA,CAAM,SAAA,EAAW,WAAW,SAAS,CAAA;AACjF,EAAA,OAAO,aAAa,IAAA,GAAO,QAAA,GAAW,EAAE,MAAA,EAAQ,MAAM,QAAA,EAAS;AACjE;AAUO,SAAS,iBAAA,CAAkB,IAAY,MAAA,EAA6B;AACzE,EAAA,MAAM,EAAE,KAAA,EAAM,GAAI,eAAA,EAAgB;AAClC,EAAA,MAAM,MAAA,GAAS,WAAA,CAAY,MAAM,KAAA,CAAM,KAAA,CAAM,MAAA,CAAO,EAAA,EAAI,MAAM,CAAA,EAAG,CAAC,KAAA,EAAO,EAAA,EAAI,MAAM,CAAC,CAAA;AACpF,EAAA,OAAO,oBAAA,CAAqB,KAAA,CAAM,KAAA,CAAM,SAAA,EAAW,QAAQ,MAAM,CAAA;AACnE","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"]}