@kolosal-ai/rivet 0.2.0 → 0.4.0

package/dist/chunk-TT2N7KWU.js

@@ -0,0 +1,676 @@
+import { useRivetContext } from './chunk-VQYN27OK.js';
+import { useSyncExternalStore, useCallback } from 'react';
+
+// src/graph.ts
+function clampChildToParent(position, childSize, parentSize) {
+  const maxX = Math.max(0, parentSize.width - childSize.width);
+  const maxY = Math.max(0, parentSize.height - childSize.height);
+  return {
+    x: Math.min(maxX, Math.max(0, position.x)),
+    y: Math.min(maxY, Math.max(0, position.y))
+  };
+}
+function snapToGrid(position, grid) {
+  const [gx, gy] = grid;
+  return {
+    x: gx > 0 ? Math.round(position.x / gx) * gx : position.x,
+    y: gy > 0 ? Math.round(position.y / gy) * gy : position.y
+  };
+}
+function boundingRect(rects) {
+  if (rects.length === 0) return null;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const r of rects) {
+    minX = Math.min(minX, r.x);
+    minY = Math.min(minY, r.y);
+    maxX = Math.max(maxX, r.x + r.width);
+    maxY = Math.max(maxY, r.y + r.height);
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+var MAX_PARENT_DEPTH = 50;
+function worldPosition(nodes, id, maxDepth = MAX_PARENT_DEPTH) {
+  const node = nodes.get(id);
+  if (!node) return { x: 0, y: 0 };
+  let x = node.position.x;
+  let y = node.position.y;
+  let parentId = node.parentId;
+  let guard = 0;
+  while (parentId && guard++ < maxDepth) {
+    const parent = nodes.get(parentId);
+    if (!parent) break;
+    x += parent.position.x;
+    y += parent.position.y;
+    parentId = parent.parentId;
+  }
+  return { x, y };
+}
+function nodeDepth(nodes, id, maxDepth = MAX_PARENT_DEPTH) {
+  let depth = 0;
+  let parentId = nodes.get(id)?.parentId;
+  while (parentId && depth < maxDepth) {
+    depth++;
+    parentId = nodes.get(parentId)?.parentId;
+  }
+  return depth;
+}
+function hasAncestorIn(nodes, id, set, maxDepth = MAX_PARENT_DEPTH) {
+  let parentId = nodes.get(id)?.parentId;
+  let guard = 0;
+  while (parentId && guard++ < maxDepth) {
+    if (set.has(parentId)) return true;
+    parentId = nodes.get(parentId)?.parentId;
+  }
+  return false;
+}
+function buildChildIndex(nodes) {
+  const childrenOf = /* @__PURE__ */ new Map();
+  for (const node of nodes.values()) {
+    if (!node.parentId) continue;
+    const list = childrenOf.get(node.parentId);
+    if (list) list.push(node.id);
+    else childrenOf.set(node.parentId, [node.id]);
+  }
+  return childrenOf;
+}
+function collectDescendants(id, childIndex, out) {
+  for (const child of childIndex.get(id) ?? []) {
+    out.push(child);
+    collectDescendants(child, childIndex, out);
+  }
+}
+function descendantIds(nodes, id) {
+  const out = [];
+  collectDescendants(id, buildChildIndex(nodes), out);
+  return out;
+}
+function serializeGraph(nodes, edges, viewport) {
+  const cleanNodes = [];
+  for (const node of nodes) {
+    const copy = { ...node, position: { ...node.position } };
+    if (node.size) copy.size = { ...node.size };
+    copy.hovered = void 0;
+    copy.dragging = void 0;
+    cleanNodes.push(copy);
+  }
+  return {
+    nodes: cleanNodes,
+    edges: [...edges].map((edge) => ({ ...edge })),
+    viewport: { ...viewport }
+  };
+}
+function nodeControlledEqual(a, b) {
+  return a.position.x === b.position.x && a.position.y === b.position.y && Boolean(a.selected) === Boolean(b.selected) && a.data === b.data && a.type === b.type && a.laneId === b.laneId && a.ariaLabel === b.ariaLabel && a.parentId === b.parentId && a.extent === b.extent && a.width === b.width && a.height === b.height && Boolean(a.dragging) === Boolean(b.dragging) && a.size?.width === b.size?.width && a.size?.height === b.size?.height;
+}
+
+// src/presence/targets.ts
+var EDGE_PREFIX = "edge:";
+var ANCHOR_PREFIX = "anchor:";
+function presenceTargetKey(target) {
+  if (typeof target === "string") return target;
+  if (target.kind === "edge") return `${EDGE_PREFIX}${target.id}`;
+  if (target.kind === "anchor") return `${ANCHOR_PREFIX}${target.nodeId}:${target.anchorId}`;
+  return target.id;
+}
+function edgeTargetKey(id) {
+  return `${EDGE_PREFIX}${id}`;
+}
+function anchorTargetKey(nodeId, anchorId) {
+  return `${ANCHOR_PREFIX}${nodeId}:${anchorId}`;
+}
+function anchorSplit(rest) {
+  const split = rest.indexOf(":");
+  return split > 0 && split < rest.length - 1 ? split : -1;
+}
+function isNodeTarget(key) {
+  if (key.startsWith(EDGE_PREFIX)) return false;
+  if (key.startsWith(ANCHOR_PREFIX)) return anchorSplit(key.slice(ANCHOR_PREFIX.length)) < 0;
+  return true;
+}
+function parsePresenceTarget(key) {
+  if (key.startsWith(EDGE_PREFIX)) return { kind: "edge", id: key.slice(EDGE_PREFIX.length) };
+  if (key.startsWith(ANCHOR_PREFIX)) {
+    const rest = key.slice(ANCHOR_PREFIX.length);
+    const split = anchorSplit(rest);
+    if (split >= 0) {
+      return { kind: "anchor", nodeId: rest.slice(0, split), anchorId: rest.slice(split + 1) };
+    }
+  }
+  return { kind: "node", id: key };
+}
+function presenceTargetNodeId(target) {
+  const resolved = typeof target === "string" ? parsePresenceTarget(target) : target;
+  if (resolved.kind === "node") return resolved.id;
+  if (resolved.kind === "anchor") return resolved.nodeId;
+  return null;
+}
+function presenceTargetEdgeId(target) {
+  if (typeof target === "string") {
+    return target.startsWith(EDGE_PREFIX) ? target.slice(EDGE_PREFIX.length) : null;
+  }
+  return target.kind === "edge" ? target.id : null;
+}
+
+// src/locks/registry.ts
+var LOCK_DEFAULT_REFUSED = /* @__PURE__ */ new Set([
+  "select",
+  "drag",
+  "resize",
+  "delete",
+  "reconnect"
+]);
+function locksEqual(current, next) {
+  const keys = Object.keys(next);
+  if (keys.length !== current.size) return false;
+  return keys.every((key) => current.get(key) === next[key]);
+}
+var NO_EDGE_LOCKS = /* @__PURE__ */ new Map();
+function indexEdgeLocks(locks) {
+  let edges = null;
+  for (const [key, holderId] of locks) {
+    const edgeId = presenceTargetEdgeId(key);
+    if (edgeId === null) continue;
+    edges ??= /* @__PURE__ */ new Map();
+    edges.set(edgeId, holderId);
+  }
+  return edges ?? NO_EDGE_LOCKS;
+}
+var Registry = class {
+  /**
+   * `requestRender` marks the canvas dirty — a lock is paint as well as policy.
+   * `getParentId` is how the cascade walks upward; a registry built without one
+   * (no graph to ask) governs each node by its own entry alone.
+   */
+  constructor(requestRender, getParentId = () => void 0) {
+    this.requestRender = requestRender;
+    this.getParentId = getParentId;
+  }
+  requestRender;
+  getParentId;
+  locks = /* @__PURE__ */ new Map();
+  /** `edge:` entries of {@link locks}, re-indexed on every table change. */
+  edgeLocks = NO_EDGE_LOCKS;
+  policy = null;
+  version = 0;
+  listeners = /* @__PURE__ */ new Set();
+  setLocks = (locks) => {
+    const next = locks ?? {};
+    if (locksEqual(this.locks, next)) return [];
+    const opened = [];
+    for (const [key, holderId] of Object.entries(next)) {
+      if (this.locks.get(key) !== holderId) opened.push(key);
+    }
+    this.locks = new Map(Object.entries(next));
+    this.edgeLocks = indexEdgeLocks(this.locks);
+    this.version += 1;
+    this.requestRender();
+    for (const listener of this.listeners) listener();
+    return opened;
+  };
+  setPolicy = (policy) => {
+    this.policy = policy;
+  };
+  isLocked = (target) => this.getLockSource(target) !== null;
+  getHolder = (target) => {
+    const source = this.getLockSource(target);
+    return source === null ? null : this.locks.get(source) ?? null;
+  };
+  getLockSource = (target) => {
+    if (this.locks.size === 0) return null;
+    const key = typeof target === "string" ? target : presenceTargetKey(target);
+    if (this.locks.has(key)) return key;
+    if (isNodeTarget(key)) return this.ancestorLock(key);
+    const owner = presenceTargetNodeId(key);
+    if (owner === null) return null;
+    return this.locks.has(owner) ? owner : this.ancestorLock(owner);
+  };
+  /**
+   * The nearest locked ancestor of a node, ignoring the node itself. Locking a
+   * container claims what's inside it: a lock that stopped at the container
+   * would leave its contents draggable out of it, deletable, and rewireable —
+   * the box protected and everything it holds is not.
+   */
+  ancestorLock(nodeId) {
+    let parentId = this.getParentId(nodeId);
+    let guard = 0;
+    while (parentId && guard++ < MAX_PARENT_DEPTH) {
+      if (this.locks.has(parentId)) return parentId;
+      parentId = this.getParentId(parentId);
+    }
+    return null;
+  }
+  getLocks = () => this.locks;
+  getLockedEdges = () => this.edgeLocks;
+  size = () => this.locks.size;
+  allows = (target, intent) => {
+    if (this.locks.size === 0) return true;
+    const lockedKey = this.getLockSource(target);
+    if (lockedKey === null) return true;
+    const holderId = this.locks.get(lockedKey);
+    if (holderId === void 0) return true;
+    if (this.policy) {
+      const key = typeof target === "string" ? target : presenceTargetKey(target);
+      const resolved = typeof target === "string" ? parsePresenceTarget(key) : target;
+      const lockedTarget = parsePresenceTarget(lockedKey);
+      return this.policy({
+        target: resolved,
+        lockedTarget,
+        nodeId: presenceTargetNodeId(resolved),
+        lockedNodeId: presenceTargetNodeId(lockedTarget),
+        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, getParentId) {
+  return new Registry(requestRender, getParentId);
+}
+
+// src/presence/registry.ts
+var DEFAULT_PRESENCE_OPTIONS = {
+  throttleMs: 50,
+  renderCursors: true,
+  renderOutlines: 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 = [];
+function normalizeTargets(targets) {
+  if (!targets || targets.length === 0) return EMPTY_IDS;
+  return targets.map(presenceTargetKey);
+}
+var samePoint = (a, b) => a === b || a != null && b != null && a.x === b.x && a.y === b.y;
+var sameConnection = (a, b) => {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.source === b.source && a.sourceHandle === b.sourceHandle && a.sourceType === b.sourceType && a.toPosition === b.toPosition && samePoint(a.from, b.from) && samePoint(a.to, b.to);
+};
+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 identityEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return a.name === b.name && a.color === b.color && a.data === b.data && samePoint(a.cursor, b.cursor) && sameConnection(a.pending, b.pending);
+}
+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();
+  identityListeners = /* @__PURE__ */ new Set();
+  claimsListeners = /* @__PURE__ */ new Set();
+  snapshot = [];
+  stale = false;
+  identitySnapshot = [];
+  identityStale = 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 — routed to the
+   * half (or halves) it belongs to. The union channel fires once either way: a
+   * peer who joins with a selection is one roster change, not two.
+   */
+  touchRoster(identity, claims) {
+    if (!identity && !claims) return;
+    this.touch();
+    if (identity) {
+      this.identityStale = true;
+      for (const listener of this.identityListeners) listener();
+    }
+    if (claims) for (const listener of this.claimsListeners) listener();
+    for (const listener of this.listeners) listener();
+  }
+  peer(id) {
+    let state = this.peers.get(id);
+    if (!state) {
+      state = {
+        id,
+        declared: null,
+        selection: EMPTY_IDS,
+        holding: EMPTY_IDS,
+        live: void 0,
+        renderCursor: null,
+        transforms: /* @__PURE__ */ new Map(),
+        renderTransforms: /* @__PURE__ */ new Map(),
+        livePending: void 0,
+        renderPending: null
+      };
+      this.peers.set(id, state);
+      this.identityStale = true;
+    }
+    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 || state.livePending) return;
+    this.peers.delete(state.id);
+    this.identityStale = true;
+    this.invalidateTransforms();
+  }
+  invalidateTransforms() {
+    this.transformsStale = true;
+    this.version += 1;
+  }
+  setPeers = (peers) => {
+    let identityChanged = false;
+    let claimsChanged = false;
+    const incoming = /* @__PURE__ */ new Set();
+    for (const peer of peers) {
+      incoming.add(peer.id);
+      const known = this.peers.has(peer.id);
+      const state = this.peer(peer.id);
+      if (!known || !identityEqual(state.declared, peer)) identityChanged = true;
+      const selection = normalizeTargets(peer.selection);
+      const holding = normalizeTargets(peer.holding);
+      if (!sameIds(state.selection, selection) || !sameIds(state.holding, holding)) {
+        state.selection = selection;
+        state.holding = holding;
+        claimsChanged = true;
+      }
+      state.declared = peer;
+    }
+    for (const state of [...this.peers.values()]) {
+      if (incoming.has(state.id)) continue;
+      if (!state.declared) continue;
+      this.peers.delete(state.id);
+      identityChanged = true;
+      if (state.selection.length > 0 || state.holding.length > 0) claimsChanged = true;
+    }
+    this.touchRoster(identityChanged, claimsChanged);
+  };
+  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();
+  };
+  setPeerConnection = (peerId, connection) => {
+    const state = this.peer(peerId);
+    if (state.livePending !== void 0 && sameConnection(state.livePending, connection)) return;
+    state.livePending = connection;
+    if (connection === null) this.prune(state);
+    this.touch();
+  };
+  removePeer = (peerId) => {
+    const state = this.peers.get(peerId);
+    if (!state) return;
+    this.peers.delete(peerId);
+    this.invalidateTransforms();
+    this.touchRoster(true, state.selection.length > 0 || state.holding.length > 0);
+  };
+  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;
+      }
+      const wire = state.livePending !== void 0 ? state.livePending : state.declared?.pending ?? null;
+      if (!wire) {
+        state.renderPending = null;
+      } else if (!state.renderPending || // A different wire, not the same one moved: placed outright, or the
+      // loose end would sweep across the canvas between two drags.
+      state.renderPending.source !== wire.source || state.renderPending.sourceHandle !== wire.sourceHandle) {
+        state.renderPending = wire;
+      } else if (!samePoint(state.renderPending.to, wire.to)) {
+        state.renderPending = {
+          ...wire,
+          to: {
+            x: approach(state.renderPending.to.x, wire.to.x, t),
+            y: approach(state.renderPending.to.y, wire.to.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),
+          data: declared?.data,
+          // 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: state.selection,
+          holding: state.holding,
+          transforms: state.renderTransforms,
+          // Same fallback as the cursor: a registry nobody steps still reports
+          // the wire that arrived rather than nothing.
+          pending: state.renderPending ?? (state.livePending !== void 0 ? state.livePending : declared?.pending ?? null)
+        };
+      });
+    }
+    return this.snapshot;
+  };
+  getPeerIdentities = () => {
+    if (this.identityStale) {
+      this.identityStale = false;
+      this.identitySnapshot = [...this.peers.values()].map((state) => ({
+        id: state.id,
+        name: state.declared?.name,
+        color: state.declared?.color ?? peerColor(state.id),
+        data: state.declared?.data
+      }));
+    }
+    return this.identitySnapshot;
+  };
+  isEmpty = () => this.peers.size === 0;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  subscribeIdentity = (listener) => {
+    this.identityListeners.add(listener);
+    return () => {
+      this.identityListeners.delete(listener);
+    };
+  };
+  subscribeClaims = (listener) => {
+    this.claimsListeners.add(listener);
+    return () => {
+      this.claimsListeners.delete(listener);
+    };
+  };
+};
+function createPresenceRegistry(requests) {
+  return new Registry2(requests);
+}
+function usePeerIdentities() {
+  const { store } = useRivetContext();
+  return useSyncExternalStore(
+    store.presence.subscribeIdentity,
+    store.presence.getPeerIdentities,
+    store.presence.getPeerIdentities
+  );
+}
+
+// src/presence/outlines.ts
+var EMPTY_ENTRIES = [];
+function collectPeerOutlines(peers, identities, locks) {
+  if (peers.length === 0 && locks.size === 0) return EMPTY_ENTRIES;
+  const byId = new Map(identities.map((identity) => [identity.id, identity]));
+  const entries = /* @__PURE__ */ new Map();
+  const entry = (key) => {
+    let found = entries.get(key);
+    if (!found) {
+      found = { key, target: parsePresenceTarget(key), claims: [], lock: null };
+      entries.set(key, found);
+    }
+    return found;
+  };
+  const claim = (key, peer, kind) => {
+    const target = entry(key);
+    if (target.claims.some((existing) => existing.peer.id === peer.id)) return;
+    target.claims.push({ peer, kind });
+  };
+  for (const peer of peers) {
+    const identity = byId.get(peer.id) ?? peer;
+    for (const key of peer.holding) claim(key, identity, "held");
+    for (const nodeId of peer.transforms.keys()) claim(nodeId, identity, "held");
+    for (const key of peer.selection) claim(key, identity, "selected");
+  }
+  for (const [key, holderId] of locks) {
+    entry(key).lock = { holderId, peer: byId.get(holderId) };
+  }
+  return [...entries.values()];
+}
+function peerOutlinesEqual(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  return a.every((left, index) => {
+    const right = b[index];
+    if (!right || left.key !== right.key) return false;
+    if (left.lock?.holderId !== right.lock?.holderId) return false;
+    if (left.claims.length !== right.claims.length) return false;
+    return left.claims.every((claim, i) => {
+      const other = right.claims[i];
+      return other?.peer === claim.peer && other?.kind === claim.kind;
+    });
+  });
+}
+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, anchorTargetKey, boundingRect, buildChildIndex, clampChildToParent, collectDescendants, collectPeerOutlines, createLockRegistry, createPresenceRegistry, descendantIds, edgeTargetKey, hasAncestorIn, isNodeTarget, nodeControlledEqual, nodeDepth, parsePresenceTarget, peerColor, peerOutlinesEqual, presenceTargetEdgeId, presenceTargetKey, presenceTargetNodeId, serializeGraph, snapToGrid, useNodeLock, useNodeLockAllows, usePeerIdentities, worldPosition };
+//# sourceMappingURL=chunk-TT2N7KWU.js.map
+//# sourceMappingURL=chunk-TT2N7KWU.js.map