@1agh/maude 0.28.1 → 0.30.0

package/apps/studio/dist/comment-mount.js

@@ -0,0 +1,2046 @@
+// canvas-comment-mount.tsx
+import {
+  Component,
+  createElement,
+  Fragment as Fragment3,
+  useCallback as useCallback5,
+  useEffect as useEffect6,
+  useMemo as useMemo5,
+  useRef as useRef4,
+  useState as useState5
+} from "react";
+import { createRoot } from "react-dom/client";
+
+// comments-overlay.tsx
+import { useCallback as useCallback3, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef3, useState as useState3 } from "react";
+
+// use-collab.tsx
+import * as decoding from "lib0/decoding";
+import * as encoding from "lib0/encoding";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { Awareness, applyAwarenessUpdate, encodeAwarenessUpdate } from "y-protocols/awareness";
+import { readSyncMessage, writeSyncStep1, writeUpdate } from "y-protocols/sync";
+import * as Y from "yjs";
+import { jsx } from "react/jsx-runtime";
+var CollabContext = createContext(null);
+function useCollab() {
+  return useContext(CollabContext);
+}
+
+// use-selection-set.tsx
+import {
+  createContext as createContext2,
+  useCallback as useCallback2,
+  useContext as useContext2,
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { jsx as jsx2, Fragment } from "react/jsx-runtime";
+var SelectionSetContext = createContext2(null);
+function selectionKey(s) {
+  return s.id ? `id:${s.id}` : `sel:${s.selector}`;
+}
+function dedupe(list) {
+  const out = [];
+  const seen = new Set;
+  for (const s of list) {
+    const k = selectionKey(s);
+    if (seen.has(k))
+      continue;
+    seen.add(k);
+    out.push(s);
+  }
+  return out;
+}
+var POST_DEBOUNCE_MS = 50;
+function SelectionSetProvider({
+  children,
+  postTarget
+}) {
+  const [selected, setSelected] = useState2([]);
+  const timerRef = useRef2(null);
+  const post = useCallback2((next) => {
+    if (timerRef.current)
+      clearTimeout(timerRef.current);
+    timerRef.current = setTimeout(() => {
+      timerRef.current = null;
+      const target = postTarget ?? (typeof window !== "undefined" ? window.parent : null);
+      if (!target)
+        return;
+      const payload = next.length === 0 ? null : next.length === 1 ? next[0] ?? null : next;
+      try {
+        target.postMessage({ dgn: "select-set", selection: payload }, "*");
+      } catch {}
+    }, POST_DEBOUNCE_MS);
+  }, [postTarget]);
+  useEffect2(() => () => {
+    if (timerRef.current)
+      clearTimeout(timerRef.current);
+  }, []);
+  const replace = useCallback2((s) => {
+    const next = dedupe(Array.isArray(s) ? s : [s]);
+    setSelected(next);
+    post(next);
+  }, [post]);
+  const add = useCallback2((s) => {
+    const incoming = Array.isArray(s) ? s : [s];
+    setSelected((prev) => {
+      const next = dedupe([...prev, ...incoming]);
+      post(next);
+      return next;
+    });
+  }, [post]);
+  const remove = useCallback2((s) => {
+    const k = selectionKey(s);
+    setSelected((prev) => {
+      const next = prev.filter((x) => selectionKey(x) !== k);
+      post(next);
+      return next;
+    });
+  }, [post]);
+  const toggle = useCallback2((s) => {
+    const k = selectionKey(s);
+    setSelected((prev) => {
+      const next = prev.some((x) => selectionKey(x) === k) ? prev.filter((x) => selectionKey(x) !== k) : [...prev, s];
+      post(next);
+      return next;
+    });
+  }, [post]);
+  const clear = useCallback2(() => {
+    setSelected([]);
+    post([]);
+  }, [post]);
+  const value = useMemo2(() => ({ selected, replace, add, remove, toggle, clear }), [selected, replace, add, remove, toggle, clear]);
+  return /* @__PURE__ */ jsx2(SelectionSetContext.Provider, {
+    value,
+    children
+  });
+}
+function MaybeSelectionSetProvider({ children }) {
+  const outer = useContext2(SelectionSetContext);
+  if (outer)
+    return /* @__PURE__ */ jsx2(Fragment, {
+      children
+    });
+  return /* @__PURE__ */ jsx2(SelectionSetProvider, {
+    children
+  });
+}
+function useSelectionSet() {
+  const ctx = useContext2(SelectionSetContext);
+  if (!ctx) {
+    throw new Error("useSelectionSet must be used inside <SelectionSetProvider>");
+  }
+  return ctx;
+}
+function useSelectionSetOptional() {
+  return useContext2(SelectionSetContext);
+}
+
+// comments-overlay.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var CSS_HREF = "/_client/comments-overlay.css";
+function ensureOverlayStyles() {
+  if (typeof document === "undefined")
+    return;
+  if (document.getElementById("cm-overlay-css"))
+    return;
+  const link = document.createElement("link");
+  link.id = "cm-overlay-css";
+  link.rel = "stylesheet";
+  link.href = CSS_HREF;
+  document.head.appendChild(link);
+}
+function deriveFile() {
+  if (typeof window === "undefined")
+    return null;
+  try {
+    const p = window.location.pathname;
+    if (p === "/_canvas-shell.html" || p === "/_canvas-shell") {
+      const qs = new URLSearchParams(window.location.search);
+      const canvas = qs.get("canvas") ?? "";
+      const designRel = (qs.get("designRel") ?? ".design").replace(/^\/+|\/+$/g, "");
+      return canvas ? `${designRel}/${canvas}` : null;
+    }
+    return decodeURIComponent(p).replace(/^\//, "");
+  } catch {
+    return null;
+  }
+}
+function screenRectFor(selector, index) {
+  if (!selector)
+    return null;
+  let el = null;
+  try {
+    const all = document.querySelectorAll(selector);
+    const i = index && index > 0 && index < all.length ? index : 0;
+    el = all[i] ?? all[0] ?? null;
+  } catch {
+    return null;
+  }
+  if (!el?.isConnected)
+    return null;
+  const r = el.getBoundingClientRect();
+  if (r.width === 0 && r.height === 0)
+    return null;
+  return { x: r.left, y: r.top, w: r.width, h: r.height };
+}
+function CommentsOverlay() {
+  ensureOverlayStyles();
+  const selSet = useSelectionSetOptional();
+  const [comments, setComments] = useState3([]);
+  const [focusedId, setFocusedId] = useState3(null);
+  const [composer, setComposer] = useState3(null);
+  const file = useMemo3(() => deriveFile(), []);
+  useEffect3(() => {
+    if (typeof document === "undefined")
+      return;
+    const legacy = document.getElementById("dgn-pin-layer");
+    if (!legacy)
+      return;
+    const prev = legacy.style.display;
+    legacy.style.display = "none";
+    return () => {
+      legacy.style.display = prev;
+    };
+  }, []);
+  const mirrorSelection = useCallback3((comment) => {
+    if (!selSet)
+      return;
+    if (!comment?.selector) {
+      selSet.clear();
+      return;
+    }
+    const cdMatch = comment.selector.match(/data-cd-id="([^"]+)"/);
+    const cdId = cdMatch ? cdMatch[1] : undefined;
+    let tag;
+    let classes;
+    try {
+      const el = document.querySelector(comment.selector);
+      if (el) {
+        tag = el.tagName.toLowerCase();
+        classes = (el.getAttribute("class") ?? "").split(/\s+/).filter((cls) => cls && !cls.startsWith("dgn-") && !cls.startsWith("dc-cv-")).join(" ");
+      }
+    } catch {}
+    selSet.replace({
+      file: file ?? undefined,
+      id: cdId,
+      selector: comment.selector,
+      tag,
+      classes,
+      bounds: comment.bounds ?? undefined
+    });
+  }, [selSet, file]);
+  const commentsRef = useRef3(comments);
+  commentsRef.current = comments;
+  const collab = useCollab();
+  useEffect3(() => {
+    if (!collab)
+      return;
+    const arr = collab.doc.getArray("comments");
+    const sync = () => {
+      setComments(arr.toArray());
+    };
+    if (arr.length > 0)
+      sync();
+    arr.observe(sync);
+    return () => {
+      try {
+        arr.unobserve(sync);
+      } catch {}
+    };
+  }, [collab]);
+  useEffect3(() => {
+    if (typeof window === "undefined")
+      return;
+    const onMessage = (e) => {
+      const m = e.data;
+      if (!m || typeof m !== "object" || !m.dgn)
+        return;
+      if (m.dgn === "comments-set" && Array.isArray(m.comments)) {
+        setComments(m.comments);
+      } else if (m.dgn === "comment-focus") {
+        const id = typeof m.id === "string" ? m.id : null;
+        setFocusedId(id);
+        const target = id ? commentsRef.current.find((c) => c.id === id) : undefined;
+        mirrorSelection(target);
+      }
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [mirrorSelection]);
+  useEffect3(() => {
+    if (typeof document === "undefined")
+      return;
+    const onOpen = (e) => {
+      const detail = e.detail;
+      if (!detail?.selection)
+        return;
+      setComposer({
+        selection: detail.selection,
+        clientX: typeof detail.clientX === "number" ? detail.clientX : 0,
+        clientY: typeof detail.clientY === "number" ? detail.clientY : 0
+      });
+    };
+    document.addEventListener("cm:open-composer", onOpen);
+    return () => document.removeEventListener("cm:open-composer", onOpen);
+  }, []);
+  const closeComposer = useCallback3(() => {
+    setComposer(null);
+    if (typeof window === "undefined")
+      return;
+    try {
+      window.parent.postMessage({ dgn: "force-clear" }, "*");
+    } catch {}
+  }, []);
+  const submitComposer = useCallback3((text) => {
+    if (!composer)
+      return;
+    const sel = composer.selection;
+    const payload = {
+      file: sel.file,
+      selector: sel.selector,
+      index: sel.index,
+      dom_path: sel.dom_path,
+      tag: sel.tag,
+      classes: sel.classes,
+      bounds: sel.bounds,
+      html_excerpt: sel.html,
+      text
+    };
+    if (typeof window === "undefined")
+      return;
+    try {
+      window.parent.postMessage({ dgn: "comment-submit", payload }, "*");
+    } catch {}
+    closeComposer();
+  }, [composer, closeComposer]);
+  useEffect3(() => {
+    if (!file)
+      return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const r = await fetch(`/_comments?file=${encodeURIComponent(file)}`);
+        if (!r.ok)
+          return;
+        const data = await r.json();
+        if (cancelled)
+          return;
+        if (Array.isArray(data.comments)) {
+          setComments((prev) => prev.length === 0 ? data.comments ?? [] : prev);
+        }
+      } catch {}
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [file]);
+  const visible = useMemo3(() => {
+    const list = comments.slice().sort((a, b) => a.created.localeCompare(b.created));
+    return list.filter((c) => c.status !== "resolved");
+  }, [comments]);
+  const indexById = useMemo3(() => {
+    const m = new Map;
+    const all = comments.slice().sort((a, b) => a.created.localeCompare(b.created));
+    all.forEach((c, i) => {
+      m.set(c.id, i + 1);
+    });
+    return m;
+  }, [comments]);
+  const handlePinClick = useCallback3((id) => {
+    setFocusedId(id);
+    mirrorSelection(comments.find((c) => c.id === id));
+    if (typeof window === "undefined")
+      return;
+    try {
+      window.parent.postMessage({ dgn: "comment-click", id }, "*");
+    } catch {}
+  }, [comments, mirrorSelection]);
+  const handlePatch = useCallback3((id, patch) => {
+    if (typeof window === "undefined")
+      return;
+    try {
+      window.parent.postMessage({ dgn: "comment-patch", id, patch }, "*");
+    } catch {}
+  }, []);
+  const handleDelete = useCallback3((id) => {
+    if (typeof window === "undefined")
+      return;
+    try {
+      window.parent.postMessage({ dgn: "comment-delete", id }, "*");
+    } catch {}
+    setFocusedId((prev) => prev === id ? null : prev);
+  }, []);
+  const handleReply = useCallback3(async (id, body) => {
+    if (typeof fetch === "undefined")
+      return false;
+    try {
+      const r = await fetch(`/_api/comments/${encodeURIComponent(id)}/reply`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ body })
+      });
+      if (!r.ok)
+        return false;
+      const updated = await r.json();
+      setComments((prev) => prev.map((c) => c.id === updated.id ? updated : c));
+      return true;
+    } catch {
+      return false;
+    }
+  }, []);
+  return /* @__PURE__ */ jsxs("div", {
+    className: "cm-layer",
+    "aria-hidden": false,
+    children: [
+      visible.map((c) => {
+        const n = indexById.get(c.id) ?? 0;
+        return /* @__PURE__ */ jsx3(CommentPin, {
+          comment: c,
+          sequence: n,
+          focused: focusedId === c.id,
+          onClick: handlePinClick
+        }, c.id);
+      }),
+      composer ? /* @__PURE__ */ jsx3(CommentComposer, {
+        state: composer,
+        onSubmit: submitComposer,
+        onCancel: closeComposer
+      }) : null,
+      (() => {
+        if (!focusedId)
+          return null;
+        const focused = visible.find((c) => c.id === focusedId);
+        if (!focused)
+          return null;
+        return /* @__PURE__ */ jsx3(CommentThread, {
+          comment: focused,
+          sequence: indexById.get(focused.id) ?? 0,
+          onClose: () => {
+            setFocusedId(null);
+            selSet?.clear();
+          },
+          onPatch: (patch) => handlePatch(focused.id, patch),
+          onDelete: () => handleDelete(focused.id),
+          onReply: (body) => handleReply(focused.id, body)
+        });
+      })()
+    ]
+  });
+}
+var committerCache = null;
+async function loadCommitters() {
+  if (!committerCache) {
+    committerCache = (async () => {
+      try {
+        const r = await fetch("/_api/git-committers");
+        if (!r.ok)
+          return [];
+        const data = await r.json();
+        return Array.isArray(data.committers) ? data.committers : [];
+      } catch {
+        return [];
+      }
+    })();
+  }
+  return committerCache;
+}
+function firstNameSlug(name) {
+  const first = name.trim().split(/\s+/)[0] ?? "";
+  return first.replace(/[^\w.-]/g, "").toLowerCase();
+}
+function detectMentionToken(text, caret) {
+  if (caret <= 0 || caret > text.length)
+    return null;
+  let i = caret - 1;
+  while (i >= 0) {
+    const ch = text[i] ?? "";
+    if (ch === "@") {
+      const prev = i > 0 ? text[i - 1] : "";
+      if (i === 0 || /\s/.test(prev ?? "")) {
+        const query = text.slice(i + 1, caret);
+        return { start: i, end: caret, query };
+      }
+      return null;
+    }
+    if (!/[\w.-]/.test(ch))
+      return null;
+    i -= 1;
+  }
+  return null;
+}
+function MentionAwareTextarea({
+  className,
+  value,
+  onChange,
+  onKeyDown,
+  placeholder,
+  rows,
+  disabled,
+  textareaRef,
+  ariaLabel
+}) {
+  const internalRef = useRef3(null);
+  const setRef = useCallback3((el) => {
+    internalRef.current = el;
+    if (textareaRef)
+      textareaRef.current = el;
+  }, [textareaRef]);
+  const [committers, setCommitters] = useState3([]);
+  const [token, setToken] = useState3(null);
+  const [highlight, setHighlight] = useState3(0);
+  const onFocus = useCallback3(() => {
+    if (committers.length > 0)
+      return;
+    loadCommitters().then((list) => setCommitters(list));
+  }, [committers.length]);
+  const filtered = useMemo3(() => {
+    if (!token)
+      return [];
+    const q = token.query.toLowerCase();
+    const list = !q ? committers : committers.filter((c) => c.name.toLowerCase().includes(q) || c.email.toLowerCase().includes(q));
+    return list.slice(0, 8);
+  }, [token, committers]);
+  const refreshToken = useCallback3((textarea) => {
+    const caret = textarea.selectionStart ?? textarea.value.length;
+    const t = detectMentionToken(textarea.value, caret);
+    setToken(t);
+    setHighlight(0);
+  }, []);
+  const handleChange = useCallback3((e) => {
+    onChange(e.target.value);
+    refreshToken(e.target);
+  }, [onChange, refreshToken]);
+  const insertMention = useCallback3((committer) => {
+    if (!token)
+      return;
+    const ta = internalRef.current;
+    if (!ta)
+      return;
+    const tag = `@${firstNameSlug(committer.name)}`;
+    const next = `${value.slice(0, token.start)}${tag} ${value.slice(token.end)}`;
+    onChange(next);
+    setToken(null);
+    const newCaret = token.start + tag.length + 1;
+    requestAnimationFrame(() => {
+      ta.focus();
+      ta.setSelectionRange(newCaret, newCaret);
+    });
+  }, [token, value, onChange]);
+  const handleKeyDown = useCallback3((e) => {
+    if (token && filtered.length > 0) {
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setHighlight((h) => (h + 1) % filtered.length);
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setHighlight((h) => (h - 1 + filtered.length) % filtered.length);
+        return;
+      }
+      if (e.key === "Enter" || e.key === "Tab") {
+        e.preventDefault();
+        const pick = filtered[highlight] ?? filtered[0];
+        if (pick)
+          insertMention(pick);
+        return;
+      }
+      if (e.key === "Escape") {
+        e.preventDefault();
+        setToken(null);
+        return;
+      }
+    }
+    onKeyDown?.(e);
+  }, [token, filtered, highlight, insertMention, onKeyDown]);
+  const handleSelect = useCallback3((e) => {
+    refreshToken(e.currentTarget);
+  }, [refreshToken]);
+  return /* @__PURE__ */ jsxs("div", {
+    style: { position: "relative" },
+    children: [
+      /* @__PURE__ */ jsx3("textarea", {
+        ref: setRef,
+        className,
+        value,
+        placeholder,
+        rows,
+        disabled,
+        "aria-label": ariaLabel,
+        onChange: handleChange,
+        onKeyDown: handleKeyDown,
+        onFocus,
+        onSelect: handleSelect,
+        onClick: handleSelect
+      }),
+      token && filtered.length > 0 ? /* @__PURE__ */ jsx3("ul", {
+        className: "cm-mention-popup",
+        role: "listbox",
+        "aria-label": "Mention suggestions",
+        style: { left: 0, top: "100%" },
+        children: filtered.map((c, i) => {
+          const selected = i === highlight;
+          return /* @__PURE__ */ jsxs("li", {
+            role: "option",
+            "aria-selected": selected,
+            className: "cm-mention-popup__item",
+            onMouseEnter: () => setHighlight(i),
+            onMouseDown: (ev) => {
+              ev.preventDefault();
+              insertMention(c);
+            },
+            children: [
+              /* @__PURE__ */ jsxs("span", {
+                className: "cm-mention-popup__name",
+                children: [
+                  "@",
+                  firstNameSlug(c.name)
+                ]
+              }),
+              /* @__PURE__ */ jsx3("span", {
+                className: "cm-mention-popup__email",
+                children: c.email
+              })
+            ]
+          }, `${c.name}-${c.email}`);
+        })
+      }) : null
+    ]
+  });
+}
+function CommentPin({
+  comment,
+  sequence,
+  focused,
+  onClick
+}) {
+  const ref = useRef3(null);
+  const rafRef = useRef3(null);
+  useEffect3(() => {
+    const tick = () => {
+      rafRef.current = null;
+      const pin = ref.current;
+      if (!pin)
+        return;
+      let pos = screenRectFor(comment.selector, comment.index);
+      if (!pos && comment.bounds) {
+        pos = {
+          x: comment.bounds.x,
+          y: comment.bounds.y,
+          w: comment.bounds.w,
+          h: comment.bounds.h
+        };
+      }
+      if (!pos) {
+        pin.style.display = "none";
+        rafRef.current = requestAnimationFrame(tick);
+        return;
+      }
+      pin.style.display = "grid";
+      const left = Math.round(pos.x + pos.w - 12);
+      const top = Math.round(pos.y - 12);
+      pin.style.left = `${left}px`;
+      pin.style.top = `${top}px`;
+      rafRef.current = requestAnimationFrame(tick);
+    };
+    rafRef.current = requestAnimationFrame(tick);
+    return () => {
+      if (rafRef.current != null)
+        cancelAnimationFrame(rafRef.current);
+    };
+  }, [comment.selector, comment.bounds, comment.index]);
+  const author = comment.author?.trim() || "unknown";
+  const label = `Comment ${sequence} by ${author}`;
+  return /* @__PURE__ */ jsx3("button", {
+    ref,
+    type: "button",
+    className: "cm-pin",
+    "data-resolved": comment.status === "resolved" ? "true" : "false",
+    "data-focused": focused ? "true" : "false",
+    "data-comment-pin": comment.id,
+    "aria-label": label,
+    "aria-expanded": focused,
+    title: comment.text.slice(0, 200),
+    onClick: (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      onClick(comment.id);
+    },
+    children: sequence
+  });
+}
+function CommentComposer({
+  state,
+  onSubmit,
+  onCancel
+}) {
+  const [text, setText] = useState3("");
+  const textareaRef = useRef3(null);
+  const cardRef = useRef3(null);
+  const rafRef = useRef3(null);
+  useEffect3(() => {
+    const tick = () => {
+      rafRef.current = null;
+      const node = cardRef.current;
+      if (!node)
+        return;
+      const anchor = computeAnchor(state);
+      node.style.left = `${Math.round(anchor.x)}px`;
+      node.style.top = `${Math.round(anchor.y)}px`;
+      rafRef.current = requestAnimationFrame(tick);
+    };
+    rafRef.current = requestAnimationFrame(tick);
+    return () => {
+      if (rafRef.current != null)
+        cancelAnimationFrame(rafRef.current);
+    };
+  }, [state]);
+  useEffect3(() => {
+    textareaRef.current?.focus();
+  }, []);
+  const trySubmit = useCallback3(() => {
+    const v = text.trim();
+    if (!v)
+      return;
+    onSubmit(v);
+  }, [text, onSubmit]);
+  const onKeyDown = useCallback3((e) => {
+    if (e.key === "Escape") {
+      e.preventDefault();
+      onCancel();
+      return;
+    }
+    if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
+      e.preventDefault();
+      trySubmit();
+    }
+  }, [onCancel, trySubmit]);
+  const selectorChip = useMemo3(() => {
+    const s = state.selection.selector || "";
+    if (!s)
+      return state.selection.tag || "canvas";
+    const cd = s.match(/data-cd-id="([^"]+)"/);
+    if (cd)
+      return `cd:${cd[1]}`;
+    return s.length > 36 ? `${s.slice(0, 33)}…` : s;
+  }, [state.selection]);
+  return /* @__PURE__ */ jsxs("div", {
+    ref: cardRef,
+    className: "cm-composer",
+    role: "dialog",
+    "aria-label": "New comment",
+    onClick: (e) => e.stopPropagation(),
+    onPointerDown: (e) => e.stopPropagation(),
+    children: [
+      /* @__PURE__ */ jsxs("div", {
+        className: "cm-composer__head",
+        children: [
+          /* @__PURE__ */ jsx3("span", {
+            children: "New comment"
+          }),
+          /* @__PURE__ */ jsx3("span", {
+            className: "cm-composer__selector",
+            children: selectorChip
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsx3(MentionAwareTextarea, {
+        textareaRef,
+        className: "cm-composer__textarea",
+        value: text,
+        placeholder: "Type a comment. ⌘↵ to save · Esc to cancel · @name to tag",
+        onChange: setText,
+        onKeyDown,
+        rows: 3,
+        ariaLabel: "Comment body"
+      }),
+      /* @__PURE__ */ jsxs("div", {
+        className: "cm-composer__actions",
+        children: [
+          /* @__PURE__ */ jsx3("button", {
+            type: "button",
+            className: "cm-btn",
+            onClick: onCancel,
+            children: "Cancel"
+          }),
+          /* @__PURE__ */ jsx3("button", {
+            type: "button",
+            className: "cm-btn cm-btn--primary",
+            disabled: !text.trim(),
+            onClick: trySubmit,
+            children: "Save"
+          })
+        ]
+      })
+    ]
+  });
+}
+function CommentThread({
+  comment,
+  sequence,
+  onClose,
+  onPatch,
+  onDelete,
+  onReply
+}) {
+  const dialogRef = useRef3(null);
+  const replyRef = useRef3(null);
+  const rafRef = useRef3(null);
+  const [reply, setReply] = useState3("");
+  const [sending, setSending] = useState3(false);
+  useEffect3(() => {
+    const tick = () => {
+      rafRef.current = null;
+      const node = dialogRef.current;
+      if (!node)
+        return;
+      const anchor = computeThreadAnchor(comment);
+      node.style.left = `${Math.round(anchor.x)}px`;
+      node.style.top = `${Math.round(anchor.y)}px`;
+      rafRef.current = requestAnimationFrame(tick);
+    };
+    rafRef.current = requestAnimationFrame(tick);
+    return () => {
+      if (rafRef.current != null)
+        cancelAnimationFrame(rafRef.current);
+    };
+  }, [comment]);
+  useEffect3(() => {
+    dialogRef.current?.focus();
+    const pinId = comment.id;
+    return () => {
+      const pin = document.querySelector(`[data-comment-pin="${pinId}"]`);
+      pin?.focus();
+    };
+  }, [comment.id]);
+  useEffect3(() => {
+    if (typeof document === "undefined")
+      return;
+    const onKey = (e) => {
+      if (e.key !== "Escape")
+        return;
+      const root = dialogRef.current;
+      if (!root)
+        return;
+      if (root.contains(e.target) || document.activeElement === root) {
+        e.preventDefault();
+        onClose();
+      }
+    };
+    document.addEventListener("keydown", onKey);
+    return () => document.removeEventListener("keydown", onKey);
+  }, [onClose]);
+  const trySendReply = useCallback3(async () => {
+    const v = reply.trim();
+    if (!v || sending)
+      return;
+    setSending(true);
+    const ok = await onReply(v);
+    setSending(false);
+    if (ok) {
+      setReply("");
+      replyRef.current?.focus();
+    }
+  }, [reply, sending, onReply]);
+  const onReplyKeyDown = useCallback3((e) => {
+    if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
+      e.preventDefault();
+      trySendReply();
+    }
+  }, [trySendReply]);
+  const headId = `cm-thread-head-${comment.id}`;
+  const selectorChip = formatSelectorChip(comment.selector, "");
+  return /* @__PURE__ */ jsxs("div", {
+    ref: dialogRef,
+    className: "cm-thread",
+    role: "dialog",
+    "aria-labelledby": headId,
+    tabIndex: -1,
+    onClick: (e) => e.stopPropagation(),
+    onPointerDown: (e) => e.stopPropagation(),
+    children: [
+      /* @__PURE__ */ jsxs("div", {
+        className: "cm-thread__head",
+        id: headId,
+        children: [
+          /* @__PURE__ */ jsxs("div", {
+            className: "cm-thread__head-row",
+            children: [
+              /* @__PURE__ */ jsx3("span", {
+                className: "cm-thread__seq",
+                "aria-hidden": "true",
+                children: sequence
+              }),
+              /* @__PURE__ */ jsx3("span", {
+                className: "cm-thread__author",
+                children: comment.author?.trim() || "unknown"
+              }),
+              /* @__PURE__ */ jsx3("span", {
+                className: "cm-thread__time",
+                children: formatRelativeTime(comment.created)
+              }),
+              /* @__PURE__ */ jsx3("button", {
+                type: "button",
+                className: "cm-thread__close",
+                "aria-label": "Close thread",
+                title: "Close · Esc",
+                onClick: onClose,
+                children: "×"
+              })
+            ]
+          }),
+          selectorChip ? /* @__PURE__ */ jsx3("code", {
+            className: "cm-thread__selector",
+            children: selectorChip
+          }) : null
+        ]
+      }),
+      /* @__PURE__ */ jsx3("div", {
+        className: "cm-thread__body",
+        children: renderBodyWithMentions(comment.text)
+      }),
+      (comment.thread ?? []).map((r) => /* @__PURE__ */ jsxs("div", {
+        className: "cm-thread__reply",
+        children: [
+          /* @__PURE__ */ jsxs("div", {
+            className: "cm-thread__reply-head",
+            children: [
+              /* @__PURE__ */ jsx3("span", {
+                className: "cm-thread__reply-author",
+                children: r.author?.trim() || "unknown"
+              }),
+              /* @__PURE__ */ jsx3("span", {
+                className: "cm-thread__reply-time",
+                children: formatRelativeTime(r.created)
+              })
+            ]
+          }),
+          /* @__PURE__ */ jsx3("div", {
+            className: "cm-thread__reply-body",
+            children: renderBodyWithMentions(r.body)
+          })
+        ]
+      }, r.id)),
+      /* @__PURE__ */ jsxs("div", {
+        className: "cm-thread__reply-form",
+        children: [
+          /* @__PURE__ */ jsx3(MentionAwareTextarea, {
+            textareaRef: replyRef,
+            className: "cm-thread__reply-textarea",
+            value: reply,
+            placeholder: "Reply… ⌘↵ to send · @name to tag",
+            onChange: setReply,
+            onKeyDown: onReplyKeyDown,
+            rows: 2,
+            ariaLabel: "Reply",
+            disabled: sending
+          }),
+          /* @__PURE__ */ jsx3("div", {
+            className: "cm-thread__reply-actions",
+            children: /* @__PURE__ */ jsx3("button", {
+              type: "button",
+              className: "cm-btn cm-btn--primary",
+              disabled: !reply.trim() || sending,
+              onClick: () => void trySendReply(),
+              children: "Send"
+            })
+          })
+        ]
+      }),
+      /* @__PURE__ */ jsxs("div", {
+        className: "cm-thread__actions",
+        children: [
+          comment.status === "resolved" ? /* @__PURE__ */ jsx3("button", {
+            type: "button",
+            className: "cm-btn",
+            onClick: () => onPatch({ status: "open" }),
+            children: "↺ Reopen"
+          }) : /* @__PURE__ */ jsx3("button", {
+            type: "button",
+            className: "cm-btn cm-btn--primary",
+            onClick: () => {
+              onPatch({ status: "resolved" });
+              onClose();
+            },
+            children: "✓ Resolve"
+          }),
+          /* @__PURE__ */ jsx3("button", {
+            type: "button",
+            className: "cm-btn cm-btn--danger",
+            onClick: () => {
+              onDelete();
+              onClose();
+            },
+            children: "Delete"
+          })
+        ]
+      })
+    ]
+  });
+}
+function renderBodyWithMentions(text) {
+  if (!text)
+    return null;
+  const re = /(@[\w][\w.-]*)/g;
+  const parts = text.split(re);
+  return parts.map((part, i) => {
+    const key = `${i}:${part}`;
+    if (i % 2 === 1) {
+      return /* @__PURE__ */ jsx3("strong", {
+        "data-mention": "true",
+        children: part
+      }, key);
+    }
+    return /* @__PURE__ */ jsx3("span", {
+      children: part
+    }, key);
+  });
+}
+function formatRelativeTime(iso) {
+  if (!iso)
+    return "";
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t))
+    return "";
+  const diffSec = Math.round((Date.now() - t) / 1000);
+  if (diffSec < 60)
+    return `${Math.max(diffSec, 0)}s ago`;
+  if (diffSec < 3600)
+    return `${Math.round(diffSec / 60)}m ago`;
+  if (diffSec < 86400)
+    return `${Math.round(diffSec / 3600)}h ago`;
+  return `${Math.round(diffSec / 86400)}d ago`;
+}
+function formatSelectorChip(selector, fallback) {
+  if (!selector)
+    return fallback;
+  const cd = selector.match(/data-cd-id="([^"]+)"/);
+  if (cd)
+    return `cd:${cd[1]}`;
+  return selector.length > 36 ? `${selector.slice(0, 33)}…` : selector;
+}
+function computeThreadAnchor(comment) {
+  const rect = comment.selector ? screenRectFor(comment.selector, comment.index) : null;
+  if (rect) {
+    return { x: rect.x + rect.w - 12, y: rect.y + 16 };
+  }
+  if (comment.bounds) {
+    return { x: comment.bounds.x + comment.bounds.w - 12, y: comment.bounds.y + 16 };
+  }
+  return { x: 16, y: 16 };
+}
+function computeAnchor(state) {
+  if (state.clientX || state.clientY) {
+    return { x: state.clientX, y: state.clientY + 8 };
+  }
+  if (state.selection.selector) {
+    const rect = screenRectFor(state.selection.selector, state.selection.index);
+    if (rect) {
+      return { x: rect.x, y: rect.y + rect.h + 8 };
+    }
+  }
+  return { x: 16, y: 16 };
+}
+
+// dom-selection.ts
+function deriveFile2() {
+  if (typeof window === "undefined")
+    return;
+  try {
+    const p = window.location.pathname;
+    if (p === "/_canvas-shell.html" || p === "/_canvas-shell") {
+      const qs = new URLSearchParams(window.location.search);
+      const canvas = qs.get("canvas") ?? "";
+      const designRel = (qs.get("designRel") ?? ".design").replace(/^\/+|\/+$/g, "");
+      return canvas ? `${designRel}/${canvas}` : undefined;
+    }
+    return decodeURIComponent(p).replace(/^\//, "");
+  } catch {
+    return;
+  }
+}
+function realClasses(el) {
+  if (!el)
+    return "";
+  return (el.getAttribute("class") ?? "").trim().split(/\s+/).filter((c) => c && !c.startsWith("dgn-") && !c.startsWith("dc-cv-")).join(" ");
+}
+function shortText(el, max) {
+  if (!el)
+    return "";
+  const t = (el.innerText || el.textContent || "").replace(/\s+/g, " ").trim();
+  return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+function cssPath(el) {
+  if (!el)
+    return "";
+  const path = [];
+  let cur = el;
+  while (cur && cur.nodeType === 1 && path.length < 8) {
+    const dscEl = cur.getAttribute?.("data-dc-element");
+    if (dscEl) {
+      path.unshift(`[data-dc-element="${dscEl}"]`);
+      break;
+    }
+    const dscSc = cur.getAttribute?.("data-dc-screen");
+    if (dscSc) {
+      path.unshift(`[data-dc-screen="${dscSc}"]`);
+      break;
+    }
+    let sel = cur.nodeName.toLowerCase();
+    if (cur.id) {
+      sel = `#${cur.id}`;
+      path.unshift(sel);
+      break;
+    }
+    const cls = realClasses(cur).split(/\s+/).filter(Boolean).slice(0, 2);
+    if (cls.length)
+      sel += `.${cls.join(".")}`;
+    let sib = 1;
+    let n = cur.previousElementSibling;
+    while (n) {
+      sib++;
+      n = n.previousElementSibling;
+    }
+    sel += `:nth-child(${sib})`;
+    path.unshift(sel);
+    cur = cur.parentElement;
+  }
+  return path.join(" > ");
+}
+function domPath(el) {
+  const hops = [];
+  let cur = el;
+  while (cur && cur.nodeType === 1 && hops.length < 8) {
+    let label = cur.nodeName.toLowerCase();
+    const dEl = cur.getAttribute?.("data-dc-element");
+    const dSc = cur.getAttribute?.("data-dc-screen");
+    if (dEl)
+      label += `[data-dc-element="${dEl}"]`;
+    else if (dSc)
+      label += `[data-dc-screen="${dSc}"]`;
+    else if (cur.id)
+      label += `#${cur.id}`;
+    const cls = realClasses(cur).split(/\s+/).filter(Boolean).slice(0, 2);
+    if (cls.length && !dEl && !dSc)
+      label += `.${cls.join(".")}`;
+    hops.unshift(label);
+    cur = cur.parentElement;
+  }
+  return hops;
+}
+function scopedCdSelector(cdId, artboardId) {
+  return artboardId ? `[data-dc-screen="${artboardId}"] [data-cd-id="${cdId}"]` : `[data-cd-id="${cdId}"]`;
+}
+function selectorIndex(doc, selector, el) {
+  if (!el)
+    return 0;
+  try {
+    const all = doc.querySelectorAll(selector);
+    for (let i = 0;i < all.length; i++) {
+      if (all[i] === el)
+        return i;
+    }
+  } catch {}
+  return 0;
+}
+var KNOB_PROPS = [
+  "display",
+  "flex-direction",
+  "align-items",
+  "justify-content",
+  "gap",
+  "font-family",
+  "color",
+  "font-size",
+  "font-weight",
+  "line-height",
+  "letter-spacing",
+  "text-align",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "width",
+  "height",
+  "max-width",
+  "background-color",
+  "border-radius",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-bottom-left-radius",
+  "border-bottom-right-radius",
+  "border-width",
+  "border-style",
+  "border-color",
+  "box-shadow",
+  "opacity"
+];
+var ATTR_SKIP = /^(style|class|data-cd-id|data-dc-|data-dcid$)/;
+function styleMapsFor(el) {
+  if (!el || typeof window === "undefined" || !window.getComputedStyle) {
+    return { authored: {}, computed: {}, customStyles: {}, attrs: {} };
+  }
+  try {
+    const inline = el.style;
+    const cs = window.getComputedStyle(el);
+    const authored = {};
+    const computed = {};
+    const knob = new Set(KNOB_PROPS);
+    for (const p of KNOB_PROPS) {
+      const a = inline.getPropertyValue(p);
+      if (a)
+        authored[p] = a.trim();
+      const c = cs.getPropertyValue(p);
+      if (c)
+        computed[p] = c.trim();
+    }
+    const MANAGED_FAMILY = /^(margin|padding|border)(-|$)/;
+    const customStyles = {};
+    for (let i = 0;i < inline.length; i++) {
+      const p = inline.item(i);
+      if (!p || knob.has(p) || MANAGED_FAMILY.test(p))
+        continue;
+      const v = inline.getPropertyValue(p);
+      if (v)
+        customStyles[p] = v.trim();
+    }
+    const attrs = {};
+    for (const a of Array.from(el.attributes)) {
+      if (ATTR_SKIP.test(a.name))
+        continue;
+      attrs[a.name] = a.value;
+    }
+    return { authored, computed, customStyles, attrs };
+  } catch {
+    return { authored: {}, computed: {}, customStyles: {}, attrs: {} };
+  }
+}
+function hoverTargetToSelection(target, file) {
+  const el = target.el;
+  const rect = el && el.getBoundingClientRect ? el.getBoundingClientRect() : null;
+  const cdId = target.cdId;
+  const selector = cdId ? scopedCdSelector(cdId, target.artboardId) : target.artboardId ? `[data-dc-screen="${target.artboardId}"]` : cssPath(el);
+  const index = cdId && typeof document !== "undefined" ? selectorIndex(document, selector, el) : 0;
+  return {
+    file: file ?? deriveFile2(),
+    id: cdId ?? undefined,
+    selector,
+    artboardId: target.artboardId,
+    index,
+    tag: el?.tagName.toLowerCase() ?? "",
+    classes: realClasses(el),
+    text: shortText(el, 240),
+    dom_path: domPath(el),
+    bounds: rect ? {
+      x: Math.round(rect.left),
+      y: Math.round(rect.top),
+      w: Math.round(rect.width),
+      h: Math.round(rect.height)
+    } : null,
+    html: el ? (el.outerHTML ?? "").slice(0, 4000) : "",
+    ...styleMapsFor(el)
+  };
+}
+
+// input-router.tsx
+import { useEffect as useEffect4 } from "react";
+var ANNOTATION_TOOLS = new Set([
+  "pen",
+  "highlighter",
+  "shape",
+  "rect",
+  "ellipse",
+  "arrow",
+  "sticky",
+  "text",
+  "section",
+  "eraser"
+]);
+function isAnnotationTool(t) {
+  return ANNOTATION_TOOLS.has(t);
+}
+var metaOrCtrl = (i) => !!(i.metaKey || i.ctrlKey);
+function classify(input) {
+  if (input.type === "keydown") {
+    if (input.isEditable)
+      return { kind: "no-op" };
+    if (input.metaKey || input.ctrlKey || input.altKey) {
+      if (input.key === "Escape")
+        return { kind: "escape" };
+      const k2 = (input.key || "").toLowerCase();
+      if (!input.altKey && (input.metaKey || input.ctrlKey)) {
+        if (k2 === "z" && input.shiftKey)
+          return { kind: "redo" };
+        if (k2 === "z")
+          return { kind: "undo" };
+        if (k2 === "y" && !input.shiftKey)
+          return { kind: "redo" };
+      }
+      return { kind: "no-op" };
+    }
+    const k = (input.key || "").toLowerCase();
+    if (k === "v")
+      return { kind: "tool", tool: "move" };
+    if (k === "h")
+      return { kind: "tool", tool: "hand" };
+    if (k === "c")
+      return { kind: "tool", tool: "comment" };
+    if (k === "b")
+      return { kind: "tool", tool: "pen" };
+    if (k === "i")
+      return { kind: "tool", tool: "highlighter" };
+    if (k === "r" || k === "o")
+      return { kind: "tool", tool: "shape" };
+    if (k === "a")
+      return { kind: "tool", tool: "arrow" };
+    if (k === "n")
+      return { kind: "tool", tool: "sticky" };
+    if (k === "t")
+      return { kind: "tool", tool: "text" };
+    if (k === "s" && input.shiftKey)
+      return { kind: "tool", tool: "section" };
+    if (k === "e")
+      return { kind: "tool", tool: "eraser" };
+    if (input.key === "Escape")
+      return { kind: "escape" };
+    return { kind: "no-op" };
+  }
+  if (input.type === "contextmenu") {
+    return {
+      kind: "context-menu",
+      clientX: input.clientX ?? 0,
+      clientY: input.clientY ?? 0
+    };
+  }
+  if (input.type === "pointermove") {
+    if (isAnnotationTool(input.activeTool))
+      return { kind: "no-op" };
+    if (input.activeTool === "hand")
+      return { kind: "no-op" };
+    if (input.activeTool === "comment") {
+      return {
+        kind: "hover",
+        deep: true,
+        clientX: input.clientX ?? 0,
+        clientY: input.clientY ?? 0
+      };
+    }
+    if (!metaOrCtrl(input))
+      return { kind: "no-op" };
+    return {
+      kind: "hover",
+      deep: true,
+      clientX: input.clientX ?? 0,
+      clientY: input.clientY ?? 0
+    };
+  }
+  if (input.type === "pointerdown") {
+    if (input.button === 2) {
+      return {
+        kind: "context-menu",
+        clientX: input.clientX ?? 0,
+        clientY: input.clientY ?? 0
+      };
+    }
+    if (input.button === 1 || input.spaceHeld)
+      return { kind: "no-op" };
+    if (input.button !== 0)
+      return { kind: "no-op" };
+    if (isAnnotationTool(input.activeTool) && !metaOrCtrl(input)) {
+      return { kind: "no-op" };
+    }
+    if (input.activeTool === "comment") {
+      return {
+        kind: "drop-comment",
+        clientX: input.clientX ?? 0,
+        clientY: input.clientY ?? 0
+      };
+    }
+    if (input.activeTool === "hand")
+      return { kind: "no-op" };
+    const cmd = metaOrCtrl(input);
+    if (!cmd)
+      return { kind: "no-op" };
+    const shift = !!input.shiftKey;
+    return {
+      kind: "select",
+      mode: shift ? "add" : "replace",
+      deep: true,
+      clientX: input.clientX ?? 0,
+      clientY: input.clientY ?? 0
+    };
+  }
+  return { kind: "no-op" };
+}
+function isEditableTarget(t) {
+  if (!t || !t.tagName)
+    return false;
+  const el = t;
+  const tag = el.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT")
+    return true;
+  if (el.isContentEditable)
+    return true;
+  return false;
+}
+function isOverlayTarget(t) {
+  if (!t || !t.closest)
+    return false;
+  return !!t.closest(".cm-composer, .cm-thread, .cm-mention-popup, .cm-pin");
+}
+function useInputRouter(opts) {
+  const { hostRef, getActiveTool, isSpaceHeld, callbacks, enabled = true, claimableActions } = opts;
+  useEffect4(() => {
+    if (!enabled)
+      return;
+    const host = hostRef.current;
+    if (!host)
+      return;
+    const claim = (action) => claimableActions && action.kind !== "no-op" && !claimableActions.has(action.kind) ? { kind: "no-op" } : action;
+    const dispatch = (action) => {
+      switch (action.kind) {
+        case "hover":
+          callbacks.onHover?.(action);
+          break;
+        case "select":
+          callbacks.onSelect?.(action);
+          break;
+        case "drop-comment":
+          callbacks.onDropComment?.(action);
+          break;
+        case "context-menu":
+          callbacks.onContextMenu?.(action);
+          break;
+        case "tool":
+          callbacks.onTool?.(action);
+          break;
+        case "escape":
+          callbacks.onEscape?.();
+          break;
+        case "undo":
+          callbacks.onUndo?.();
+          break;
+        case "redo":
+          callbacks.onRedo?.();
+          break;
+        case "no-op":
+          break;
+      }
+    };
+    const onPointerMove = (e) => {
+      const action = claim(classify({
+        type: "pointermove",
+        button: e.button,
+        metaKey: e.metaKey,
+        ctrlKey: e.ctrlKey,
+        shiftKey: e.shiftKey,
+        altKey: e.altKey,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        spaceHeld: isSpaceHeld?.() ?? false,
+        activeTool: getActiveTool()
+      }));
+      dispatch(action);
+    };
+    const onPointerDown = (e) => {
+      if (isOverlayTarget(e.target))
+        return;
+      const action = claim(classify({
+        type: "pointerdown",
+        button: e.button,
+        metaKey: e.metaKey,
+        ctrlKey: e.ctrlKey,
+        shiftKey: e.shiftKey,
+        altKey: e.altKey,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        spaceHeld: isSpaceHeld?.() ?? false,
+        activeTool: getActiveTool()
+      }));
+      if (action.kind !== "no-op") {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+      }
+      dispatch(action);
+    };
+    const onMouseDown = (e) => {
+      if (isOverlayTarget(e.target))
+        return;
+      const action = claim(classify({
+        type: "pointerdown",
+        button: e.button,
+        metaKey: e.metaKey,
+        ctrlKey: e.ctrlKey,
+        shiftKey: e.shiftKey,
+        altKey: e.altKey,
+        clientX: e.clientX,
+        clientY: e.clientY,
+        spaceHeld: isSpaceHeld?.() ?? false,
+        activeTool: getActiveTool()
+      }));
+      if (action.kind !== "no-op") {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+      }
+    };
+    const onClick = (e) => {
+      if (isOverlayTarget(e.target))
+        return;
+      const tool = getActiveTool();
+      const mod = e.metaKey || e.ctrlKey;
+      const wouldRouteKind = tool === "comment" ? "drop-comment" : tool === "move" && mod && e.button === 0 ? "select" : e.button === 2 ? "context-menu" : null;
+      if (wouldRouteKind && (!claimableActions || claimableActions.has(wouldRouteKind))) {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+      }
+    };
+    const onContextMenu = (e) => {
+      const action = claim(classify({
+        type: "contextmenu",
+        clientX: e.clientX,
+        clientY: e.clientY,
+        metaKey: e.metaKey,
+        ctrlKey: e.ctrlKey,
+        shiftKey: e.shiftKey,
+        altKey: e.altKey,
+        activeTool: getActiveTool()
+      }));
+      if (action.kind === "no-op")
+        return;
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      dispatch(action);
+    };
+    const onKeyDown = (e) => {
+      const action = claim(classify({
+        type: "keydown",
+        key: e.key,
+        metaKey: e.metaKey,
+        ctrlKey: e.ctrlKey,
+        shiftKey: e.shiftKey,
+        altKey: e.altKey,
+        isEditable: isEditableTarget(e.target),
+        activeTool: getActiveTool()
+      }));
+      if (action.kind === "tool" || action.kind === "escape" || action.kind === "undo" || action.kind === "redo") {
+        e.preventDefault();
+      }
+      dispatch(action);
+    };
+    host.addEventListener("pointermove", onPointerMove, { passive: true });
+    host.addEventListener("pointerdown", onPointerDown, { capture: true });
+    host.addEventListener("mousedown", onMouseDown, { capture: true });
+    host.addEventListener("click", onClick, { capture: true });
+    host.addEventListener("contextmenu", onContextMenu, { capture: true });
+    const doc = host.ownerDocument ?? document;
+    doc.addEventListener("keydown", onKeyDown, true);
+    return () => {
+      host.removeEventListener("pointermove", onPointerMove);
+      host.removeEventListener("pointerdown", onPointerDown, {
+        capture: true
+      });
+      host.removeEventListener("mousedown", onMouseDown, { capture: true });
+      host.removeEventListener("click", onClick, { capture: true });
+      host.removeEventListener("contextmenu", onContextMenu, {
+        capture: true
+      });
+      doc.removeEventListener("keydown", onKeyDown, true);
+    };
+  }, [enabled, hostRef, getActiveTool, isSpaceHeld, callbacks, claimableActions]);
+}
+function resolveHoverTarget(doc, clientX, clientY, opts) {
+  const hit = doc.elementFromPoint(clientX, clientY);
+  if (!hit)
+    return null;
+  if (hit.closest?.(".dc-mm, .dc-zoom-tb, .dc-tool-palette, .dc-context-menu, .dc-cv-group-bbox")) {
+    return null;
+  }
+  const artboardEl = hit.closest?.("[data-dc-screen]") ?? null;
+  const artboardId = artboardEl?.getAttribute("data-dc-screen") ?? null;
+  const bodyEl = hit.closest?.(".dc-artboard-body") ?? null;
+  if (!bodyEl) {
+    if (artboardEl && artboardId) {
+      return { el: artboardEl, cdId: null, artboardId };
+    }
+    return null;
+  }
+  if (hit === bodyEl) {
+    if (artboardEl && artboardId) {
+      return { el: artboardEl, cdId: null, artboardId };
+    }
+    return null;
+  }
+  if (opts.deep) {
+    const cdId2 = hit.getAttribute?.("data-cd-id") ?? null;
+    return { el: hit, cdId: cdId2, artboardId };
+  }
+  let cur = hit;
+  let topCdEl = null;
+  while (cur && cur !== bodyEl) {
+    if (cur.hasAttribute?.("data-cd-id"))
+      topCdEl = cur;
+    cur = cur.parentElement;
+  }
+  const el = topCdEl ?? hit;
+  const cdId = el.getAttribute?.("data-cd-id") ?? null;
+  return { el, cdId, artboardId };
+}
+
+// use-tool-mode.tsx
+import {
+  createContext as createContext3,
+  useCallback as useCallback4,
+  useContext as useContext3,
+  useEffect as useEffect5,
+  useMemo as useMemo4,
+  useState as useState4
+} from "react";
+
+// canvas-cursors.ts
+function svgCursor(svg, hx, hy, fallback) {
+  return `url("data:image/svg+xml,${encodeURIComponent(svg.trim())}") ${hx} ${hy}, ${fallback}`;
+}
+var W = `width='24' height='24' viewBox='0 0 32 32' xmlns='http://www.w3.org/2000/svg'`;
+var INK = "#1f1f1f";
+var HALO = "stroke='#ffffff' stroke-linejoin='round' stroke-linecap='round'";
+function kenney(b, w, transform) {
+  const open = transform ? `<g transform='${transform}'>` : "";
+  const close = transform ? "</g>" : "";
+  return `<svg ${W}>${open}<path fill='#ffffff' d='${b}'/><path fill='${INK}' d='${w}'/>${close}</svg>`;
+}
+var FLIP_V = "translate(0,32) scale(1,-1)";
+var MOVE = svgCursor(kenney("M10.25 8.25 L10.05 8.65 10 9 10 23.1 10.05 23.4 10.25 23.75 10.8 24 11.45 23.85 11.6 23.7 11.75 23.45 14.65 19.8 14.85 19.65 14.95 19.5 15.4 19.2 15.95 19.1 21.05 19.1 21.2 19.1 21.35 19.05 21.65 18.9 21.9 18.6 22 18.3 22 17.9 21.9 17.65 21.75 17.35 21.65 17.3 21.55 17.15 11.5 8.25 11.25 8.05 10.95 8 10.6 8.05 10.25 8.25 M9.15 6.6 L9.7 6.25 10 6.15 10.95 6 11.9 6.15 13 6.9 22.9 15.65 23 15.8 23.2 15.95 23.75 16.75 24 17.9 24 18.3 23.9 18.95 23.8 19.25 23.6 19.7 23.1 20.35 22.75 20.6 22.1 20.9 22.05 20.95 22 20.95 21.2 21.1 21.05 21.1 16.2 21.1 16.1 21.25 16.05 21.25 13.4 24.6 13.05 25.15 12.9 25.3 12.55 25.55 Q11.6 26.15 10.55 26 L10.5 26 Q9.65 25.85 9 25.3 L8.45 24.65 8.4 24.5 8.15 24.05 8 23.1 8 9 Q8 8.45 8.15 8.05 L8.25 7.75 8.45 7.35 9.15 6.6", "M10.25 8.25 L10.6 8.05 10.95 8 11.25 8.05 11.5 8.25 21.55 17.15 21.65 17.3 21.75 17.35 21.9 17.65 22 17.9 22 18.3 21.9 18.6 21.65 18.9 21.35 19.05 21.2 19.1 21.05 19.1 15.95 19.1 15.4 19.2 14.95 19.5 14.85 19.65 14.65 19.8 11.75 23.45 11.6 23.7 11.45 23.85 10.8 24 10.25 23.75 10.05 23.4 10 23.1 10 9 10.05 8.65 10.25 8.25"), 8, 5, "default");
+var HAND = svgCursor(kenney("M28.55 17.8 Q29.4 20.3 28.75 22.8 L28.7 23 28.15 24.55 28.05 24.75 Q26.4 28.2 22.75 29.4 L22.45 29.5 18 29.9 17.75 29.85 Q15.8 29.25 13.8 28.1 L13.45 27.95 Q12 27.05 10.35 26.8 L10.25 26.75 7.9 26.7 7.8 26.7 Q6.1 26.9 4.8 25.8 L4.75 25.8 4.65 25.7 4.6 25.65 Q3.25 24.5 3.05 22.85 L3 22.75 Q2.8 20.95 4 19.5 5.05 18.15 6.75 17.95 L8.4 17.9 7.5 15.55 7.3 15.2 7.2 15 5 10.95 Q3.9 9.15 4.3 7.75 L4.4 7.5 Q4.75 6.15 6.45 5.2 9 3.65 11 5 11.05 4.1 11.5 3.45 12.15 2.1 14.2 1.6 L14.35 1.6 Q18.05 0.6 19.6 4.4 L19.65 4.55 Q20.75 3.65 22.7 3.75 L22.75 3.75 Q26.75 4 27 8.15 L27 8.25 27 8.35 27 8.45 Q26.9 10.75 27.1 12.6 27.15 14.65 28.2 16.75 L28.55 17.8 M26.65 18.4 L26.1 16.8 26.1 16.85 Q24.8 13.7 25 8.35 L25 8.25 Q24.85 5.9 22.6 5.75 20.7 5.65 20.4 7.35 L20.1 7.95 19.5 8.2 18.85 8.05 18.45 7.5 17.75 5.15 Q16.85 2.95 14.7 3.55 L14.65 3.55 Q12.55 4.05 13.15 6.15 L13.85 8.75 13.75 9.45 13.25 9.95 12.55 9.95 12 9.55 10.9 7.7 Q9.5 5.7 7.45 6.9 6.5 7.45 6.25 8.15 6.1 8.9 6.7 9.85 9.2 13.9 10.8 18.65 L10.8 19.3 10.4 19.8 9.75 19.95 Q8.35 19.8 6.95 19.95 6.1 20.05 5.55 20.75 4.9 21.55 5 22.55 5.15 23.55 6 24.2 L6.05 24.25 Q6.75 24.85 7.65 24.7 L7.7 24.7 10.65 24.8 Q12.7 25.15 14.45 26.2 L14.5 26.2 Q16.4 27.35 18.3 27.9 L22.05 27.5 22.1 27.5 Q24.95 26.55 26.25 23.85 L26.8 22.3 Q27.3 20.35 26.65 18.4", "M26.65 18.4 Q27.3 20.35 26.8 22.3 L26.25 23.85 Q24.95 26.55 22.1 27.5 L22.05 27.5 18.3 27.9 Q16.4 27.35 14.5 26.2 L14.45 26.2 Q12.7 25.15 10.65 24.8 L7.7 24.7 7.65 24.7 Q6.75 24.85 6.05 24.25 L6 24.2 Q5.15 23.55 5 22.55 4.9 21.55 5.55 20.75 6.1 20.05 6.95 19.95 8.35 19.8 9.75 19.95 L10.4 19.8 10.8 19.3 10.8 18.65 Q9.2 13.9 6.7 9.85 6.1 8.9 6.25 8.15 6.5 7.45 7.45 6.9 9.5 5.7 10.9 7.7 L12 9.55 12.55 9.95 13.25 9.95 13.75 9.45 13.85 8.75 13.15 6.15 Q12.55 4.05 14.65 3.55 L14.7 3.55 Q16.85 2.95 17.75 5.15 L18.45 7.5 18.85 8.05 19.5 8.2 20.1 7.95 20.4 7.35 Q20.7 5.65 22.6 5.75 24.85 5.9 25 8.25 L25 8.35 Q24.8 13.7 26.1 16.85 L26.1 16.8 26.65 18.4"), 12, 12, "grab");
+var COMMENT = svgCursor(kenney("M28 14 Q28 9.85 24.45 6.9 20.95 4 16 4 11.05 4 7.5 6.9 L7.45 7 Q4 9.9 4 14 4 18.15 7.55 21.05 L7.5 21.05 Q9.2 22.45 11.2 23.2 L15.3 27.3 16 27.6 16.7 27.3 20.85 23.2 Q22.7 22.45 24.3 21.15 L24.45 21.05 Q28 18.15 28 14 M25.75 5.35 Q30.05 8.95 30 14 30.05 19.05 25.75 22.6 L25.4 22.85 Q23.8 24.1 22 24.9 L18.1 28.75 18.15 28.75 Q17.2 29.6 16 29.6 14.8 29.6 13.85 28.75 L13.9 28.75 10 24.9 6.6 22.85 6.25 22.6 Q1.95 19.05 2 14 1.95 8.95 6.25 5.35 10.3 2 16 2 21.7 2 25.75 5.35", "M28 14 Q28 18.15 24.45 21.05 L24.3 21.15 Q22.7 22.45 20.85 23.2 L16.7 27.3 16 27.6 15.3 27.3 11.2 23.2 Q9.2 22.45 7.5 21.05 L7.55 21.05 Q4 18.15 4 14 4 9.9 7.45 7 L7.5 6.9 Q11.05 4 16 4 20.95 4 24.45 6.9 28 9.85 28 14"), 12, 21, "crosshair");
+var PEN = svgCursor(kenney("M4 13.1 L4 6 Q4 5.15 4.6 4.6 5.15 4 6 4 L13.1 4 Q13.95 4 14.55 4.6 L28.65 18.75 Q29.8 19.9 29.75 21.45 L29.75 21.6 29.75 21.7 Q29.75 23.2 28.7 24.35 L24.45 28.65 24.35 28.75 Q23.15 29.85 21.65 29.8 L21.55 29.8 21.4 29.8 Q20.2 29.8 19.25 29.15 L18 29.35 Q16.6 29.4 15.25 28 L15.2 27.95 8.2 20.95 Q7.6 20.35 7.6 19.55 7.6 18.7 8.2 18.1 L4.6 14.5 Q4 13.9 4 13.1 M19.5 26.65 L20.1 27.25 Q20.7 27.85 21.5 27.8 22.35 27.85 23 27.25 L27.25 22.95 Q27.8 22.35 27.75 21.55 27.8 20.75 27.2 20.15 L13.1 6 6 6 6 13.1 12.35 19.45 9.6 19.5 16.65 26.55 Q18.05 28.05 19.5 26.65 M8.05 12.3 L8 8 12.25 8.05 13.8 9.6 9.6 13.85 8.05 12.3 M15.25 11.05 L23 18.8 18.8 23.05 11.05 15.3 15.25 11.05", "M15.25 11.05 L11.05 15.3 18.8 23.05 23 18.8 15.25 11.05 M12.35 19.45 L6 13.1 6 6 13.1 6 27.2 20.15 Q27.8 20.75 27.75 21.55 27.8 22.35 27.25 22.95 L23 27.25 Q22.35 27.85 21.5 27.8 20.7 27.85 20.1 27.25 L19.5 26.65 12.35 19.45 M8.05 12.3 L9.6 13.85 13.8 9.6 12.25 8.05 8 8 8.05 12.3", FLIP_V), 6, 18, "crosshair");
+var HIGHLIGHTER = svgCursor(kenney("M5.15 10.85 Q4 9.65 4 8.1 L4 7.95 4 7.85 Q3.95 6.2 5.1 5.15 6.25 4 7.85 4 L7.95 4 8.1 4 Q9.65 4 10.85 5.15 L11 5.3 14.3 5.25 Q15.15 5.25 15.75 5.85 L29.9 20 Q31 21.15 31 22.75 L31 22.85 31 23 Q31.05 24.5 29.9 25.7 L29.55 25.95 25.65 29.9 25.65 29.95 Q24.45 31.1 22.75 31.1 21.2 31.15 20 29.95 L5.85 15.8 Q5.25 15.2 5.25 14.35 L5.25 10.95 5.15 10.85 M19.95 24.2 L18.55 22.8 22.8 18.55 24.2 19.95 19.95 24.2 M28.45 21.4 L14.3 7.25 10.15 7.3 9.4 6.55 Q8.8 5.95 7.95 6 7.1 5.95 6.5 6.55 5.95 7.1 6 7.95 5.95 8.8 6.55 9.4 L7.25 10.1 7.25 14.35 21.4 28.5 Q22 29.1 22.75 29.1 23.6 29.1 24.2 28.5 L28.45 24.25 Q29.05 23.65 29 22.85 29.05 22 28.45 21.4 M9.25 13.5 L9.25 9.3 13.5 9.25 14.3 10.05 10.05 14.3 9.25 13.5 M17.15 21.4 L11.5 15.75 15.75 11.5 21.4 17.15 17.15 21.4", "M17.15 21.4 L21.4 17.15 15.75 11.5 11.5 15.75 17.15 21.4 M28.45 21.4 Q29.05 22 29 22.85 29.05 23.65 28.45 24.25 L24.2 28.5 Q23.6 29.1 22.75 29.1 22 29.1 21.4 28.5 L7.25 14.35 7.25 10.1 6.55 9.4 Q5.95 8.8 6 7.95 5.95 7.1 6.5 6.55 7.1 5.95 7.95 6 8.8 5.95 9.4 6.55 L10.15 7.3 14.3 7.25 28.45 21.4 M19.95 24.2 L24.2 19.95 22.8 18.55 18.55 22.8 19.95 24.2 M9.25 13.5 L10.05 14.3 14.3 10.05 13.5 9.25 9.25 9.3 9.25 13.5", FLIP_V), 6, 18, "crosshair");
+var CROSSHAIR = svgCursor(kenney("M17 2 Q18.2 2 19.15 2.9 20 3.8 20 5 L20 12 27 12 Q28.2 12 29.15 12.9 30 13.8 30 15 L30 17 Q30 18.2 29.15 19.15 28.2 20 27 20 L20 20 20 27 Q20 28.2 19.15 29.15 18.2 30 17 30 L15 30 Q13.8 30 12.9 29.15 12 28.2 12 27 L12 20 5 20 Q3.8 20 2.9 19.15 2 18.2 2 17 L2 15 Q2 13.8 2.9 12.9 3.8 12 5 12 L12 12 12 5 Q12 3.8 12.9 2.9 13.8 2 15 2 L17 2 M14 27 L14.3 27.7 Q14.6 28 15 28 L17 28 17.7 27.7 18 27 18 18.05 18.05 18 27 18 Q27.4 18 27.7 17.7 L28 17 28 15 27.7 14.3 Q27.4 14 27 14 L18 14 18 5 17.7 4.3 17 4 15 4 Q14.6 4 14.3 4.3 14 4.6 14 5 L14 14 5 14 Q4.6 14 4.3 14.3 4 14.6 4 15 L4 17 Q4 17.4 4.3 17.7 4.6 18 5 18 L14 18 14 27", "M14 27 L14 18 5 18 Q4.6 18 4.3 17.7 4 17.4 4 17 L4 15 Q4 14.6 4.3 14.3 4.6 14 5 14 L14 14 14 5 Q14 4.6 14.3 4.3 14.6 4 15 4 L17 4 17.7 4.3 18 5 18 14 27 14 Q27.4 14 27.7 14.3 L28 15 28 17 27.7 17.7 Q27.4 18 27 18 L18.05 18 18 18.05 18 27 17.7 27.7 17 28 15 28 Q14.6 28 14.3 27.7 L14 27"), 12, 12, "crosshair");
+var ERASER = svgCursor(kenney("M3.9 11.35 Q2.3 12.5 3.7 13.9 L16.4 26.65 Q17.85 28.05 19.45 26.9 L27.65 21.15 Q29.3 20 27.85 18.6 L15.15 5.85 Q13.75 4.45 12.1 5.6 L3.9 11.35 M1.05 12.4 Q1 10.95 2.75 9.75 L10.95 4 10.95 3.95 Q14 1.85 16.6 4.45 L29.3 17.2 Q30.8 18.65 30.55 20.1 30.55 21.55 28.8 22.8 L20.6 28.55 20.65 28.55 Q17.7 30.65 15 28.1 L15 28.05 2.3 15.3 2.3 15.35 Q0.8 13.85 1.05 12.4 M13.5 7 L19.85 13.35 11.65 19.15 5.3 12.75 13.5 7", "M13.5 7 L5.3 12.75 11.65 19.15 19.85 13.35 13.5 7 M3.9 11.35 L12.1 5.6 Q13.75 4.45 15.15 5.85 L27.85 18.6 Q29.3 20 27.65 21.15 L19.45 26.9 Q17.85 28.05 16.4 26.65 L3.7 13.9 Q2.3 12.5 3.9 11.35"), 6, 14, "cell");
+var TEXT = svgCursor(`<svg ${W}><path d='M16 4V28M11 4H21M11 28H21' fill='none' ${HALO} stroke-width='5'/><path d='M16 4V28M11 4H21M11 28H21' fill='none' stroke='${INK}' stroke-width='2.25' stroke-linecap='round'/></svg>`, 12, 12, "text");
+var STICKY = svgCursor(`<svg ${W}><path d='M6 5H21L26 10V27H6Z' fill='${INK}' ${HALO} stroke-width='2.5'/><path d='M21 5V11H26' fill='none' ${HALO} stroke-width='2.25'/></svg>`, 5, 5, "crosshair");
+var TOOL_CURSORS = Object.freeze({
+  move: MOVE,
+  hand: HAND,
+  comment: COMMENT,
+  pen: PEN,
+  section: CROSSHAIR,
+  highlighter: HIGHLIGHTER,
+  shape: CROSSHAIR,
+  rect: CROSSHAIR,
+  ellipse: CROSSHAIR,
+  sticky: STICKY,
+  arrow: CROSSHAIR,
+  text: TEXT,
+  eraser: ERASER
+});
+
+// use-tool-mode.tsx
+import { jsx as jsx4, Fragment as Fragment2 } from "react/jsx-runtime";
+var DEFAULT_TOOLS = Object.freeze([
+  { id: "move", label: "Move", shortcut: "V", cursor: TOOL_CURSORS.move },
+  { id: "hand", label: "Hand", shortcut: "H", cursor: TOOL_CURSORS.hand },
+  { id: "comment", label: "Comment", shortcut: "C", cursor: TOOL_CURSORS.comment },
+  { id: "pen", label: "Pen", shortcut: "B", cursor: TOOL_CURSORS.pen },
+  { id: "highlighter", label: "Highlighter", shortcut: "I", cursor: TOOL_CURSORS.highlighter },
+  { id: "shape", label: "Shape", shortcut: "R", cursor: TOOL_CURSORS.shape },
+  { id: "sticky", label: "Sticky", shortcut: "N", cursor: TOOL_CURSORS.sticky },
+  { id: "section", label: "Section", shortcut: "⇧S", cursor: TOOL_CURSORS.shape },
+  { id: "arrow", label: "Arrow", shortcut: "A", cursor: TOOL_CURSORS.arrow },
+  { id: "text", label: "Text", shortcut: "T", cursor: TOOL_CURSORS.text },
+  { id: "eraser", label: "Eraser", shortcut: "E", cursor: TOOL_CURSORS.eraser }
+]);
+var ToolContext = createContext3(null);
+function ToolProvider({
+  children,
+  tools = DEFAULT_TOOLS,
+  initial = "move"
+}) {
+  const [tool, setToolState] = useState4(initial);
+  const [sticky, setSticky] = useState4(() => ({
+    tool: null,
+    locked: false
+  }));
+  const setTool = useCallback4((t) => {
+    setToolState(t);
+    setSticky((prev) => prev.locked && prev.tool === t ? prev : { tool: null, locked: false });
+  }, []);
+  const toggleSticky = useCallback4((t) => {
+    setSticky((prev) => {
+      if (prev.locked && prev.tool === t)
+        return { tool: null, locked: false };
+      return { tool: t, locked: true };
+    });
+    setToolState(t);
+  }, []);
+  const clearSticky = useCallback4(() => {
+    setSticky({ tool: null, locked: false });
+  }, []);
+  const [shapeKind, setShapeKind] = useState4("rounded");
+  useEffect5(() => {
+    if (typeof document === "undefined")
+      return;
+    const desc = tools.find((t) => t.id === tool);
+    if (!desc)
+      return;
+    const prev = document.body.style.cursor;
+    document.body.style.cursor = desc.cursor;
+    let styleEl = document.getElementById("dc-tool-cursor");
+    if (!styleEl) {
+      styleEl = document.createElement("style");
+      styleEl.id = "dc-tool-cursor";
+      document.head.appendChild(styleEl);
+    }
+    styleEl.textContent = `* { cursor: ${desc.cursor} !important; }`;
+    if (typeof window !== "undefined" && window.parent && window.parent !== window) {
+      try {
+        window.parent.postMessage({ dgn: "tool-cursor", tool }, "*");
+      } catch {}
+    }
+    return () => {
+      document.body.style.cursor = prev;
+      const el = document.getElementById("dc-tool-cursor");
+      if (el)
+        el.textContent = "";
+    };
+  }, [tool, tools]);
+  const value = useMemo4(() => ({ tool, setTool, tools, sticky, toggleSticky, clearSticky, shapeKind, setShapeKind }), [tool, setTool, tools, sticky, toggleSticky, clearSticky, shapeKind]);
+  return /* @__PURE__ */ jsx4(ToolContext.Provider, {
+    value,
+    children
+  });
+}
+function MaybeToolProvider({ children }) {
+  const outer = useContext3(ToolContext);
+  if (outer)
+    return /* @__PURE__ */ jsx4(Fragment2, {
+      children
+    });
+  return /* @__PURE__ */ jsx4(ToolProvider, {
+    children
+  });
+}
+function useToolMode() {
+  const ctx = useContext3(ToolContext);
+  if (!ctx) {
+    throw new Error("useToolMode must be used inside <ToolProvider>");
+  }
+  return ctx;
+}
+
+// canvas-comment-mount.tsx
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+var COMMENT_CLAIMS = new Set([
+  "drop-comment",
+  "tool",
+  "escape",
+  "hover"
+]);
+function isBareSpecimen() {
+  return typeof document !== "undefined" && !document.querySelector(".dc-canvas");
+}
+function pickSpecimenEl(clientX, clientY) {
+  if (typeof document === "undefined")
+    return null;
+  const hit = document.elementFromPoint(clientX, clientY);
+  if (!hit)
+    return null;
+  if (hit.closest(".cm-composer, .cm-thread, .cm-mention-popup, .cm-pin, [data-mc-hover-halo]")) {
+    return null;
+  }
+  const tag = hit.tagName;
+  if (tag === "HTML" || tag === "BODY")
+    return null;
+  return hit;
+}
+function CommentHost({ children, file }) {
+  const { tool, setTool } = useToolMode();
+  const selSet = useSelectionSet();
+  const hostRef = useRef4(null);
+  const [hoverEl, setHoverEl] = useState5(null);
+  const toolRef = useRef4(tool);
+  toolRef.current = tool;
+  const getActiveTool = useMemo5(() => () => toolRef.current, []);
+  useEffect6(() => {
+    if (tool !== "comment")
+      setHoverEl(null);
+  }, [tool]);
+  useEffect6(() => {
+    const host = hostRef.current;
+    if (host)
+      host.setAttribute("data-active-tool", tool);
+    if (typeof document !== "undefined" && document.body) {
+      document.body.setAttribute("data-active-tool", tool);
+    }
+    return () => {
+      host?.removeAttribute("data-active-tool");
+    };
+  }, [tool]);
+  useEffect6(() => {
+    if (typeof window === "undefined")
+      return;
+    const onMessage = (e) => {
+      const m = e.data;
+      if (!m || typeof m !== "object" || m.dgn !== "tool-set")
+        return;
+      if (typeof m.tool === "string")
+        setTool(m.tool);
+    };
+    window.addEventListener("message", onMessage);
+    return () => window.removeEventListener("message", onMessage);
+  }, [setTool]);
+  useInputRouter({
+    hostRef,
+    getActiveTool,
+    claimableActions: COMMENT_CLAIMS,
+    callbacks: {
+      onHover: ({ clientX, clientY }) => {
+        if (toolRef.current !== "comment" || !isBareSpecimen()) {
+          setHoverEl(null);
+          return;
+        }
+        const el = pickSpecimenEl(clientX, clientY);
+        setHoverEl((prev) => prev === el ? prev : el);
+      },
+      onTool: ({ tool: t }) => setTool(t),
+      onEscape: () => {
+        if (toolRef.current !== "move")
+          setTool("move");
+        setHoverEl(null);
+        selSet.clear();
+        if (typeof window !== "undefined") {
+          try {
+            window.parent.postMessage({ dgn: "force-clear" }, "*");
+          } catch {}
+        }
+      },
+      onDropComment: ({ clientX, clientY }) => dropComment(clientX, clientY, selSet, file)
+    }
+  });
+  return /* @__PURE__ */ jsxs2("div", {
+    "data-mc-host": true,
+    ref: hostRef,
+    style: { display: "contents" },
+    children: [
+      children,
+      hoverEl ? /* @__PURE__ */ jsx5(MountHoverHalo, {
+        el: hoverEl
+      }) : null,
+      /* @__PURE__ */ jsx5(CommentsOverlay, {})
+    ]
+  });
+}
+function MountHoverHalo({ el }) {
+  const ref = useRef4(null);
+  const targetRef = useRef4(el);
+  targetRef.current = el;
+  const rafRef = useRef4(null);
+  useEffect6(() => {
+    const tick = () => {
+      rafRef.current = null;
+      const div = ref.current;
+      const t = targetRef.current;
+      if (div && t?.isConnected) {
+        const r = t.getBoundingClientRect();
+        if (r.width === 0 && r.height === 0) {
+          div.style.display = "none";
+        } else {
+          div.style.display = "block";
+          div.style.left = `${Math.round(r.left)}px`;
+          div.style.top = `${Math.round(r.top)}px`;
+          div.style.width = `${Math.round(r.width)}px`;
+          div.style.height = `${Math.round(r.height)}px`;
+        }
+      } else if (div) {
+        div.style.display = "none";
+      }
+      rafRef.current = requestAnimationFrame(tick);
+    };
+    rafRef.current = requestAnimationFrame(tick);
+    return () => {
+      if (rafRef.current != null)
+        cancelAnimationFrame(rafRef.current);
+    };
+  }, []);
+  return /* @__PURE__ */ jsx5("div", {
+    ref,
+    "aria-hidden": "true",
+    "data-mc-hover-halo": "",
+    style: {
+      position: "fixed",
+      display: "none",
+      pointerEvents: "none",
+      zIndex: 2147483646,
+      border: "2px solid var(--maude-hud-accent, #d63b1f)",
+      borderRadius: "3px",
+      boxSizing: "border-box"
+    }
+  });
+}
+function dropComment(clientX, clientY, selSet, file) {
+  if (typeof document === "undefined")
+    return;
+  let target = resolveHoverTarget(document, clientX, clientY, { deep: true });
+  if (!target)
+    target = resolveHoverTarget(document, clientX, clientY, { deep: false });
+  if (!target && !isBareSpecimen() && typeof document.elementsFromPoint === "function") {
+    const stack = document.elementsFromPoint(clientX, clientY);
+    for (const candidate of stack) {
+      const stamped = candidate.closest?.("[data-cd-id]");
+      if (!stamped)
+        continue;
+      if (!stamped.closest(".dc-artboard-body"))
+        continue;
+      const artboardEl = stamped.closest("[data-dc-screen]");
+      target = {
+        el: stamped,
+        cdId: stamped.getAttribute("data-cd-id"),
+        artboardId: artboardEl?.getAttribute("data-dc-screen") ?? null
+      };
+      break;
+    }
+  }
+  if (!target && isBareSpecimen()) {
+    const el = pickSpecimenEl(clientX, clientY);
+    if (el)
+      target = { el, cdId: el.getAttribute("data-cd-id"), artboardId: null };
+  }
+  if (!target) {
+    const floatingSel = {
+      file,
+      id: undefined,
+      selector: "",
+      artboardId: null,
+      tag: "",
+      classes: "",
+      text: "",
+      dom_path: [],
+      bounds: { x: clientX - 12, y: clientY - 12, w: 24, h: 24 },
+      html: ""
+    };
+    openComposer(floatingSel, clientX, clientY);
+    return;
+  }
+  const sel = hoverTargetToSelection(target, file);
+  selSet.replace(sel);
+  openComposer(sel, clientX, clientY);
+}
+function openComposer(selection, clientX, clientY) {
+  if (typeof document !== "undefined") {
+    try {
+      document.dispatchEvent(new CustomEvent("cm:open-composer", { detail: { selection, clientX, clientY } }));
+    } catch {}
+  }
+  if (typeof window !== "undefined") {
+    try {
+      window.parent.postMessage({ dgn: "comment-compose", selection }, "*");
+    } catch {}
+  }
+}
+function buildCanvasTree(Canvas, file) {
+  return createElement(MaybeToolProvider, null, createElement(MaybeSelectionSetProvider, null, createElement(CommentHost, { file }, createElement(Canvas))));
+}
+function mountCanvas(Canvas, opts) {
+  const root = createRoot(opts.rootEl);
+  if (!opts.commentsEnabled) {
+    root.render(createElement(Canvas));
+    return;
+  }
+  const file = opts.file ?? deriveFile2();
+  root.render(createElement(CanvasHmrRuntime, { initialCanvas: Canvas, file }));
+}
+var RUNTIME_KEY = "__maudeCanvasRuntime";
+function OkSignal({
+  Canvas,
+  file,
+  onOk
+}) {
+  useEffect6(() => {
+    onOk();
+  }, []);
+  return buildCanvasTree(Canvas, file);
+}
+
+class CanvasErrorBoundary extends Component {
+  state = { hasError: false };
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch() {
+    this.props.onError();
+  }
+  componentDidUpdate(prev) {
+    if (prev.attempt !== this.props.attempt && this.state.hasError) {
+      this.setState({ hasError: false });
+    }
+  }
+  render() {
+    if (this.state.hasError)
+      return this.props.fallback();
+    return this.props.children;
+  }
+}
+function HmrHoldingToast({ message }) {
+  return createElement("div", {
+    className: "dc-hmr-holding",
+    role: "status",
+    "aria-live": "polite",
+    title: message ? `Holding last working render — ${message}` : "Holding last working render"
+  }, "⏸ build error — držím poslední funkční verzi");
+}
+function CanvasHmrRuntime({
+  initialCanvas,
+  file
+}) {
+  const [{ canvas, attempt }, setCanvasState] = useState5({ canvas: initialCanvas, attempt: 0 });
+  const [holding, setHoldingState] = useState5({ on: false });
+  const lastGood = useRef4(null);
+  const canvasRef = useRef4(canvas);
+  canvasRef.current = canvas;
+  useEffect6(() => {
+    const api = {
+      remount: (next) => setCanvasState((s) => ({ canvas: next, attempt: s.attempt + 1 })),
+      setHolding: (on, message) => setHoldingState(on ? { on: true, message } : { on: false })
+    };
+    window[RUNTIME_KEY] = api;
+    return () => {
+      window[RUNTIME_KEY] = undefined;
+    };
+  }, []);
+  const handleOk = useCallback5(() => {
+    lastGood.current = canvasRef.current;
+    setHoldingState((h) => h.on ? { on: false } : h);
+  }, []);
+  const handleError = useCallback5(() => {
+    setHoldingState({ on: true, message: "render error" });
+  }, []);
+  const fallback = useCallback5(() => {
+    const LG = lastGood.current;
+    return LG ? buildCanvasTree(LG, file) : null;
+  }, [file]);
+  return createElement(Fragment3, null, createElement(CanvasErrorBoundary, { attempt, onError: handleError, fallback }, createElement(OkSignal, { key: attempt, Canvas: canvas, file, onOk: handleOk })), holding.on ? createElement(HmrHoldingToast, { message: holding.message }) : null);
+}
+export {
+  mountCanvas,
+  CanvasErrorBoundary
+};
+
+//# debugId=7F1482847AF8ADD864756E2164756E21
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../canvas-comment-mount.tsx", "../comments-overlay.tsx", "../use-collab.tsx", "../use-selection-set.tsx", "../dom-selection.ts", "../input-router.tsx", "../use-tool-mode.tsx", "../canvas-cursors.ts"],
  "sourcesContent": [
    "/**\n * @file       canvas-comment-mount.tsx — shell-owned comment layer + mountCanvas\n * @scope      apps/studio/canvas-comment-mount.tsx\n * @purpose    The canvas mount harness (`_shell.html`) calls `mountCanvas`\n *             instead of rendering the canvas default-export raw. mountCanvas\n *             wraps ANY default export — a `DesignCanvas` UI canvas OR a bare\n *             DS specimen — in a LITE comment provider tree so the in-place\n *             comment tool works on every mounted surface.\n *\n * Why a single shell-owned layer (DDR — see plan §\"Key decision\"):\n *   - Comments used to be mounted only by `DesignCanvas` (ToolProvider +\n *     SelectionSetProvider + CommentsOverlay + the onDropComment router\n *     branch). Bare specimens (`system/<ds>/preview/*.tsx`) never render\n *     DesignCanvas, so they had no comment tool at all.\n *   - Hoisting the comment subsystem here makes it universal. `DesignCanvas`\n *     becomes a CONSUMER of the shell-provided ToolProvider / SelectionSet /\n *     CommentsOverlay (via MaybeToolProvider / MaybeSelectionSetProvider and\n *     by dropping its own <CommentsOverlay/>).\n *\n * Coexistence with the UI-canvas router: this layer's input router is an\n * ANCESTOR capture-listener over the canvas. On a UI canvas, `CanvasShell`\n * still runs its OWN router (hover / select / context-menu / undo). To avoid\n * swallowing those gestures, this router passes a narrow `claimableActions`\n * allowlist — `drop-comment` / `tool` / `escape` / `hover`. `hover` never\n * preventDefaults so the inner router's halo is unaffected; everything else\n * (select / context-menu / undo) propagates untouched to the inner router.\n */\n\nimport {\n  Component,\n  type ComponentType,\n  createElement,\n  Fragment,\n  type ReactNode,\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { createRoot } from 'react-dom/client';\n\nimport { CommentsOverlay } from './comments-overlay.tsx';\nimport { deriveFile, hoverTargetToSelection } from './dom-selection.ts';\nimport { type RouterAction, resolveHoverTarget, useInputRouter } from './input-router.tsx';\nimport {\n  MaybeSelectionSetProvider,\n  type Selection,\n  useSelectionSet,\n} from './use-selection-set.tsx';\nimport { MaybeToolProvider, useToolMode } from './use-tool-mode.tsx';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Phase 24 — the comment-mode cursor (and every other tool cursor) is owned\n// SOLELY by use-tool-mode.tsx, whose `* { cursor: <Kenney glyph> !important }`\n// rule is injected by the ToolProvider this layer mounts (MaybeToolProvider) —\n// so it covers bare DS specimens too. The old `[data-mc-host]…`/`body[…]`\n// comment-cursor rule used to live here, but its higher specificity shadowed\n// the unified Kenney cursor on UI canvases (comment-mount stamps\n// `data-active-tool` on <body>, so `body[data-active-tool=\"comment\"] *` matched\n// there as well). Removed so the single source of truth wins. See DDR-067.\n\n// ─────────────────────────────────────────────────────────────────────────────\n// CommentHost — owns the lite comment subsystem: the input router (comment-\n// scoped), the single CommentsOverlay, the comment-mode cursor attribute, and\n// the parent `dgn:'tool-set'` listener (so the outer menubar comment toggle\n// reaches the iframe).\n\n// Only these action kinds are claimed by the mount-layer router; the rest\n// propagate to a UI canvas's own router. `tool` + `escape` are also handled by\n// the inner router on UI canvases — idempotent (same shared provider). `hover`\n// is dispatched too (it never preventDefaults, so the inner router's own hover\n// halo on a UI canvas is unaffected) — we only PAINT the mount-layer preview\n// halo on a bare specimen, where there is no inner CanvasShell halo.\nconst COMMENT_CLAIMS: ReadonlySet<RouterAction['kind']> = new Set<RouterAction['kind']>([\n  'drop-comment',\n  'tool',\n  'escape',\n  'hover',\n]);\n\n// True when no DesignCanvas/CanvasShell is mounted on this surface — i.e. a\n// bare DS specimen. On a UI canvas (`.dc-canvas` present) the inner shell owns\n// hover-halo painting + `resolveHoverTarget` element anchoring, so the lite\n// layer defers to it.\nfunction isBareSpecimen(): boolean {\n  return typeof document !== 'undefined' && !document.querySelector('.dc-canvas');\n}\n\n// Deepest non-chrome element under a point — the comment anchor for a bare\n// specimen (specimens aren't stamped with `data-cd-id` and have no\n// `.dc-artboard-body`, so `resolveHoverTarget` returns null for them).\nfunction pickSpecimenEl(clientX: number, clientY: number): HTMLElement | null {\n  if (typeof document === 'undefined') return null;\n  const hit = document.elementFromPoint(clientX, clientY) as HTMLElement | null;\n  if (!hit) return null;\n  // Never anchor to comment chrome or the document root.\n  if (hit.closest('.cm-composer, .cm-thread, .cm-mention-popup, .cm-pin, [data-mc-hover-halo]')) {\n    return null;\n  }\n  const tag = hit.tagName;\n  if (tag === 'HTML' || tag === 'BODY') return null;\n  return hit;\n}\n\nfunction CommentHost({ children, file }: { children: ReactNode; file: string | undefined }) {\n  const { tool, setTool } = useToolMode();\n  const selSet = useSelectionSet();\n  const hostRef = useRef<HTMLDivElement | null>(null);\n  // Hover-preview halo target (bare specimens only — see isBareSpecimen).\n  const [hoverEl, setHoverEl] = useState<HTMLElement | null>(null);\n\n  // Latest tool for the router (read at event time, not captured).\n  const toolRef = useRef(tool);\n  toolRef.current = tool;\n  const getActiveTool = useMemo(() => () => toolRef.current, []);\n\n  // Drop the preview halo whenever we leave comment mode.\n  useEffect(() => {\n    if (tool !== 'comment') setHoverEl(null);\n  }, [tool]);\n\n  // Reflect the active tool onto the host (and body, since the host is\n  // display:contents and can't carry a paintable cursor). Comment-mode CSS\n  // keys off `[data-active-tool=\"comment\"]`.\n  useEffect(() => {\n    const host = hostRef.current;\n    if (host) host.setAttribute('data-active-tool', tool);\n    if (typeof document !== 'undefined' && document.body) {\n      document.body.setAttribute('data-active-tool', tool);\n    }\n    return () => {\n      host?.removeAttribute('data-active-tool');\n    };\n  }, [tool]);\n\n  // Parent `dgn:'tool-set'` — the outer dev-server menubar posts this when the\n  // user toggles the comment tool. Mirrors canvas-shell's listener so the\n  // toggle reaches bare specimens too (which have no inner shell listener).\n  useEffect(() => {\n    if (typeof window === 'undefined') return;\n    const onMessage = (e: MessageEvent) => {\n      const m = e.data as { dgn?: string; tool?: string } | null;\n      if (!m || typeof m !== 'object' || m.dgn !== 'tool-set') return;\n      if (typeof m.tool === 'string') setTool(m.tool as never);\n    };\n    window.addEventListener('message', onMessage);\n    return () => window.removeEventListener('message', onMessage);\n  }, [setTool]);\n\n  useInputRouter({\n    hostRef,\n    getActiveTool,\n    claimableActions: COMMENT_CLAIMS,\n    callbacks: {\n      onHover: ({ clientX, clientY }) => {\n        // Paint a preview halo only on bare specimens; a UI canvas's own\n        // CanvasShell HoverHalo owns the comment-mode preview there.\n        if (toolRef.current !== 'comment' || !isBareSpecimen()) {\n          setHoverEl(null);\n          return;\n        }\n        const el = pickSpecimenEl(clientX, clientY);\n        setHoverEl((prev) => (prev === el ? prev : el));\n      },\n      onTool: ({ tool: t }) => setTool(t),\n      onEscape: () => {\n        if (toolRef.current !== 'move') setTool('move');\n        setHoverEl(null);\n        selSet.clear();\n        if (typeof window !== 'undefined') {\n          try {\n            window.parent.postMessage({ dgn: 'force-clear' }, '*');\n          } catch {\n            /* parent detached */\n          }\n        }\n      },\n      onDropComment: ({ clientX, clientY }) => dropComment(clientX, clientY, selSet, file),\n    },\n  });\n\n  // `display: contents` keeps the specimen's own flex/grid layout byte-\n  // identical — the host box contributes nothing to layout. The fixed-position\n  // CommentsOverlay renders fine as a child regardless.\n  return (\n    <div data-mc-host ref={hostRef} style={{ display: 'contents' }}>\n      {children}\n      {hoverEl ? <MountHoverHalo el={hoverEl} /> : null}\n      <CommentsOverlay />\n    </div>\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// MountHoverHalo — fixed-position outline tracking the hovered element's screen\n// bounds via rAF. Inline-styled (no dependency on canvas-lib's HALO_CSS, which\n// a bare specimen doesn't load). Mirrors canvas-shell's HoverHalo visually.\n\nfunction MountHoverHalo({ el }: { el: HTMLElement }) {\n  const ref = useRef<HTMLDivElement | null>(null);\n  const targetRef = useRef<HTMLElement>(el);\n  targetRef.current = el;\n  const rafRef = useRef<number | null>(null);\n\n  useEffect(() => {\n    const tick = () => {\n      rafRef.current = null;\n      const div = ref.current;\n      const t = targetRef.current;\n      if (div && t?.isConnected) {\n        const r = t.getBoundingClientRect();\n        if (r.width === 0 && r.height === 0) {\n          div.style.display = 'none';\n        } else {\n          div.style.display = 'block';\n          div.style.left = `${Math.round(r.left)}px`;\n          div.style.top = `${Math.round(r.top)}px`;\n          div.style.width = `${Math.round(r.width)}px`;\n          div.style.height = `${Math.round(r.height)}px`;\n        }\n      } else if (div) {\n        div.style.display = 'none';\n      }\n      rafRef.current = requestAnimationFrame(tick);\n    };\n    rafRef.current = requestAnimationFrame(tick);\n    return () => {\n      if (rafRef.current != null) cancelAnimationFrame(rafRef.current);\n    };\n  }, []);\n\n  return (\n    <div\n      ref={ref}\n      aria-hidden=\"true\"\n      data-mc-hover-halo=\"\"\n      style={{\n        position: 'fixed',\n        display: 'none',\n        pointerEvents: 'none',\n        zIndex: 2147483646,\n        border: '2px solid var(--maude-hud-accent, #d63b1f)',\n        borderRadius: '3px',\n        boxSizing: 'border-box',\n      }}\n    />\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Comment drop — generic path lifted from canvas-shell's onDropComment. Works\n// with or without artboards: deep/shallow resolveHoverTarget → elementsFromPoint\n// data-cd-id climb → floating fallback. Dispatches `cm:open-composer` for the\n// in-iframe overlay + posts `comment-compose` to the parent for legacy mocks.\n\nfunction dropComment(\n  clientX: number,\n  clientY: number,\n  selSet: { replace: (s: Selection) => void },\n  file: string | undefined\n): void {\n  if (typeof document === 'undefined') return;\n  let target = resolveHoverTarget(document, clientX, clientY, { deep: true });\n  if (!target) target = resolveHoverTarget(document, clientX, clientY, { deep: false });\n  // UI-canvas recovery — when both passes bail on a `pointer-events: none`\n  // decoration, enumerate the stack and climb the first `data-cd-id` ancestor\n  // inside an artboard body. Skipped on bare specimens, which instead anchor to\n  // the exact hovered element below (so the pin matches the hover preview halo).\n  if (!target && !isBareSpecimen() && typeof document.elementsFromPoint === 'function') {\n    const stack = document.elementsFromPoint(clientX, clientY);\n    for (const candidate of stack) {\n      const stamped = (candidate as Element).closest?.('[data-cd-id]') as HTMLElement | null;\n      if (!stamped) continue;\n      if (!stamped.closest('.dc-artboard-body')) continue;\n      const artboardEl = stamped.closest('[data-dc-screen]');\n      target = {\n        el: stamped,\n        cdId: stamped.getAttribute('data-cd-id'),\n        artboardId: artboardEl?.getAttribute('data-dc-screen') ?? null,\n      };\n      break;\n    }\n  }\n\n  // Bare-specimen anchor — specimens have no `.dc-artboard-body`, so\n  // resolveHoverTarget bails. Anchor to the EXACT element under the cursor (the\n  // same one pickSpecimenEl highlights for the hover preview), via its own\n  // data-cd-id when stamped, else a cssPath selector — so the dropped pin lands\n  // on the previewed element instead of floating.\n  if (!target && isBareSpecimen()) {\n    const el = pickSpecimenEl(clientX, clientY);\n    if (el) target = { el, cdId: el.getAttribute('data-cd-id'), artboardId: null };\n  }\n\n  if (!target) {\n    // Floating comment — no element anchor, just the click point (e.g. a click\n    // on empty canvas/specimen dead space). The overlay renders a pin at the\n    // stored bounds.\n    const floatingSel: Selection = {\n      file,\n      id: undefined,\n      selector: '',\n      artboardId: null,\n      tag: '',\n      classes: '',\n      text: '',\n      dom_path: [],\n      bounds: { x: clientX - 12, y: clientY - 12, w: 24, h: 24 },\n      html: '',\n    };\n    openComposer(floatingSel, clientX, clientY);\n    return;\n  }\n\n  const sel = hoverTargetToSelection(target, file);\n  selSet.replace(sel);\n  openComposer(sel, clientX, clientY);\n}\n\nfunction openComposer(selection: Selection, clientX: number, clientY: number): void {\n  if (typeof document !== 'undefined') {\n    try {\n      document.dispatchEvent(\n        new CustomEvent('cm:open-composer', { detail: { selection, clientX, clientY } })\n      );\n    } catch {\n      /* CustomEvent absent — fall through to parent path */\n    }\n  }\n  if (typeof window !== 'undefined') {\n    try {\n      window.parent.postMessage({ dgn: 'comment-compose', selection }, '*');\n    } catch {\n      /* parent detached */\n    }\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// mountCanvas — the shell harness entry. Renders the canvas wrapped in the lite\n// comment tree, or bare when comments are disabled (gallery thumbnails pass\n// `commentsEnabled: false` via `?comments=0`).\n\nexport interface MountCanvasOptions {\n  rootEl: HTMLElement;\n  /** Canvas file key (designRel-prefixed). Defaults to `deriveFile()`. */\n  file?: string;\n  /** When false, the comment layer is skipped — the canvas renders raw. */\n  commentsEnabled: boolean;\n}\n\n// The lite provider tree wrapping a canvas component (tool + selection +\n// comment layer). Pulled out so both the live render and the error-fallback\n// render build the identical envelope.\n//\n// NB: the CanvasActivityProvider (Phase 13 / DDR-029) is NOT mounted here — it\n// lives inside `DesignCanvas` (canvas-lib). comment-mount.js and canvas-lib are\n// SEPARATE bundles, so a context provided here would be a different instance\n// from the one DCArtboard (canvas-lib) consumes. Same reasoning the real\n// ToolProvider lives in DesignCanvas, not in this layer's MaybeToolProvider.\nfunction buildCanvasTree(Canvas: ComponentType, file: string | undefined): ReactNode {\n  return createElement(\n    MaybeToolProvider,\n    null,\n    createElement(\n      MaybeSelectionSetProvider,\n      null,\n      createElement(CommentHost, { file }, createElement(Canvas))\n    )\n  );\n}\n\nexport function mountCanvas(Canvas: ComponentType, opts: MountCanvasOptions): void {\n  const root = createRoot(opts.rootEl);\n  if (!opts.commentsEnabled) {\n    root.render(createElement(Canvas));\n    return;\n  }\n  const file = opts.file ?? deriveFile();\n  root.render(createElement(CanvasHmrRuntime, { initialCanvas: Canvas, file }));\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Phase 13.1 / DDR-077 — HMR error resilience during agent editing.\n//\n// When an agent (`/design:edit` / `/design:new`) live-edits a canvas, a\n// half-saved file (missing import, undefined symbol, transpile error) used to\n// blank the canvas to white: the shell did `location.reload()` straight into the\n// broken module. The shell now soft-reloads (import-before-swap, see\n// `templates/_shell.html`) so a build/import error never tears down the good\n// render. This runtime closes the remaining gap — a *render-time* throw — by\n// keeping the last good canvas mounted via an error boundary and surfacing a\n// \"holding last good\" toast instead of a white screen. Strictly gated by the\n// shell on agent-active; manual edits keep the plain reload (so this is inert\n// for solo hand-editing). The runtime exposes its swap/hold API on\n// `window.__maudeCanvasRuntime` (the same window-handshake style the shell\n// already uses for `__canvas_rel__` etc.).\n\nexport interface CanvasRuntimeApi {\n  /** Swap in a freshly-imported canvas module's default export (success path). */\n  remount: (next: ComponentType) => void;\n  /** Show/hide the \"holding last good\" toast (build-error path from the shell). */\n  setHolding: (on: boolean, message?: string) => void;\n}\n\nconst RUNTIME_KEY = '__maudeCanvasRuntime';\n\n/**\n * Fires `onOk` only when its subtree COMMITS — i.e. renders without throwing. A\n * render-time throw in the canvas unwinds to the boundary before this commits,\n * so `onOk` never runs and `lastGood` is not advanced to a broken module.\n */\nfunction OkSignal({\n  Canvas,\n  file,\n  onOk,\n}: {\n  Canvas: ComponentType;\n  file: string | undefined;\n  onOk: () => void;\n}) {\n  // biome-ignore lint/correctness/useExhaustiveDependencies: fire once per mount (key=attempt remounts this).\n  useEffect(() => {\n    onOk();\n  }, []);\n  return buildCanvasTree(Canvas, file);\n}\n\nexport class CanvasErrorBoundary extends Component<\n  {\n    attempt: number;\n    onError: () => void;\n    fallback: () => ReactNode;\n    children: ReactNode;\n  },\n  { hasError: boolean }\n> {\n  state = { hasError: false };\n  static getDerivedStateFromError(): { hasError: boolean } {\n    return { hasError: true };\n  }\n  componentDidCatch(): void {\n    this.props.onError();\n  }\n  componentDidUpdate(prev: { attempt: number }): void {\n    // A new canvas (new attempt) arrived → clear the error and try rendering it.\n    if (prev.attempt !== this.props.attempt && this.state.hasError) {\n      this.setState({ hasError: false });\n    }\n  }\n  render(): ReactNode {\n    if (this.state.hasError) return this.props.fallback();\n    return this.props.children;\n  }\n}\n\nfunction HmrHoldingToast({ message }: { message?: string }): ReactNode {\n  return createElement(\n    'div',\n    {\n      className: 'dc-hmr-holding',\n      role: 'status',\n      'aria-live': 'polite',\n      title: message ? `Holding last working render — ${message}` : 'Holding last working render',\n    },\n    '⏸ build error — držím poslední funkční verzi'\n  );\n}\n\nfunction CanvasHmrRuntime({\n  initialCanvas,\n  file,\n}: {\n  initialCanvas: ComponentType;\n  file: string | undefined;\n}): ReactNode {\n  const [{ canvas, attempt }, setCanvasState] = useState({ canvas: initialCanvas, attempt: 0 });\n  const [holding, setHoldingState] = useState<{ on: boolean; message?: string }>({ on: false });\n  const lastGood = useRef<ComponentType | null>(null);\n  const canvasRef = useRef(canvas);\n  canvasRef.current = canvas;\n\n  // Publish the runtime API for the shell HMR client.\n  useEffect(() => {\n    const api: CanvasRuntimeApi = {\n      remount: (next) => setCanvasState((s) => ({ canvas: next, attempt: s.attempt + 1 })),\n      setHolding: (on, message) => setHoldingState(on ? { on: true, message } : { on: false }),\n    };\n    (window as unknown as Record<string, unknown>)[RUNTIME_KEY] = api;\n    return () => {\n      (window as unknown as Record<string, unknown>)[RUNTIME_KEY] = undefined;\n    };\n  }, []);\n\n  const handleOk = useCallback(() => {\n    lastGood.current = canvasRef.current;\n    // The new canvas rendered clean → drop any holding state.\n    setHoldingState((h) => (h.on ? { on: false } : h));\n  }, []);\n\n  const handleError = useCallback(() => {\n    setHoldingState({ on: true, message: 'render error' });\n  }, []);\n\n  const fallback = useCallback((): ReactNode => {\n    const LG = lastGood.current;\n    return LG ? buildCanvasTree(LG, file) : null;\n  }, [file]);\n\n  return createElement(\n    Fragment,\n    null,\n    createElement(\n      CanvasErrorBoundary,\n      { attempt, onError: handleError, fallback },\n      // key=attempt → each soft-reload remounts a fresh subtree (and resets the\n      // boundary's child), matching the clean-slate semantics of a full reload.\n      createElement(OkSignal, { key: attempt, Canvas: canvas, file, onOk: handleOk })\n    ),\n    holding.on ? createElement(HmrHoldingToast, { message: holding.message }) : null\n  );\n}\n",
    "/**\n * @file       comments-overlay.tsx — FigJam-style in-place comments overlay\n * @scope      apps/studio/comments-overlay.tsx\n * @purpose    Renders DS-styled comment pins (Phase 6 Task 2), the in-place\n *             composer bubble (Task 3), and the thread popover (Task 4)\n *             inside the canvas iframe. Sibling to `annotations-layer` —\n *             portals into `.dc-world` so CSS zoom + translate on the world\n *             plane scale every pin/popover uniformly with the artboards.\n *\n * Data flow (Phase 6 Task 2 — pins only; composer + thread land in Task 3/4):\n *   1. Shell (`client/app.jsx`) pushes `{ dgn: 'comments-set', comments }`\n *      into the iframe whenever its `commentsByFile[activePath]` changes.\n *   2. Overlay also fetches `/_comments?file=...` on mount as a self-heal —\n *      lets the overlay render even if the shell hasn't broadcast yet\n *      (race on first iframe load).\n *   3. Shell pushes `{ dgn: 'comment-focus', id }` when the user clicks a row\n *      in the comments panel — overlay highlights the matching pin.\n *   4. Overlay posts `{ dgn: 'comment-click', id }` back to the shell when\n *      the user clicks a pin — same channel the legacy `dgn-pin` overlay\n *      used; the shell already routes it to `setFocusedCommentId`.\n *\n * Filter respect — Phase 6 Task 2 default is \"hide resolved\". The shell will\n * gain a `comments-filter` channel in Task 6; until then the overlay always\n * hides resolved pins. Plan-aligned.\n *\n * Pin position math — see `offsetWithinWorld` below. We walk offsetParent up\n * to `.dc-world` to get pre-zoom world coords directly; CSS zoom on the world\n * plane then renders the pin at the right scale without us doing zoom math.\n *\n * The legacy vanilla-JS `#dgn-pin-layer` injected by `inspect.ts` is hidden\n * on mount to avoid double-pins inside TSX canvases. The legacy layer still\n * renders for `.html` mocks where this React overlay never mounts.\n */\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useCollab } from './use-collab.tsx';\nimport { useSelectionSetOptional } from './use-selection-set.tsx';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Types — kept in sync with `Comment` in `api.ts`. We mirror the shape rather\n// than import to avoid pulling server types into the canvas runtime bundle.\n\ninterface OverlayBounds {\n  x: number;\n  y: number;\n  w: number;\n  h: number;\n}\n\n// Selection payload posted by canvas-shell's `onDropComment`. Mirrors the\n// shape `hoverTargetToSelection` returns; we keep it loose so the overlay\n// doesn't depend on canvas-shell types.\ninterface ComposeSelection {\n  file?: string;\n  id?: string;\n  selector: string;\n  artboardId?: string | null;\n  tag: string;\n  classes: string;\n  text: string;\n  dom_path: string[];\n  bounds: OverlayBounds | null;\n  html: string;\n}\n\ninterface ComposerState {\n  selection: ComposeSelection;\n  clientX: number;\n  clientY: number;\n}\n\ninterface OverlayReply {\n  id: string;\n  author: string;\n  body: string;\n  created: string;\n}\n\nexport interface OverlayComment {\n  id: string;\n  file: string;\n  selector: string;\n  /** Occurrence index among `querySelectorAll(selector)` — disambiguates a\n   * component repeated within one artboard. Absent (old comments) → first. */\n  index?: number;\n  bounds: OverlayBounds | null;\n  text: string;\n  status: 'open' | 'resolved';\n  created: string;\n  resolved_at: string | null;\n  author?: string;\n  thread?: OverlayReply[];\n  mentions?: string[];\n  // dom_path / tag / classes / html_excerpt unused at overlay layer; kept off\n  // the type to keep the surface tight.\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// CSS load — sibling stylesheet, fetched once per session via a <link> tag.\n// Inlining the file at build time would cost an extra bundler config; the\n// overlay is internal-only so a runtime <link> is fine.\n\nconst CSS_HREF = '/_client/comments-overlay.css';\n\nfunction ensureOverlayStyles(): void {\n  if (typeof document === 'undefined') return;\n  if (document.getElementById('cm-overlay-css')) return;\n  const link = document.createElement('link');\n  link.id = 'cm-overlay-css';\n  link.rel = 'stylesheet';\n  link.href = CSS_HREF;\n  document.head.appendChild(link);\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// File derivation — same logic as canvas-shell.tsx::deriveFile(). Duplicated\n// here so the overlay can fetch its own comments on mount without importing\n// from canvas-shell (which would create a cycle).\n\nfunction deriveFile(): string | null {\n  if (typeof window === 'undefined') return null;\n  try {\n    const p = window.location.pathname;\n    if (p === '/_canvas-shell.html' || p === '/_canvas-shell') {\n      const qs = new URLSearchParams(window.location.search);\n      const canvas = qs.get('canvas') ?? '';\n      const designRel = (qs.get('designRel') ?? '.design').replace(/^\\/+|\\/+$/g, '');\n      return canvas ? `${designRel}/${canvas}` : null;\n    }\n    return decodeURIComponent(p).replace(/^\\//, '');\n  } catch {\n    return null;\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Position resolvers — screen coords via getBoundingClientRect. Mirrors the\n// `SelectionHalos` / `HoverHalo` pattern in canvas-shell.tsx so the comments\n// layer can render as a fixed-position sibling of `.dc-canvas` (above the\n// halo chrome at z-index 5) instead of being portaled into `.dc-world` where\n// it would lose the stacking battle.\n\nfunction screenRectFor(\n  selector: string,\n  index?: number\n): {\n  x: number;\n  y: number;\n  w: number;\n  h: number;\n} | null {\n  if (!selector) return null;\n  let el: HTMLElement | null = null;\n  try {\n    // index disambiguates a component repeated within one artboard (querySelector\n    // alone would always grab the first match). Absent/0 → first.\n    const all = document.querySelectorAll(selector);\n    const i = index && index > 0 && index < all.length ? index : 0;\n    el = (all[i] ?? all[0] ?? null) as HTMLElement | null;\n  } catch {\n    return null;\n  }\n  if (!el?.isConnected) return null;\n  const r = el.getBoundingClientRect();\n  if (r.width === 0 && r.height === 0) return null;\n  return { x: r.left, y: r.top, w: r.width, h: r.height };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Public component — mounted from canvas-shell.tsx alongside ToolPalette /\n// AnnotationsLayer / SnapGuideOverlay.\n\nexport function CommentsOverlay(): React.ReactNode {\n  ensureOverlayStyles();\n\n  // Optional — CommentsOverlay is mounted inside SelectionSetProvider in the\n  // standard CanvasShell tree, but stays usable if a host ever embeds it\n  // outside that provider (returns null instead of throwing).\n  const selSet = useSelectionSetOptional();\n  const [comments, setComments] = useState<OverlayComment[]>([]);\n  const [focusedId, setFocusedId] = useState<string | null>(null);\n  const [composer, setComposer] = useState<ComposerState | null>(null);\n  const file = useMemo(() => deriveFile(), []);\n\n  // Drop the legacy `#dgn-pin-layer` so we don't render duplicate pins inside\n  // TSX canvases. The layer ships in every served HTML page via inspect.ts;\n  // for `.html` mocks (no canvas-shell mount) it still does its job.\n  useEffect(() => {\n    if (typeof document === 'undefined') return;\n    const legacy = document.getElementById('dgn-pin-layer') as HTMLElement | null;\n    if (!legacy) return;\n    const prev = legacy.style.display;\n    legacy.style.display = 'none';\n    return () => {\n      legacy.style.display = prev;\n    };\n  }, []);\n\n  // Mirror a comment into the canvas selection set so SelectionHalos paints\n  // the same halo Cmd-click would. Called from both the in-iframe pin click\n  // AND the inbound `comment-focus` postMessage so jumping from the shell's\n  // Comments panel produces the same visual feedback as clicking the pin.\n  const mirrorSelection = useCallback(\n    (comment: OverlayComment | undefined) => {\n      if (!selSet) return;\n      if (!comment?.selector) {\n        selSet.clear();\n        return;\n      }\n      const cdMatch = comment.selector.match(/data-cd-id=\"([^\"]+)\"/);\n      const cdId = cdMatch ? cdMatch[1] : undefined;\n      let tag: string | undefined;\n      let classes: string | undefined;\n      try {\n        const el = document.querySelector(comment.selector) as HTMLElement | null;\n        if (el) {\n          tag = el.tagName.toLowerCase();\n          classes = (el.getAttribute('class') ?? '')\n            .split(/\\s+/)\n            .filter((cls) => cls && !cls.startsWith('dgn-') && !cls.startsWith('dc-cv-'))\n            .join(' ');\n        }\n      } catch {\n        /* unresolvable selector — fall through with no fresh metadata */\n      }\n      selSet.replace({\n        file: file ?? undefined,\n        id: cdId,\n        selector: comment.selector,\n        tag,\n        classes,\n        bounds: comment.bounds ?? undefined,\n      });\n    },\n    [selSet, file]\n  );\n\n  // Keep the latest comments list reachable from the message handler without\n  // re-attaching the listener on every comments mutation.\n  const commentsRef = useRef<OverlayComment[]>(comments);\n  commentsRef.current = comments;\n\n  // Phase 8 Task 3 — when a collab room is connected, the Y.Array of comments\n  // is the live source of truth. observe() fires on every remote mutation\n  // (added pins from another tab, resolved-from-inspector via the registry\n  // bridge, etc.) and on the local seed. Both paths converge on the same\n  // JSON projection — last-write-wins between Y.Array and postMessage is\n  // safe because they carry identical content; the Y.Array path just\n  // reaches us first (no 800 ms debounce delay).\n  const collab = useCollab();\n  useEffect(() => {\n    if (!collab) return;\n    const arr = collab.doc.getArray<OverlayComment>('comments');\n    const sync = () => {\n      // toArray() snapshot the current Y.Array into a plain JS list.\n      setComments(arr.toArray() as OverlayComment[]);\n    };\n    // Initial fill — covers the case where Y.Doc was already seeded by the\n    // time this overlay mounted.\n    if (arr.length > 0) sync();\n    arr.observe(sync);\n    return () => {\n      try {\n        arr.unobserve(sync);\n      } catch {\n        /* doc destroyed before unmount — observer already gone */\n      }\n    };\n  }, [collab]);\n\n  // Listen for the shell's broadcast channels. Schema matches the legacy\n  // overlay so the shell-side glue in client/app.jsx (~line 1672) keeps\n  // working without modification.\n  useEffect(() => {\n    if (typeof window === 'undefined') return;\n    const onMessage = (e: MessageEvent) => {\n      const m = e.data as { dgn?: string; comments?: unknown; id?: string } | null;\n      if (!m || typeof m !== 'object' || !m.dgn) return;\n      if (m.dgn === 'comments-set' && Array.isArray(m.comments)) {\n        setComments(m.comments as OverlayComment[]);\n      } else if (m.dgn === 'comment-focus') {\n        const id = typeof m.id === 'string' ? m.id : null;\n        setFocusedId(id);\n        const target = id ? commentsRef.current.find((c) => c.id === id) : undefined;\n        mirrorSelection(target);\n      }\n    };\n    window.addEventListener('message', onMessage);\n    return () => window.removeEventListener('message', onMessage);\n  }, [mirrorSelection]);\n\n  // canvas-shell's `onDropComment` dispatches `cm:open-composer` on the iframe\n  // document. Open the composer pinned to that click point.\n  useEffect(() => {\n    if (typeof document === 'undefined') return;\n    const onOpen = (e: Event) => {\n      const detail = (\n        e as CustomEvent<{ selection?: ComposeSelection; clientX?: number; clientY?: number }>\n      ).detail;\n      if (!detail?.selection) return;\n      setComposer({\n        selection: detail.selection,\n        clientX: typeof detail.clientX === 'number' ? detail.clientX : 0,\n        clientY: typeof detail.clientY === 'number' ? detail.clientY : 0,\n      });\n    };\n    document.addEventListener('cm:open-composer', onOpen);\n    return () => document.removeEventListener('cm:open-composer', onOpen);\n  }, []);\n\n  const closeComposer = useCallback(() => {\n    setComposer(null);\n    if (typeof window === 'undefined') return;\n    try {\n      window.parent.postMessage({ dgn: 'force-clear' }, '*');\n    } catch {\n      /* parent detached */\n    }\n  }, []);\n\n  const submitComposer = useCallback(\n    (text: string) => {\n      if (!composer) return;\n      const sel = composer.selection;\n      const payload = {\n        file: sel.file,\n        selector: sel.selector,\n        index: sel.index,\n        dom_path: sel.dom_path,\n        tag: sel.tag,\n        classes: sel.classes,\n        bounds: sel.bounds,\n        html_excerpt: sel.html,\n        text,\n      };\n      if (typeof window === 'undefined') return;\n      // Shell relays into the WS `comments-add` channel and persists.\n      try {\n        window.parent.postMessage({ dgn: 'comment-submit', payload }, '*');\n      } catch {\n        /* parent detached */\n      }\n      closeComposer();\n    },\n    [composer, closeComposer]\n  );\n\n  // Self-heal fetch — covers the race where the iframe loads before the shell\n  // pushes `comments-set` (e.g. first hydration on cold open).\n  useEffect(() => {\n    if (!file) return;\n    let cancelled = false;\n    (async () => {\n      try {\n        const r = await fetch(`/_comments?file=${encodeURIComponent(file)}`);\n        if (!r.ok) return;\n        const data = (await r.json()) as { comments?: OverlayComment[] };\n        if (cancelled) return;\n        if (Array.isArray(data.comments)) {\n          // Only set when we haven't received a shell broadcast yet; the\n          // shell is authoritative once it kicks in.\n          setComments((prev) => (prev.length === 0 ? (data.comments ?? []) : prev));\n        }\n      } catch {\n        /* offline / dev-server restart — silently no-op */\n      }\n    })();\n    return () => {\n      cancelled = true;\n    };\n  }, [file]);\n\n  // Sorted by `created` asc so sequence numbers are stable per canvas across\n  // reloads. Resolved comments are hidden by default (Task 2 spec).\n  const visible = useMemo(() => {\n    const list = comments.slice().sort((a, b) => a.created.localeCompare(b.created));\n    return list.filter((c) => c.status !== 'resolved');\n  }, [comments]);\n\n  // Sequence index lookup — built off the FULL sorted list so a resolved-then-\n  // reopened pin keeps its original number.\n  const indexById = useMemo(() => {\n    const m = new Map<string, number>();\n    const all = comments.slice().sort((a, b) => a.created.localeCompare(b.created));\n    all.forEach((c, i) => {\n      m.set(c.id, i + 1);\n    });\n    return m;\n  }, [comments]);\n\n  const handlePinClick = useCallback(\n    (id: string) => {\n      setFocusedId(id);\n      mirrorSelection(comments.find((c) => c.id === id));\n      if (typeof window === 'undefined') return;\n      try {\n        window.parent.postMessage({ dgn: 'comment-click', id }, '*');\n      } catch {\n        /* parent detached */\n      }\n    },\n    [comments, mirrorSelection]\n  );\n\n  const handlePatch = useCallback((id: string, patch: Record<string, unknown>) => {\n    if (typeof window === 'undefined') return;\n    try {\n      window.parent.postMessage({ dgn: 'comment-patch', id, patch }, '*');\n    } catch {\n      /* parent detached */\n    }\n  }, []);\n\n  const handleDelete = useCallback((id: string) => {\n    if (typeof window === 'undefined') return;\n    try {\n      window.parent.postMessage({ dgn: 'comment-delete', id }, '*');\n    } catch {\n      /* parent detached */\n    }\n    setFocusedId((prev) => (prev === id ? null : prev));\n  }, []);\n\n  const handleReply = useCallback(async (id: string, body: string): Promise<boolean> => {\n    if (typeof fetch === 'undefined') return false;\n    try {\n      const r = await fetch(`/_api/comments/${encodeURIComponent(id)}/reply`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ body }),\n      });\n      if (!r.ok) return false;\n      const updated = (await r.json()) as OverlayComment;\n      // Optimistic local merge — the shell will broadcast `comments-set`\n      // shortly after as the WS fans out the change, but applying it now\n      // avoids the popover flickering empty between submit + broadcast.\n      setComments((prev) => prev.map((c) => (c.id === updated.id ? updated : c)));\n      return true;\n    } catch {\n      return false;\n    }\n  }, []);\n\n  return (\n    <div className=\"cm-layer\" aria-hidden={false}>\n      {visible.map((c) => {\n        const n = indexById.get(c.id) ?? 0;\n        return (\n          <CommentPin\n            key={c.id}\n            comment={c}\n            sequence={n}\n            focused={focusedId === c.id}\n            onClick={handlePinClick}\n          />\n        );\n      })}\n      {composer ? (\n        <CommentComposer state={composer} onSubmit={submitComposer} onCancel={closeComposer} />\n      ) : null}\n      {(() => {\n        if (!focusedId) return null;\n        const focused = visible.find((c) => c.id === focusedId);\n        if (!focused) return null;\n        return (\n          <CommentThread\n            comment={focused}\n            sequence={indexById.get(focused.id) ?? 0}\n            onClose={() => {\n              setFocusedId(null);\n              // Drop the canvas halo when the thread closes — symmetric with\n              // `handlePinClick` which paints it on open.\n              selSet?.clear();\n            }}\n            onPatch={(patch) => handlePatch(focused.id, patch)}\n            onDelete={() => handleDelete(focused.id)}\n            onReply={(body) => handleReply(focused.id, body)}\n          />\n        );\n      })()}\n    </div>\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// MentionAwareTextarea + popup — Task 5\n//\n// Wraps a textarea and surfaces an autocomplete popup when the caret sits\n// inside an `@<query>` token (no whitespace between `@` and cursor). The\n// committer list is fetched once on first focus and cached for the session.\n// Keyboard: ↑↓ move, ↵/Tab insert (`@firstname `), Esc dismiss.\n\ninterface CommitterRow {\n  name: string;\n  email: string;\n  commits: number;\n}\n\nlet committerCache: Promise<CommitterRow[]> | null = null;\nasync function loadCommitters(): Promise<CommitterRow[]> {\n  if (!committerCache) {\n    committerCache = (async () => {\n      try {\n        const r = await fetch('/_api/git-committers');\n        if (!r.ok) return [];\n        const data = (await r.json()) as { committers?: CommitterRow[] };\n        return Array.isArray(data.committers) ? data.committers : [];\n      } catch {\n        return [];\n      }\n    })();\n  }\n  return committerCache;\n}\n\nfunction firstNameSlug(name: string): string {\n  // `@firstname` is what we insert on accept. Strip surnames + punctuation.\n  const first = name.trim().split(/\\s+/)[0] ?? '';\n  // Keep alphanum + `.` `-` `_` (matches the parseMentions regex on the server).\n  return first.replace(/[^\\w.-]/g, '').toLowerCase();\n}\n\ninterface MentionToken {\n  start: number; // index of `@`\n  end: number; // exclusive — current caret\n  query: string; // chars between `@` and caret (excluding `@`)\n}\n\nfunction detectMentionToken(text: string, caret: number): MentionToken | null {\n  if (caret <= 0 || caret > text.length) return null;\n  // Walk backwards from caret; the token starts at `@` and ends at the caret.\n  // Aborts on whitespace, newline, or any non-mention char so a stray `@` in\n  // an email is ignored.\n  let i = caret - 1;\n  while (i >= 0) {\n    const ch = text[i] ?? '';\n    if (ch === '@') {\n      // Token must be word-leading: previous char is start-of-string or whitespace.\n      const prev = i > 0 ? text[i - 1] : '';\n      if (i === 0 || /\\s/.test(prev ?? '')) {\n        const query = text.slice(i + 1, caret);\n        return { start: i, end: caret, query };\n      }\n      return null;\n    }\n    if (!/[\\w.-]/.test(ch)) return null;\n    i -= 1;\n  }\n  return null;\n}\n\nfunction MentionAwareTextarea({\n  className,\n  value,\n  onChange,\n  onKeyDown,\n  placeholder,\n  rows,\n  disabled,\n  textareaRef,\n  ariaLabel,\n}: {\n  className: string;\n  value: string;\n  onChange: (next: string) => void;\n  onKeyDown?: (e: React.KeyboardEvent<HTMLTextAreaElement>) => void;\n  placeholder?: string;\n  rows?: number;\n  disabled?: boolean;\n  textareaRef?: React.MutableRefObject<HTMLTextAreaElement | null>;\n  ariaLabel?: string;\n}): React.ReactElement {\n  const internalRef = useRef<HTMLTextAreaElement | null>(null);\n  const setRef = useCallback(\n    (el: HTMLTextAreaElement | null) => {\n      internalRef.current = el;\n      if (textareaRef) textareaRef.current = el;\n    },\n    [textareaRef]\n  );\n\n  const [committers, setCommitters] = useState<CommitterRow[]>([]);\n  const [token, setToken] = useState<MentionToken | null>(null);\n  const [highlight, setHighlight] = useState(0);\n\n  // Lazy-load committers on first focus.\n  const onFocus = useCallback(() => {\n    if (committers.length > 0) return;\n    void loadCommitters().then((list) => setCommitters(list));\n  }, [committers.length]);\n\n  const filtered = useMemo(() => {\n    if (!token) return [] as CommitterRow[];\n    const q = token.query.toLowerCase();\n    const list = !q\n      ? committers\n      : committers.filter(\n          (c) => c.name.toLowerCase().includes(q) || c.email.toLowerCase().includes(q)\n        );\n    return list.slice(0, 8);\n  }, [token, committers]);\n\n  const refreshToken = useCallback((textarea: HTMLTextAreaElement) => {\n    const caret = textarea.selectionStart ?? textarea.value.length;\n    const t = detectMentionToken(textarea.value, caret);\n    setToken(t);\n    setHighlight(0);\n  }, []);\n\n  const handleChange = useCallback(\n    (e: React.ChangeEvent<HTMLTextAreaElement>) => {\n      onChange(e.target.value);\n      refreshToken(e.target);\n    },\n    [onChange, refreshToken]\n  );\n\n  const insertMention = useCallback(\n    (committer: CommitterRow) => {\n      if (!token) return;\n      const ta = internalRef.current;\n      if (!ta) return;\n      const tag = `@${firstNameSlug(committer.name)}`;\n      const next = `${value.slice(0, token.start)}${tag} ${value.slice(token.end)}`;\n      onChange(next);\n      setToken(null);\n      // Restore caret just past the inserted token + trailing space.\n      const newCaret = token.start + tag.length + 1;\n      requestAnimationFrame(() => {\n        ta.focus();\n        ta.setSelectionRange(newCaret, newCaret);\n      });\n    },\n    [token, value, onChange]\n  );\n\n  const handleKeyDown = useCallback(\n    (e: React.KeyboardEvent<HTMLTextAreaElement>) => {\n      if (token && filtered.length > 0) {\n        if (e.key === 'ArrowDown') {\n          e.preventDefault();\n          setHighlight((h) => (h + 1) % filtered.length);\n          return;\n        }\n        if (e.key === 'ArrowUp') {\n          e.preventDefault();\n          setHighlight((h) => (h - 1 + filtered.length) % filtered.length);\n          return;\n        }\n        if (e.key === 'Enter' || e.key === 'Tab') {\n          e.preventDefault();\n          const pick = filtered[highlight] ?? filtered[0];\n          if (pick) insertMention(pick);\n          return;\n        }\n        if (e.key === 'Escape') {\n          e.preventDefault();\n          setToken(null);\n          return;\n        }\n      }\n      onKeyDown?.(e);\n    },\n    [token, filtered, highlight, insertMention, onKeyDown]\n  );\n\n  const handleSelect = useCallback(\n    (e: React.SyntheticEvent<HTMLTextAreaElement>) => {\n      refreshToken(e.currentTarget);\n    },\n    [refreshToken]\n  );\n\n  return (\n    <div style={{ position: 'relative' }}>\n      <textarea\n        ref={setRef}\n        className={className}\n        value={value}\n        placeholder={placeholder}\n        rows={rows}\n        disabled={disabled}\n        aria-label={ariaLabel}\n        onChange={handleChange}\n        onKeyDown={handleKeyDown}\n        onFocus={onFocus}\n        onSelect={handleSelect}\n        onClick={handleSelect}\n      />\n      {/* Combobox pattern — `role=\"listbox\"` + `role=\"option\"` is the canonical\n       * ARIA shape for a single-select autocomplete. Keyboard navigation\n       * (↑ ↓ Enter Esc) lives on the parent textarea per the combobox spec,\n       * so the popup itself stays inert. Same pattern applies to the composer\n       * + thread popovers below (`role=\"dialog\"` on a positioned <div>).\n       * Biome's a11y rules want semantic HTML primitives, but none match\n       * \"non-focusable listbox under a textarea\" or \"anchored non-modal popover\".\n       * The four affected rules are scoped off for this file in biome.json. */}\n      {token && filtered.length > 0 ? (\n        <ul\n          className=\"cm-mention-popup\"\n          role=\"listbox\"\n          aria-label=\"Mention suggestions\"\n          style={{ left: 0, top: '100%' }}\n        >\n          {filtered.map((c, i) => {\n            const selected = i === highlight;\n            return (\n              <li\n                key={`${c.name}-${c.email}`}\n                role=\"option\"\n                aria-selected={selected}\n                className=\"cm-mention-popup__item\"\n                onMouseEnter={() => setHighlight(i)}\n                // Use mousedown so the textarea doesn't blur before the\n                // selection registers.\n                onMouseDown={(ev) => {\n                  ev.preventDefault();\n                  insertMention(c);\n                }}\n              >\n                <span className=\"cm-mention-popup__name\">@{firstNameSlug(c.name)}</span>\n                <span className=\"cm-mention-popup__email\">{c.email}</span>\n              </li>\n            );\n          })}\n        </ul>\n      ) : null}\n    </div>\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// CommentPin — single 24×24 badge anchored to top-right of its target element.\n// Resolves target on every animation frame to track layout shifts (drag,\n// reflow, font load). Falls back to the stored `bounds` when the target is\n// gone from the DOM.\n\nfunction CommentPin({\n  comment,\n  sequence,\n  focused,\n  onClick,\n}: {\n  comment: OverlayComment;\n  sequence: number;\n  focused: boolean;\n  onClick: (id: string) => void;\n}) {\n  const ref = useRef<HTMLButtonElement | null>(null);\n  const rafRef = useRef<number | null>(null);\n\n  useEffect(() => {\n    const tick = () => {\n      rafRef.current = null;\n      const pin = ref.current;\n      if (!pin) return;\n\n      // Live screen-coord lookup mirrors SelectionHalos in canvas-shell.tsx.\n      // Falls back to stored bounds (a screen-coord capture at create time)\n      // when the target element is gone — better than vanishing entirely.\n      let pos = screenRectFor(comment.selector, comment.index);\n      if (!pos && comment.bounds) {\n        pos = {\n          x: comment.bounds.x,\n          y: comment.bounds.y,\n          w: comment.bounds.w,\n          h: comment.bounds.h,\n        };\n      }\n      if (!pos) {\n        pin.style.display = 'none';\n        rafRef.current = requestAnimationFrame(tick);\n        return;\n      }\n      pin.style.display = 'grid';\n      // Position the pin's center at (right - 12, top - 12) — the FigJam\n      // convention. 12 = half of 24 (the pin's own size).\n      const left = Math.round(pos.x + pos.w - 12);\n      const top = Math.round(pos.y - 12);\n      pin.style.left = `${left}px`;\n      pin.style.top = `${top}px`;\n      rafRef.current = requestAnimationFrame(tick);\n    };\n    rafRef.current = requestAnimationFrame(tick);\n    return () => {\n      if (rafRef.current != null) cancelAnimationFrame(rafRef.current);\n    };\n  }, [comment.selector, comment.bounds, comment.index]);\n\n  const author = comment.author?.trim() || 'unknown';\n  const label = `Comment ${sequence} by ${author}`;\n\n  return (\n    <button\n      ref={ref}\n      type=\"button\"\n      className=\"cm-pin\"\n      data-resolved={comment.status === 'resolved' ? 'true' : 'false'}\n      data-focused={focused ? 'true' : 'false'}\n      data-comment-pin={comment.id}\n      aria-label={label}\n      aria-expanded={focused}\n      title={comment.text.slice(0, 200)}\n      onClick={(e) => {\n        e.preventDefault();\n        e.stopPropagation();\n        onClick(comment.id);\n      }}\n    >\n      {sequence}\n    </button>\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// CommentComposer — DS-styled card anchored just under the clicked element\n// (or at the click point if the click hit empty canvas). Edge-clamp is the\n// pragmatic kind: position is computed once on open against the world layout,\n// not chased on pan/zoom — the user is actively typing.\n\nfunction CommentComposer({\n  state,\n  onSubmit,\n  onCancel,\n}: {\n  state: ComposerState;\n  onSubmit: (text: string) => void;\n  onCancel: () => void;\n}) {\n  const [text, setText] = useState('');\n  const textareaRef = useRef<HTMLTextAreaElement | null>(null);\n  const cardRef = useRef<HTMLDivElement | null>(null);\n  const rafRef = useRef<number | null>(null);\n\n  // Live anchor — composer tracks the target element via rAF so pan/zoom\n  // while typing keeps the card glued to its anchor. Writes directly to the\n  // DOM so we don't re-render every frame.\n  useEffect(() => {\n    const tick = () => {\n      rafRef.current = null;\n      const node = cardRef.current;\n      if (!node) return;\n      const anchor = computeAnchor(state);\n      node.style.left = `${Math.round(anchor.x)}px`;\n      node.style.top = `${Math.round(anchor.y)}px`;\n      rafRef.current = requestAnimationFrame(tick);\n    };\n    rafRef.current = requestAnimationFrame(tick);\n    return () => {\n      if (rafRef.current != null) cancelAnimationFrame(rafRef.current);\n    };\n  }, [state]);\n\n  useEffect(() => {\n    textareaRef.current?.focus();\n  }, []);\n\n  const trySubmit = useCallback(() => {\n    const v = text.trim();\n    if (!v) return;\n    onSubmit(v);\n  }, [text, onSubmit]);\n\n  const onKeyDown = useCallback(\n    (e: React.KeyboardEvent<HTMLTextAreaElement>) => {\n      if (e.key === 'Escape') {\n        e.preventDefault();\n        onCancel();\n        return;\n      }\n      if ((e.metaKey || e.ctrlKey) && e.key === 'Enter') {\n        e.preventDefault();\n        trySubmit();\n      }\n    },\n    [onCancel, trySubmit]\n  );\n\n  // Compact selector hint — strip noisy structural bits so the head stays\n  // tight inside the 300px card.\n  const selectorChip = useMemo(() => {\n    const s = state.selection.selector || '';\n    if (!s) return state.selection.tag || 'canvas';\n    // [data-cd-id=\"…\"] → cd:<id> · keeps the chip readable when stable ids\n    // are present.\n    const cd = s.match(/data-cd-id=\"([^\"]+)\"/);\n    if (cd) return `cd:${cd[1]}`;\n    return s.length > 36 ? `${s.slice(0, 33)}…` : s;\n  }, [state.selection]);\n\n  return (\n    <div\n      ref={cardRef}\n      className=\"cm-composer\"\n      role=\"dialog\"\n      aria-label=\"New comment\"\n      onClick={(e) => e.stopPropagation()}\n      onPointerDown={(e) => e.stopPropagation()}\n    >\n      <div className=\"cm-composer__head\">\n        <span>New comment</span>\n        <span className=\"cm-composer__selector\">{selectorChip}</span>\n      </div>\n      <MentionAwareTextarea\n        textareaRef={textareaRef}\n        className=\"cm-composer__textarea\"\n        value={text}\n        placeholder=\"Type a comment. ⌘↵ to save · Esc to cancel · @name to tag\"\n        onChange={setText}\n        onKeyDown={onKeyDown}\n        rows={3}\n        ariaLabel=\"Comment body\"\n      />\n      <div className=\"cm-composer__actions\">\n        <button type=\"button\" className=\"cm-btn\" onClick={onCancel}>\n          Cancel\n        </button>\n        <button\n          type=\"button\"\n          className=\"cm-btn cm-btn--primary\"\n          disabled={!text.trim()}\n          onClick={trySubmit}\n        >\n          Save\n        </button>\n      </div>\n    </div>\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// CommentThread — popover anchored to the focused pin. Shows author + relative\n// time + selector chip, the original body with @mentions bolded, replies, a\n// reply textarea, and resolve/reopen/delete actions. Patches + deletes route\n// through the shell's existing WS channel via postMessage; replies POST\n// directly to `/_api/comments/<id>/reply` because that endpoint exists only on\n// Bun runtime and lives in `http.ts`.\n\nfunction CommentThread({\n  comment,\n  sequence,\n  onClose,\n  onPatch,\n  onDelete,\n  onReply,\n}: {\n  comment: OverlayComment;\n  sequence: number;\n  onClose: () => void;\n  onPatch: (patch: Record<string, unknown>) => void;\n  onDelete: () => void;\n  onReply: (body: string) => Promise<boolean>;\n}) {\n  const dialogRef = useRef<HTMLDivElement | null>(null);\n  const replyRef = useRef<HTMLTextAreaElement | null>(null);\n  const rafRef = useRef<number | null>(null);\n  const [reply, setReply] = useState('');\n  const [sending, setSending] = useState(false);\n\n  // Live anchor — popover tracks the pin via rAF so it stays glued to its\n  // target through pan / zoom (FigJam parity). Writing to the dialog style\n  // directly avoids re-rendering every frame.\n  useEffect(() => {\n    const tick = () => {\n      rafRef.current = null;\n      const node = dialogRef.current;\n      if (!node) return;\n      const anchor = computeThreadAnchor(comment);\n      node.style.left = `${Math.round(anchor.x)}px`;\n      node.style.top = `${Math.round(anchor.y)}px`;\n      rafRef.current = requestAnimationFrame(tick);\n    };\n    rafRef.current = requestAnimationFrame(tick);\n    return () => {\n      if (rafRef.current != null) cancelAnimationFrame(rafRef.current);\n    };\n  }, [comment]);\n\n  useEffect(() => {\n    // Move focus into the dialog on open. Per WCAG 2.1 the dialog should own\n    // initial focus; we put it on the dialog root (focusable via tabindex)\n    // so screen readers announce the header before the body. On close,\n    // return focus to the pin so keyboard users land where they started.\n    dialogRef.current?.focus();\n    const pinId = comment.id;\n    return () => {\n      const pin = document.querySelector<HTMLButtonElement>(`[data-comment-pin=\"${pinId}\"]`);\n      pin?.focus();\n    };\n  }, [comment.id]);\n\n  // Esc-to-close while focus is anywhere inside the popover.\n  useEffect(() => {\n    if (typeof document === 'undefined') return;\n    const onKey = (e: KeyboardEvent) => {\n      if (e.key !== 'Escape') return;\n      const root = dialogRef.current;\n      if (!root) return;\n      if (root.contains(e.target as Node) || document.activeElement === root) {\n        e.preventDefault();\n        onClose();\n      }\n    };\n    document.addEventListener('keydown', onKey);\n    return () => document.removeEventListener('keydown', onKey);\n  }, [onClose]);\n\n  const trySendReply = useCallback(async () => {\n    const v = reply.trim();\n    if (!v || sending) return;\n    setSending(true);\n    const ok = await onReply(v);\n    setSending(false);\n    if (ok) {\n      setReply('');\n      replyRef.current?.focus();\n    }\n  }, [reply, sending, onReply]);\n\n  const onReplyKeyDown = useCallback(\n    (e: React.KeyboardEvent<HTMLTextAreaElement>) => {\n      if ((e.metaKey || e.ctrlKey) && e.key === 'Enter') {\n        e.preventDefault();\n        void trySendReply();\n      }\n    },\n    [trySendReply]\n  );\n\n  const headId = `cm-thread-head-${comment.id}`;\n  const selectorChip = formatSelectorChip(comment.selector, '');\n\n  return (\n    <div\n      ref={dialogRef}\n      className=\"cm-thread\"\n      role=\"dialog\"\n      aria-labelledby={headId}\n      tabIndex={-1}\n      onClick={(e) => e.stopPropagation()}\n      onPointerDown={(e) => e.stopPropagation()}\n    >\n      <div className=\"cm-thread__head\" id={headId}>\n        <div className=\"cm-thread__head-row\">\n          {/* Plan C P18 — pin/sequence badge in the popover header (parity with\n              `.design/ui/Studio.tsx` thread popover). */}\n          <span className=\"cm-thread__seq\" aria-hidden=\"true\">\n            {sequence}\n          </span>\n          <span className=\"cm-thread__author\">{comment.author?.trim() || 'unknown'}</span>\n          <span className=\"cm-thread__time\">{formatRelativeTime(comment.created)}</span>\n          <button\n            type=\"button\"\n            className=\"cm-thread__close\"\n            aria-label=\"Close thread\"\n            title=\"Close · Esc\"\n            onClick={onClose}\n          >\n            ×\n          </button>\n        </div>\n        {selectorChip ? <code className=\"cm-thread__selector\">{selectorChip}</code> : null}\n      </div>\n\n      <div className=\"cm-thread__body\">{renderBodyWithMentions(comment.text)}</div>\n\n      {(comment.thread ?? []).map((r) => (\n        <div className=\"cm-thread__reply\" key={r.id}>\n          <div className=\"cm-thread__reply-head\">\n            <span className=\"cm-thread__reply-author\">{r.author?.trim() || 'unknown'}</span>\n            <span className=\"cm-thread__reply-time\">{formatRelativeTime(r.created)}</span>\n          </div>\n          <div className=\"cm-thread__reply-body\">{renderBodyWithMentions(r.body)}</div>\n        </div>\n      ))}\n\n      <div className=\"cm-thread__reply-form\">\n        <MentionAwareTextarea\n          textareaRef={replyRef}\n          className=\"cm-thread__reply-textarea\"\n          value={reply}\n          placeholder=\"Reply… ⌘↵ to send · @name to tag\"\n          onChange={setReply}\n          onKeyDown={onReplyKeyDown}\n          rows={2}\n          ariaLabel=\"Reply\"\n          disabled={sending}\n        />\n        <div className=\"cm-thread__reply-actions\">\n          <button\n            type=\"button\"\n            className=\"cm-btn cm-btn--primary\"\n            disabled={!reply.trim() || sending}\n            onClick={() => void trySendReply()}\n          >\n            Send\n          </button>\n        </div>\n      </div>\n\n      <div className=\"cm-thread__actions\">\n        {comment.status === 'resolved' ? (\n          <button type=\"button\" className=\"cm-btn\" onClick={() => onPatch({ status: 'open' })}>\n            ↺ Reopen\n          </button>\n        ) : (\n          <button\n            type=\"button\"\n            className=\"cm-btn cm-btn--primary\"\n            onClick={() => {\n              onPatch({ status: 'resolved' });\n              onClose();\n            }}\n          >\n            ✓ Resolve\n          </button>\n        )}\n        <button\n          type=\"button\"\n          className=\"cm-btn cm-btn--danger\"\n          onClick={() => {\n            onDelete();\n            onClose();\n          }}\n        >\n          Delete\n        </button>\n      </div>\n    </div>\n  );\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Body renderer — splits text on @-handles, wraps each in <strong>. Anything\n// not matching the mention regex stays plain text (newlines preserved by CSS\n// `white-space: pre-wrap`).\n\nfunction renderBodyWithMentions(text: string): React.ReactNode {\n  if (!text) return null;\n  const re = /(@[\\w][\\w.-]*)/g;\n  const parts = text.split(re);\n  return parts.map((part, i) => {\n    // The split positions ARE the identity here — for the same `text` input,\n    // index `i` always maps to the same fragment. Compose key from index +\n    // content so biome's array-index-key heuristic is satisfied AND reorder\n    // resistance is intact if `text` mutates mid-render.\n    const key = `${i}:${part}`;\n    if (i % 2 === 1) {\n      // Odd parts are the captured @handles thanks to the parenthesized split.\n      return (\n        <strong key={key} data-mention=\"true\">\n          {part}\n        </strong>\n      );\n    }\n    return <span key={key}>{part}</span>;\n  });\n}\n\nfunction formatRelativeTime(iso: string): string {\n  if (!iso) return '';\n  const t = Date.parse(iso);\n  if (!Number.isFinite(t)) return '';\n  const diffSec = Math.round((Date.now() - t) / 1000);\n  if (diffSec < 60) return `${Math.max(diffSec, 0)}s ago`;\n  if (diffSec < 3600) return `${Math.round(diffSec / 60)}m ago`;\n  if (diffSec < 86_400) return `${Math.round(diffSec / 3600)}h ago`;\n  return `${Math.round(diffSec / 86_400)}d ago`;\n}\n\nfunction formatSelectorChip(selector: string, fallback: string): string {\n  if (!selector) return fallback;\n  const cd = selector.match(/data-cd-id=\"([^\"]+)\"/);\n  if (cd) return `cd:${cd[1]}`;\n  return selector.length > 36 ? `${selector.slice(0, 33)}…` : selector;\n}\n\nfunction computeThreadAnchor(comment: OverlayComment): { x: number; y: number } {\n  // Resolve target's live screen rect; popover drops below the pin with small\n  // breathing room. Stored bounds (capture-time screen coords) are the\n  // last-resort fallback for orphaned pins.\n  const rect = comment.selector ? screenRectFor(comment.selector, comment.index) : null;\n  if (rect) {\n    // Pin sits at (rect.right - 12, rect.top - 12). Place popover at the same\n    // x for visual continuity, 16px below the top so it clears the pin.\n    return { x: rect.x + rect.w - 12, y: rect.y + 16 };\n  }\n  if (comment.bounds) {\n    return { x: comment.bounds.x + comment.bounds.w - 12, y: comment.bounds.y + 16 };\n  }\n  return { x: 16, y: 16 };\n}\n\nfunction computeAnchor(state: ComposerState): { x: number; y: number } {\n  // G4 — anchor to the cursor click point first. Earlier versions anchored to\n  // the selected element's bottom-left, which landed the composer flush in\n  // the corner regardless of where the user clicked — surprising for the\n  // common case of \"I clicked the middle of an element, expecting the\n  // composer to appear near my cursor\". The element-rect path remains as a\n  // fallback for entry points that don't carry a cursor (e.g. opening the\n  // composer from a contextual toolbar button — those should set clientX/Y\n  // to a sensible anchor before dispatching).\n  if (state.clientX || state.clientY) {\n    return { x: state.clientX, y: state.clientY + 8 };\n  }\n  if (state.selection.selector) {\n    const rect = screenRectFor(state.selection.selector, state.selection.index);\n    if (rect) {\n      return { x: rect.x, y: rect.y + rect.h + 8 };\n    }\n  }\n  return { x: 16, y: 16 };\n}\n",
    "/**\n * @file       use-collab.tsx — client-side Yjs collab provider for canvas iframes\n * @scope      apps/studio/use-collab.tsx\n * @purpose    Mounts a single Y.Doc + Awareness per canvas iframe. Opens a\n *             WebSocket to `/_ws/collab/:slug`, speaks the y-websocket binary\n *             protocol, exposes hooks for the cursor overlay + Task 3 comments\n *             binding.\n *\n * Boundary:\n *   - Server-side equivalent is `collab/protocol.ts` + `collab/room.ts`.\n *   - This file mirrors the message framing (varint-prefixed sync + awareness\n *     frames) so the two sides converge over a binary WS without intermediate\n *     JSON.\n *   - Imports `yjs` + `y-protocols/{sync,awareness}` via the canvas-shell\n *     importmap (RUNTIME_PACKAGES additions). Canvas bundles that don't mount\n *     <CollabProvider> never resolve these specifiers and pay zero bundle cost.\n */\n\nimport * as decoding from 'lib0/decoding';\nimport * as encoding from 'lib0/encoding';\nimport {\n  createContext,\n  type ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { Awareness, applyAwarenessUpdate, encodeAwarenessUpdate } from 'y-protocols/awareness';\nimport { readSyncMessage, writeSyncStep1, writeUpdate } from 'y-protocols/sync';\nimport * as Y from 'yjs';\n\nconst MESSAGE_SYNC = 0;\nconst MESSAGE_AWARENESS = 1;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Color hash — stable per peer identity.\n\n/**\n * djb2 string hash → OKLCH color in a curated palette. Determinism per\n * input name is the load-bearing property: every peer hashing \"Alice\" must\n * land on the SAME color.\n *\n * DS contract (colors-presence specimen): the AI agent rides\n * `--presence-agent` (violet-magenta, hue 322) — \"a hue no human state uses,\n * so attribution on a shared canvas is unambiguous\". Human hues therefore\n * EXCLUDE the agent band (~292–352) AND the accent indigo band (~245–290,\n * reserved for selection/active). L/C match the DS presence tokens\n * (oklch ≈0.74 0.16) so every cursor reads at the same weight on both themes.\n */\nconst COLOR_PALETTE = [\n  'oklch(0.70 0.17 12)', // rose\n  'oklch(0.72 0.16 40)', // coral\n  'oklch(0.78 0.15 78)', // amber  (presence-away hue)\n  'oklch(0.76 0.16 108)', // lime\n  'oklch(0.74 0.16 145)', // green  (presence-online hue)\n  'oklch(0.75 0.14 172)', // teal\n  'oklch(0.73 0.13 200)', // cyan\n  'oklch(0.72 0.13 238)', // blue   (status-info hue)\n] as const;\n\n/** The AI agent's exclusive cursor/avatar hue — `--presence-agent`. */\nexport const AGENT_COLOR = 'oklch(0.700 0.190 322)';\n\nexport function colorForName(name: string): string {\n  // COLOR_PALETTE is a non-empty const tuple; the explicit `?? '#000'`\n  // fallback is unreachable but satisfies `noUncheckedIndexedAccess`.\n  const FALLBACK = '#000000';\n  if (!name) return COLOR_PALETTE[0] ?? FALLBACK;\n  let hash = 5381;\n  for (let i = 0; i < name.length; i++) {\n    hash = ((hash << 5) + hash + name.charCodeAt(i)) | 0;\n  }\n  const idx = ((hash % COLOR_PALETTE.length) + COLOR_PALETTE.length) % COLOR_PALETTE.length;\n  return COLOR_PALETTE[idx] ?? FALLBACK;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Awareness state shape.\n\nexport interface CollabAwarenessState {\n  name: string;\n  color: string;\n  /**\n   * Cursor position in **world coords** (canvas-lib viewport space) so foreign\n   * peers see the same conceptual point even when their local viewport is\n   * panned/zoomed differently. Null = peer is not over the canvas surface.\n   */\n  cursor: { x: number; y: number } | null;\n  /**\n   * Most-recently selected element. `cssPath` is the locator id chain the\n   * canvas-shell already uses; `bounds` are screen-px rect at the moment of\n   * publish (so it's a hint, not a live ref). Null when nothing selected.\n   */\n  selection: { cssPath: string; bounds: { x: number; y: number; w: number; h: number } } | null;\n  /**\n   * Currently-selected annotation stroke IDs (Phase 5). Strokes are addressed\n   * by their stable `data-id` attribute, so peers can resolve halos via\n   * `document.querySelectorAll('[data-id=\"<id>\"]')`. Empty when nothing\n   * annotation-shaped is selected.\n   */\n  annotationSelection: string[];\n  viewport: { x: number; y: number; zoom: number };\n  /**\n   * Server-side `disconnect` matches awareness states to outgoing peers by\n   * this token (must equal the ws.data.id the server assigns at upgrade).\n   * Until the server pushes the assigned id back to the client, we use a\n   * client-generated UUID — collisions are negligible and disconnect cleanup\n   * tolerates a stale state (the next awareness GC pass drops it).\n   */\n  __connId: string;\n}\n\nexport type ForeignAwareness = Omit<CollabAwarenessState, '__connId'> & { clientID: number };\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Untrusted-input sanitization at the awareness trust boundary.\n//\n// Phase 8 awareness was loopback-only — every state came from a trusted local\n// tab. Phase 9 (Task 5) bridges awareness through a SEMI-TRUSTED hub (DDR-054),\n// so foreign states are now attacker-influenceable. `useForeignAwareness` is\n// the single chokepoint where remote state is read before it reaches the\n// cursor / participant render sinks, so all validation lives here. Fields are\n// validated for VALUE, not just type:\n//   - color: re-derived locally from the (sanitized) name and the wire value\n//     is DISCARDED — a hub-chosen `color` string would otherwise flow into an\n//     inline `style` and a `url(...)` value beacons every viewer's browser.\n//     The palette is deterministic, so re-derivation is visually identical.\n//   - name: control / bidi / zero-width chars stripped, length-capped — blocks\n//     identity spoofing + render bloat.\n//   - cursor / viewport: finite-number gated — a NaN/Infinity would poison the\n//     CSS transform / the local viewport controller during Follow mode.\n//   - selection.cssPath: charset + length allowlist before it reaches\n//     `querySelector` — blocks selector-complexity DoS + arbitrary DOM probing.\n//   - annotationSelection: per-id token + array-length capped — blocks a\n//     querySelector render-storm.\n//   - peer count capped — blocks an unbounded-clients memory/render DoS.\n\nconst MAX_FOREIGN_PEERS = 64;\nconst MAX_NAME_LEN = 64;\nconst MAX_CSSPATH_LEN = 512;\nconst MAX_ANNOTATION_IDS = 256;\nconst MAX_ANNOTATION_ID_LEN = 128;\n\n// Charset of every selector the canvas-shell `cssPath()` emits\n// (`[data-*=\"...\"]`, `#id`, `tag.cls:nth-child(N)`, ` > ` combinators).\nconst CSSPATH_ALLOWED = /^[A-Za-z0-9 ._#>:[\\]=\"'()-]+$/;\n// `cssPath()` only ever emits `:nth-child(N)` as a parenthesised construct.\n// Functional pseudo-classes (`:has()`, `:is()`, `:where()`, `:not()`) trigger\n// per-render subtree walks → a malicious hub peer could publish a deeply\n// nested `:has()` selector and pin every viewer's main thread (querySelector\n// re-runs each render). So after stripping the legit `:nth-child/of-type(N)`\n// forms, any residual paren means a functional pseudo — reject. The charset\n// allowlist alone was wider than the generator (the original DoS hole).\nconst CSSPATH_NTH = /:nth-(child|of-type)\\(\\d{1,4}\\)/g;\nconst ANNOTATION_ID_ALLOWED = /^[A-Za-z0-9._:-]+$/;\n\nfunction isSafeCssPath(p: string): boolean {\n  if (p.length > MAX_CSSPATH_LEN || !CSSPATH_ALLOWED.test(p)) return false;\n  const stripped = p.replace(CSSPATH_NTH, '');\n  return !stripped.includes('(') && !stripped.includes(')');\n}\n\nfunction isFiniteNum(v: unknown): v is number {\n  return typeof v === 'number' && Number.isFinite(v);\n}\n\n// Control (C0/C1), zero-width, and bidi-override code points get stripped from\n// displayed strings so a remote peer can't spoof another's identity or hide\n// payloads in labels. A charCode scan (not a regex literal with raw control\n// chars) sidesteps biome's noControlCharactersInRegex while keeping the same\n// semantics — same approach as the hub's sanitizeForLog (DDR-053).\nfunction isUnsafeCodePoint(cp: number): boolean {\n  return (\n    cp <= 0x1f ||\n    (cp >= 0x7f && cp <= 0x9f) ||\n    (cp >= 0x200b && cp <= 0x200f) ||\n    (cp >= 0x202a && cp <= 0x202e) ||\n    (cp >= 0x2066 && cp <= 0x2069) ||\n    cp === 0xfeff\n  );\n}\n\nfunction sanitizeName(raw: unknown): string {\n  if (typeof raw !== 'string') return 'anonymous';\n  let cleaned = '';\n  for (const ch of raw) {\n    if (!isUnsafeCodePoint(ch.codePointAt(0) ?? 0)) cleaned += ch;\n  }\n  cleaned = cleaned.trim().slice(0, MAX_NAME_LEN);\n  return cleaned || 'anonymous';\n}\n\nfunction sanitizeCursor(raw: unknown): { x: number; y: number } | null {\n  if (!raw || typeof raw !== 'object') return null;\n  const c = raw as { x?: unknown; y?: unknown };\n  return isFiniteNum(c.x) && isFiniteNum(c.y) ? { x: c.x, y: c.y } : null;\n}\n\nfunction sanitizeViewport(raw: unknown): { x: number; y: number; zoom: number } {\n  const fallback = { x: 0, y: 0, zoom: 1 };\n  if (!raw || typeof raw !== 'object') return fallback;\n  const v = raw as { x?: unknown; y?: unknown; zoom?: unknown };\n  if (!isFiniteNum(v.x) || !isFiniteNum(v.y) || !isFiniteNum(v.zoom) || v.zoom <= 0)\n    return fallback;\n  return { x: v.x, y: v.y, zoom: v.zoom };\n}\n\nfunction sanitizeSelection(raw: unknown): CollabAwarenessState['selection'] {\n  if (!raw || typeof raw !== 'object') return null;\n  const s = raw as { cssPath?: unknown; bounds?: unknown };\n  const b = s.bounds as { x?: unknown; y?: unknown; w?: unknown; h?: unknown } | undefined;\n  const bounds =\n    b && isFiniteNum(b.x) && isFiniteNum(b.y) && isFiniteNum(b.w) && isFiniteNum(b.h)\n      ? { x: b.x, y: b.y, w: b.w, h: b.h }\n      : null;\n  // Only keep cssPath if it matches the locator grammar — otherwise drop it and\n  // let the renderer fall back to the (validated) bounds.\n  const cssPath = typeof s.cssPath === 'string' && isSafeCssPath(s.cssPath) ? s.cssPath : '';\n  if (!cssPath && !bounds) return null;\n  return { cssPath, bounds: bounds ?? { x: 0, y: 0, w: 0, h: 0 } };\n}\n\nfunction sanitizeAnnotationSelection(raw: unknown): string[] {\n  if (!Array.isArray(raw)) return [];\n  const out: string[] = [];\n  for (const id of raw) {\n    if (out.length >= MAX_ANNOTATION_IDS) break;\n    if (\n      typeof id === 'string' &&\n      id.length <= MAX_ANNOTATION_ID_LEN &&\n      ANNOTATION_ID_ALLOWED.test(id)\n    )\n      out.push(id);\n  }\n  return out;\n}\n\n/**\n * Validate + normalize one foreign awareness state at the trust boundary.\n * Returns null for states that can't be a peer (no usable name). `color` is\n * always re-derived locally from the sanitized name — the wire value is never\n * trusted, which is what closes the hub CSS-`url()` exfil channel. Exported so\n * the hostile-input matrix can exercise it without a React harness.\n */\nexport function sanitizeForeignState(clientID: number, state: unknown): ForeignAwareness | null {\n  if (!state || typeof state !== 'object') return null;\n  const s = state as Partial<CollabAwarenessState>;\n  if (typeof s.name !== 'string') return null;\n  const name = sanitizeName(s.name);\n  return {\n    clientID,\n    name,\n    color: colorForName(name),\n    cursor: sanitizeCursor(s.cursor),\n    selection: sanitizeSelection(s.selection),\n    annotationSelection: sanitizeAnnotationSelection(s.annotationSelection),\n    viewport: sanitizeViewport(s.viewport),\n  };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Context.\n\ninterface CollabValue {\n  doc: Y.Doc;\n  /**\n   * SECURITY INVARIANT: in linked mode this Awareness carries states relayed\n   * from a SEMI-TRUSTED hub (DDR-054). Foreign states are untrusted input —\n   * read them ONLY through `useForeignAwareness`, which sanitizes every field\n   * at the trust boundary (`sanitizeForeignState`). Do NOT call\n   * `awareness.getStates()` directly in render code; that bypasses the gate.\n   */\n  awareness: Awareness;\n  /** Local peer's session-stable color (derived from git user.name). */\n  myColor: string;\n  /** Local peer's display name (git user.name or anonymous fallback). */\n  myName: string;\n  /** Local peer's connection id (matches server-side ws.data.id pattern). */\n  myConnId: string;\n  /** True when the WS is OPEN. Cursor overlay can use this to gate rendering. */\n  connected: boolean;\n  /** Publish (debounce-coalesced) an updated local awareness state. */\n  publishAwareness: (patch: Partial<Omit<CollabAwarenessState, '__connId'>>) => void;\n}\n\nconst CollabContext = createContext<CollabValue | null>(null);\n\nexport function useCollab(): CollabValue | null {\n  return useContext(CollabContext);\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Hook: foreign awareness peers (the cursor overlay subscribes to this).\n\n/**\n * Returns the current set of foreign peers (excludes the local client). The\n * returned array is stable-reference between awareness updates — useful for\n * downstream React.memo cursor components.\n */\nexport function useForeignAwareness(): ForeignAwareness[] {\n  const collab = useCollab();\n  const [peers, setPeers] = useState<ForeignAwareness[]>([]);\n\n  useEffect(() => {\n    if (!collab) {\n      setPeers([]);\n      return;\n    }\n    const { awareness } = collab;\n    function compute(): ForeignAwareness[] {\n      const out: ForeignAwareness[] = [];\n      const myId = awareness.clientID;\n      for (const [clientID, state] of awareness.getStates() as Map<number, unknown>) {\n        if (clientID === myId) continue;\n        if (out.length >= MAX_FOREIGN_PEERS) break; // bound DoS via unbounded peers\n        // Sanitize every now-remote field at this trust boundary (Task 5).\n        const peer = sanitizeForeignState(clientID, state);\n        if (peer) out.push(peer);\n      }\n      return out;\n    }\n    setPeers(compute());\n    const onChange = () => setPeers(compute());\n    awareness.on('change', onChange);\n    return () => {\n      awareness.off('change', onChange);\n    };\n  }, [collab]);\n\n  return peers;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Slug derivation — must match `api.fileSlug` server-side.\n\n/**\n * Mirror of server-side `api.fileSlug`. The input is the canvas path as the\n * shell stored it on `window.__canvas_meta_file__` (e.g. `.design/ui/Foo.tsx`).\n * Strip the designRel prefix (read from `window.__canvas_design_rel__`, set\n * by _shell.html) so both sides land on the same slug — without this both\n * tabs open a `design-ui-foo` room while the server's inspector bridge\n * pushes into `ui-foo`, and the rooms never converge.\n */\nexport function canvasSlugFromPath(canvasRel: string | null | undefined): string | null {\n  if (!canvasRel) return null;\n  let p = canvasRel.replace(/^\\/+|\\/+$/g, '');\n  if (typeof window !== 'undefined') {\n    const w = window as unknown as { __canvas_design_rel__?: string };\n    const designRel = (w.__canvas_design_rel__ ?? '').replace(/^\\/+|\\/+$/g, '');\n    if (designRel && p.startsWith(`${designRel}/`)) p = p.slice(designRel.length + 1);\n  }\n  const slug = p\n    .replace(/\\//g, '-')\n    .replace(/\\s+/g, '_')\n    .replace(/\\.(tsx|html)$/i, '')\n    .replace(/^\\.+/, '')\n    .toLowerCase();\n  return /^[a-z0-9_-]+$/.test(slug) ? slug : null;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Provider — opens WS, owns Y.Doc + Awareness lifecycle.\n\ninterface CollabProviderProps {\n  /** Canvas slug — must match server-side `parseCollabSlug`. */\n  slug: string;\n  children: ReactNode;\n}\n\nconst AWARENESS_THROTTLE_MS = 33; // ~30 Hz\n\nexport function CollabProvider({ slug, children }: CollabProviderProps): JSX.Element {\n  // Y.Doc + Awareness are recreated whenever the slug changes (switching\n  // canvases tears down the prior session cleanly). The useMemo factory\n  // bodies don't read `slug` — slug IS the cache key, intentionally.\n  // biome-ignore lint/correctness/useExhaustiveDependencies: slug is the cache key\n  const doc = useMemo(() => new Y.Doc(), [slug]);\n  const awareness = useMemo(() => new Awareness(doc), [doc]);\n  // biome-ignore lint/correctness/useExhaustiveDependencies: slug is the cache key\n  const myConnId = useMemo(() => crypto.randomUUID(), [slug]);\n\n  const [myName, setMyName] = useState('anonymous');\n  const [myColor, setMyColor] = useState(colorForName('anonymous'));\n  const [connected, setConnected] = useState(false);\n\n  // Fetch git user.name once per slug; falls back to anonymous-<short id>.\n  useEffect(() => {\n    let cancelled = false;\n    fetch('/_api/git-user')\n      .then((r) => r.json())\n      .then((j) => {\n        if (cancelled) return;\n        const n = typeof j?.name === 'string' && j.name.trim() ? j.name.trim() : null;\n        const finalName = n ?? `anonymous-${myConnId.slice(0, 6)}`;\n        setMyName(finalName);\n        setMyColor(colorForName(finalName));\n      })\n      .catch(() => {\n        if (cancelled) return;\n        const fallback = `anonymous-${myConnId.slice(0, 6)}`;\n        setMyName(fallback);\n        setMyColor(colorForName(fallback));\n      });\n    return () => {\n      cancelled = true;\n    };\n  }, [myConnId]);\n\n  // Seed local awareness state immediately so foreign peers see our name even\n  // before the cursor moves. Update when myName/myColor settles from the fetch.\n  useEffect(() => {\n    awareness.setLocalState({\n      name: myName,\n      color: myColor,\n      cursor: null,\n      selection: null,\n      annotationSelection: [],\n      viewport: { x: 0, y: 0, zoom: 1 },\n      __connId: myConnId,\n    } satisfies CollabAwarenessState);\n  }, [awareness, myName, myColor, myConnId]);\n\n  // ── WebSocket lifecycle ──────────────────────────────────────────────────\n  const wsRef = useRef<WebSocket | null>(null);\n\n  useEffect(() => {\n    let cancelled = false;\n    let reconnectTimer: ReturnType<typeof setTimeout> | null = null;\n\n    function sendFrame(ws: WebSocket, payload: Uint8Array) {\n      try {\n        ws.send(payload);\n      } catch {\n        /* dead socket — close handler will reconnect */\n      }\n    }\n\n    function broadcastAwareness(ws: WebSocket, changed: number[]) {\n      if (changed.length === 0) return;\n      const encoder = encoding.createEncoder();\n      encoding.writeVarUint(encoder, MESSAGE_AWARENESS);\n      encoding.writeVarUint8Array(encoder, encodeAwarenessUpdate(awareness, changed));\n      sendFrame(ws, encoding.toUint8Array(encoder));\n    }\n\n    function broadcastSyncUpdate(ws: WebSocket, update: Uint8Array) {\n      const encoder = encoding.createEncoder();\n      encoding.writeVarUint(encoder, MESSAGE_SYNC);\n      writeUpdate(encoder, update);\n      sendFrame(ws, encoding.toUint8Array(encoder));\n    }\n\n    function connect() {\n      if (cancelled) return;\n      const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';\n      const ws = new WebSocket(`${proto}//${location.host}/_ws/collab/${slug}`);\n      ws.binaryType = 'arraybuffer';\n      wsRef.current = ws;\n\n      ws.addEventListener('open', () => {\n        setConnected(true);\n        // Sync step 1 — announce our state vector so the server can send the\n        // missing pieces (matches the encodeHandshake server path).\n        const encoder = encoding.createEncoder();\n        encoding.writeVarUint(encoder, MESSAGE_SYNC);\n        writeSyncStep1(encoder, doc);\n        sendFrame(ws, encoding.toUint8Array(encoder));\n        // Awareness initial state — fire our local state to the room.\n        broadcastAwareness(ws, [awareness.clientID]);\n      });\n\n      ws.addEventListener('close', () => {\n        setConnected(false);\n        wsRef.current = null;\n        if (cancelled) return;\n        reconnectTimer = setTimeout(connect, 1000);\n      });\n\n      ws.addEventListener('error', () => {\n        // Let close handler do the reconnect; error events without a close\n        // would just retry-spam.\n      });\n\n      ws.addEventListener('message', (evt) => {\n        const payload =\n          evt.data instanceof ArrayBuffer\n            ? new Uint8Array(evt.data)\n            : evt.data instanceof Uint8Array\n              ? evt.data\n              : null;\n        if (!payload) return;\n        const decoder = decoding.createDecoder(payload);\n        const messageType = decoding.readVarUint(decoder);\n        switch (messageType) {\n          case MESSAGE_SYNC: {\n            const encoder = encoding.createEncoder();\n            encoding.writeVarUint(encoder, MESSAGE_SYNC);\n            readSyncMessage(decoder, encoder, doc, ws);\n            if (encoding.length(encoder) > 1) sendFrame(ws, encoding.toUint8Array(encoder));\n            break;\n          }\n          case MESSAGE_AWARENESS: {\n            applyAwarenessUpdate(awareness, decoding.readVarUint8Array(decoder), ws);\n            break;\n          }\n          default:\n            break;\n        }\n      });\n    }\n\n    // Wire doc updates → broadcast to server. Origin tagged with the ws ref so\n    // server-side updates we receive don't echo back.\n    const onDocUpdate = (update: Uint8Array, origin: unknown) => {\n      const ws = wsRef.current;\n      if (!ws || ws.readyState !== WebSocket.OPEN) return;\n      if (origin === ws) return; // came from server, don't echo\n      broadcastSyncUpdate(ws, update);\n    };\n    doc.on('update', onDocUpdate);\n\n    // Wire awareness changes → broadcast. Same origin guard.\n    const onAwarenessUpdate = (\n      { added, updated, removed }: { added: number[]; updated: number[]; removed: number[] },\n      origin: unknown\n    ) => {\n      const ws = wsRef.current;\n      if (!ws || ws.readyState !== WebSocket.OPEN) return;\n      if (origin === ws) return;\n      const changed = added.concat(updated, removed);\n      broadcastAwareness(ws, changed);\n    };\n    awareness.on('update', onAwarenessUpdate);\n\n    connect();\n\n    return () => {\n      cancelled = true;\n      if (reconnectTimer) clearTimeout(reconnectTimer);\n      doc.off('update', onDocUpdate);\n      awareness.off('update', onAwarenessUpdate);\n      const ws = wsRef.current;\n      if (ws && ws.readyState === WebSocket.OPEN) {\n        try {\n          ws.close();\n        } catch {\n          /* ignore */\n        }\n      }\n      // Don't destroy doc/awareness here — the useMemo-tied lifetime handles\n      // that when the slug changes.\n    };\n  }, [slug, doc, awareness]);\n\n  // Per-slug cleanup of doc/awareness when slug changes (or provider unmounts).\n  useEffect(\n    () => () => {\n      try {\n        awareness.destroy();\n      } catch {\n        /* ignore */\n      }\n      try {\n        doc.destroy();\n      } catch {\n        /* ignore */\n      }\n    },\n    [doc, awareness]\n  );\n\n  // ── Throttled awareness publish ─────────────────────────────────────────\n  const pendingRef = useRef<Partial<Omit<CollabAwarenessState, '__connId'>> | null>(null);\n  const throttleTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  const publishAwareness = useCallback(\n    (patch: Partial<Omit<CollabAwarenessState, '__connId'>>) => {\n      pendingRef.current = { ...(pendingRef.current ?? {}), ...patch };\n      if (throttleTimerRef.current) return;\n      throttleTimerRef.current = setTimeout(() => {\n        throttleTimerRef.current = null;\n        const next = pendingRef.current;\n        pendingRef.current = null;\n        if (!next) return;\n        const current = (awareness.getLocalState() ?? {}) as Partial<CollabAwarenessState>;\n        awareness.setLocalState({\n          name: current.name ?? myName,\n          color: current.color ?? myColor,\n          cursor: current.cursor ?? null,\n          selection: current.selection ?? null,\n          annotationSelection: current.annotationSelection ?? [],\n          viewport: current.viewport ?? { x: 0, y: 0, zoom: 1 },\n          __connId: myConnId,\n          ...next,\n        } satisfies CollabAwarenessState);\n      }, AWARENESS_THROTTLE_MS);\n    },\n    [awareness, myName, myColor, myConnId]\n  );\n\n  // ── Cleanup throttle timer on unmount ───────────────────────────────────\n  useEffect(\n    () => () => {\n      if (throttleTimerRef.current) clearTimeout(throttleTimerRef.current);\n    },\n    []\n  );\n\n  const value = useMemo<CollabValue>(\n    () => ({\n      doc,\n      awareness,\n      myColor,\n      myName,\n      myConnId,\n      connected,\n      publishAwareness,\n    }),\n    [doc, awareness, myColor, myName, myConnId, connected, publishAwareness]\n  );\n\n  return <CollabContext.Provider value={value}>{children}</CollabContext.Provider>;\n}\n",
    "/**\n * @file       use-selection-set.tsx — Phase 4.1 multi-selection store\n * @scope      apps/studio/use-selection-set.tsx\n * @purpose    Multi-element selection state for canvas-shell. The canvas\n *             input router calls `replace()` / `add()` / `clear()`;\n *             the provider debounces and posts up to the dev-server shell\n *             through the existing `__design_selected` window.parent channel\n *             so `_active.json` reflects the current selection set.\n *\n * Schema migration. `_active.json#selected` historically holds\n *     selected: SelectedElement | null\n * Phase 4.1 widens to\n *     selected: SelectedElement | SelectedElement[] | null\n * Writer: emits a single object when N === 1 (back-compat with downstream\n * tools that still read the legacy shape — `/design:edit`, handoff). Emits an\n * array when N > 1. Reader (this hook on rehydrate) accepts all three.\n */\n\nimport {\n  createContext,\n  type ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Types\n\n/**\n * Minimal Selection shape that travels through the parent postMessage channel.\n * Mirrors `SelectedElement` from inspect.ts but the canvas router computes it\n * client-side and the inspector overlay's enrichment fields (html excerpt,\n * dom_path, classes...) are filled in by the router right before the message\n * is posted.\n */\nexport interface Selection {\n  /** Canvas file path — designRel-prefixed (e.g. `.design/ui/Foo.tsx`). */\n  file?: string;\n  /** Stable `data-cd-id` anchor when present. v2-grade only. */\n  id?: string;\n  /** CSS-selector fallback path (always present). */\n  selector: string;\n  /** Artboard host (`data-dc-screen`) — for scoping multi-edits in future. */\n  artboardId?: string | null;\n  /**\n   * Occurrence index of this element among `querySelectorAll(selector)`.\n   * data-cd-id is stamped per SOURCE element, so a component rendered N times\n   * (a list row, or a reusable used twice) yields N DOM nodes with the SAME\n   * id+artboard selector. The index disambiguates which instance — resolvers\n   * use `querySelectorAll(selector)[index]`. Absent/0 → first match.\n   */\n  index?: number;\n  /** Snapshot fields filled by the router from `resolveHoverTarget`. */\n  tag?: string;\n  classes?: string;\n  text?: string;\n  dom_path?: string[];\n  bounds?: { x: number; y: number; w: number; h: number } | null;\n  html?: string;\n  /** Phase 12.2 — authored inline-style values (knob pre-fill) + resolved computed (placeholder hint). */\n  authored?: Record<string, string>;\n  computed?: Record<string, string>;\n  /** Phase 12.3 — authored inline-style props OUTSIDE the curated knob set, so the\n   *  panel can surface a custom CSS property the user added (e.g. `letter-spacing`). */\n  customStyles?: Record<string, string>;\n  /** Phase 12.3 — custom HTML attributes on the element (data-, aria-, role, title…),\n   *  so the panel reflects a custom attribute the user added via the escape hatch. */\n  attrs?: Record<string, string>;\n}\n\ninterface SelectionSetValue {\n  selected: Selection[];\n  replace: (s: Selection | Selection[]) => void;\n  add: (s: Selection | Selection[]) => void;\n  remove: (s: Selection) => void;\n  toggle: (s: Selection) => void;\n  clear: () => void;\n}\n\nconst SelectionSetContext = createContext<SelectionSetValue | null>(null);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Identity. Prefer `id` (data-cd-id stable anchor); fall back to selector.\n\nfunction selectionKey(s: Selection): string {\n  return s.id ? `id:${s.id}` : `sel:${s.selector}`;\n}\n\nfunction dedupe(list: Selection[]): Selection[] {\n  const out: Selection[] = [];\n  const seen = new Set<string>();\n  for (const s of list) {\n    const k = selectionKey(s);\n    if (seen.has(k)) continue;\n    seen.add(k);\n    out.push(s);\n  }\n  return out;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Provider\n\nconst POST_DEBOUNCE_MS = 50; // mirrors canvas-lib's SETTLE/PUBLISH cadence\n\nexport function SelectionSetProvider({\n  children,\n  /** Override the postMessage destination (used in tests). */\n  postTarget,\n}: {\n  children: ReactNode;\n  postTarget?: { postMessage: (msg: unknown, targetOrigin: string) => void } | null;\n}) {\n  const [selected, setSelected] = useState<Selection[]>([]);\n  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n\n  const post = useCallback(\n    (next: Selection[]) => {\n      if (timerRef.current) clearTimeout(timerRef.current);\n      timerRef.current = setTimeout(() => {\n        timerRef.current = null;\n        const target = postTarget ?? (typeof window !== 'undefined' ? window.parent : null);\n        if (!target) return;\n        // Wire shape: single object for N=1 (back-compat), array for N>1, null for empty.\n        const payload: Selection | Selection[] | null =\n          next.length === 0 ? null : next.length === 1 ? (next[0] ?? null) : next;\n        try {\n          target.postMessage({ dgn: 'select-set', selection: payload }, '*');\n        } catch {\n          /* iframe likely cross-origin or detached */\n        }\n      }, POST_DEBOUNCE_MS);\n    },\n    [postTarget]\n  );\n\n  // Cleanup the debounce timer on unmount.\n  useEffect(\n    () => () => {\n      if (timerRef.current) clearTimeout(timerRef.current);\n    },\n    []\n  );\n\n  const replace = useCallback(\n    (s: Selection | Selection[]) => {\n      const next = dedupe(Array.isArray(s) ? s : [s]);\n      setSelected(next);\n      post(next);\n    },\n    [post]\n  );\n\n  const add = useCallback(\n    (s: Selection | Selection[]) => {\n      const incoming = Array.isArray(s) ? s : [s];\n      setSelected((prev) => {\n        const next = dedupe([...prev, ...incoming]);\n        post(next);\n        return next;\n      });\n    },\n    [post]\n  );\n\n  const remove = useCallback(\n    (s: Selection) => {\n      const k = selectionKey(s);\n      setSelected((prev) => {\n        const next = prev.filter((x) => selectionKey(x) !== k);\n        post(next);\n        return next;\n      });\n    },\n    [post]\n  );\n\n  const toggle = useCallback(\n    (s: Selection) => {\n      const k = selectionKey(s);\n      setSelected((prev) => {\n        const next = prev.some((x) => selectionKey(x) === k)\n          ? prev.filter((x) => selectionKey(x) !== k)\n          : [...prev, s];\n        post(next);\n        return next;\n      });\n    },\n    [post]\n  );\n\n  const clear = useCallback(() => {\n    setSelected([]);\n    post([]);\n  }, [post]);\n\n  const value = useMemo<SelectionSetValue>(\n    () => ({ selected, replace, add, remove, toggle, clear }),\n    [selected, replace, add, remove, toggle, clear]\n  );\n\n  return <SelectionSetContext.Provider value={value}>{children}</SelectionSetContext.Provider>;\n}\n\n/**\n * Mount a `SelectionSetProvider` only when none exists above us. The shell-\n * owned comment mount layer provides one so both the lite comment router and\n * `CanvasShell` share a single selection set. Hook called unconditionally;\n * only the returned tree branches (hook rules).\n */\nexport function MaybeSelectionSetProvider({ children }: { children: ReactNode }) {\n  const outer = useContext(SelectionSetContext);\n  if (outer) return <>{children}</>;\n  return <SelectionSetProvider>{children}</SelectionSetProvider>;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Hooks\n\nexport function useSelectionSet(): SelectionSetValue {\n  const ctx = useContext(SelectionSetContext);\n  if (!ctx) {\n    throw new Error('useSelectionSet must be used inside <SelectionSetProvider>');\n  }\n  return ctx;\n}\n\nexport function useSelectionSetOptional(): SelectionSetValue | null {\n  return useContext(SelectionSetContext);\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Wire-shape helpers — exported for tests and inspect.ts back-compat reader.\n\n/** Convert any inbound shape to an array. */\nexport function normalizeSelectedRead(\n  raw: Selection | Selection[] | null | undefined\n): Selection[] {\n  if (raw == null) return [];\n  if (Array.isArray(raw)) return dedupe(raw);\n  return [raw];\n}\n\n/** Convert internal array back to the wire shape (writer). */\nexport function denormalizeSelectedWrite(list: Selection[]): Selection | Selection[] | null {\n  if (list.length === 0) return null;\n  if (list.length === 1) return list[0] ?? null;\n  return list;\n}\n",
    "/**\n * @file       dom-selection.ts — selection-from-DOM helpers (leaf module)\n * @scope      apps/studio/dom-selection.ts\n * @purpose    Pure DOM → Selection builders shared by the canvas chrome\n *             (canvas-shell.tsx) and the shell-owned comment mount layer\n *             (canvas-comment-mount.tsx). Lives in its own leaf module — no\n *             React, no canvas-lib import — so both consumers can lift the\n *             same `hoverTargetToSelection` / `deriveFile` logic without a\n *             cycle and without bundling the heavy DesignCanvas tree into the\n *             lite comment mount.\n */\n\nimport type { HoverTarget } from './input-router.tsx';\nimport type { Selection } from './use-selection-set.tsx';\n\n/**\n * Canvas file path for the current page. Under the mount harness the page is\n * `/_canvas-shell.html?canvas=<rel>&designRel=<root>`; for legacy `.html`\n * mocks it's the served file path itself.\n */\nexport function deriveFile(): string | undefined {\n  if (typeof window === 'undefined') return undefined;\n  try {\n    const p = window.location.pathname;\n    if (p === '/_canvas-shell.html' || p === '/_canvas-shell') {\n      const qs = new URLSearchParams(window.location.search);\n      const canvas = qs.get('canvas') ?? '';\n      const designRel = (qs.get('designRel') ?? '.design').replace(/^\\/+|\\/+$/g, '');\n      return canvas ? `${designRel}/${canvas}` : undefined;\n    }\n    return decodeURIComponent(p).replace(/^\\//, '');\n  } catch {\n    return undefined;\n  }\n}\n\nexport function realClasses(el: Element | null): string {\n  if (!el) return '';\n  return (el.getAttribute('class') ?? '')\n    .trim()\n    .split(/\\s+/)\n    .filter((c) => c && !c.startsWith('dgn-') && !c.startsWith('dc-cv-'))\n    .join(' ');\n}\n\nexport function shortText(el: Element | null, max: number): string {\n  if (!el) return '';\n  const t = ((el as HTMLElement).innerText || el.textContent || '').replace(/\\s+/g, ' ').trim();\n  return t.length > max ? `${t.slice(0, max - 1)}…` : t;\n}\n\nexport function cssPath(el: Element | null): string {\n  if (!el) return '';\n  const path: string[] = [];\n  let cur: Element | null = el;\n  while (cur && cur.nodeType === 1 && path.length < 8) {\n    const dscEl = cur.getAttribute?.('data-dc-element');\n    if (dscEl) {\n      path.unshift(`[data-dc-element=\"${dscEl}\"]`);\n      break;\n    }\n    const dscSc = cur.getAttribute?.('data-dc-screen');\n    if (dscSc) {\n      path.unshift(`[data-dc-screen=\"${dscSc}\"]`);\n      break;\n    }\n    let sel = cur.nodeName.toLowerCase();\n    if (cur.id) {\n      sel = `#${cur.id}`;\n      path.unshift(sel);\n      break;\n    }\n    const cls = realClasses(cur).split(/\\s+/).filter(Boolean).slice(0, 2);\n    if (cls.length) sel += `.${cls.join('.')}`;\n    let sib = 1;\n    let n: Element | null = cur.previousElementSibling;\n    while (n) {\n      sib++;\n      n = n.previousElementSibling;\n    }\n    sel += `:nth-child(${sib})`;\n    path.unshift(sel);\n    cur = cur.parentElement;\n  }\n  return path.join(' > ');\n}\n\nexport function domPath(el: Element | null): string[] {\n  const hops: string[] = [];\n  let cur = el;\n  while (cur && cur.nodeType === 1 && hops.length < 8) {\n    let label = cur.nodeName.toLowerCase();\n    const dEl = cur.getAttribute?.('data-dc-element');\n    const dSc = cur.getAttribute?.('data-dc-screen');\n    if (dEl) label += `[data-dc-element=\"${dEl}\"]`;\n    else if (dSc) label += `[data-dc-screen=\"${dSc}\"]`;\n    else if (cur.id) label += `#${cur.id}`;\n    const cls = realClasses(cur).split(/\\s+/).filter(Boolean).slice(0, 2);\n    if (cls.length && !dEl && !dSc) label += `.${cls.join('.')}`;\n    hops.unshift(label);\n    cur = cur.parentElement;\n  }\n  return hops;\n}\n\nexport function cssEscape(s: string): string {\n  // Minimal CSS.escape polyfill — only handles chars actually present in\n  // pipeline-stamped IDs (alphanumerics + `-` + `_`).\n  return s.replace(/[^a-zA-Z0-9_-]/g, (c) => `\\\\${c}`);\n}\n\n/**\n * Build the wire-shape `Selection` for a resolved hover target. `file`\n * defaults to `deriveFile()`; the comment mount layer passes it explicitly\n * so all three consumers (router, overlay, mount) agree on the same key.\n */\n/**\n * The artboard-scoped data-cd-id selector. A component shared across artboards\n * carries the SAME data-cd-id in each, so a bare `[data-cd-id=\"…\"]` resolves\n * (via querySelector) to the FIRST artboard. Prefixing the hit's artboard makes\n * the anchor per-instance. Shared by EVERY selector builder + resolver so they\n * can't drift (the original fix only patched one of ~8 sites).\n */\nexport function scopedCdSelector(cdId: string, artboardId?: string | null): string {\n  return artboardId\n    ? `[data-dc-screen=\"${artboardId}\"] [data-cd-id=\"${cdId}\"]`\n    : `[data-cd-id=\"${cdId}\"]`;\n}\n\n/**\n * Occurrence index of `el` among `doc.querySelectorAll(selector)`. Even with an\n * artboard-scoped data-cd-id selector, a component repeated WITHIN one artboard\n * (a list row, or a reusable used twice) produces several matches — the index\n * is the only thing that makes the anchor truly unique per DOM instance.\n */\nexport function selectorIndex(doc: Document, selector: string, el: Element | null): number {\n  if (!el) return 0;\n  try {\n    const all = doc.querySelectorAll(selector);\n    for (let i = 0; i < all.length; i++) {\n      if (all[i] === el) return i;\n    }\n  } catch {\n    /* malformed selector */\n  }\n  return 0;\n}\n\n/**\n * Resolve a stored Selection to its live element, artboard-scoped. Prefers the\n * id+artboardId scoped selector (the robust path), then the stored `selector`\n * (already scoped for recent selections; a legacy fallback for old comments).\n * Every halo / pin / toolbar / spacing-handle resolver routes through this so a\n * shared component anchors to the instance the user actually clicked.\n */\nexport function resolveSelectionEl(\n  doc: Document,\n  sel: { id?: string | null; selector?: string | null; artboardId?: string | null; index?: number }\n): Element | null {\n  const at = (selector: string): Element | null => {\n    try {\n      const all = doc.querySelectorAll(selector);\n      if (!all.length) return null;\n      const i = sel.index && sel.index > 0 && sel.index < all.length ? sel.index : 0;\n      return all[i] ?? all[0];\n    } catch {\n      return null;\n    }\n  };\n  if (sel.id) {\n    const el = at(scopedCdSelector(sel.id, sel.artboardId));\n    if (el) return el;\n  }\n  if (sel.selector) return at(sel.selector);\n  return null;\n}\n\n/**\n * Phase 12.2 — style maps for the CSS-knob properties. `authored` is what the\n * element sets INLINE (React renders `style={{padding:8}}` → `style=\"padding:8px\"`),\n * so the knob pre-fills the EDITABLE source value and is blank when unset — not\n * the noisy resolved default (`656.003px`, `rgb(0,0,0)`). `computed` is the\n * resolved value, shown only as a faint placeholder hint. Empty for a detached\n * node / SSR.\n */\n// Phase 12.3 (W2.2 fix) — EVERY property the CSS panel has a control for, so each\n// reads back into `authored` (pre-fills the right control) and is excluded from\n// `customStyles`. The earlier short list omitted the box-model LONGHANDS\n// (`padding-top`, `margin-left`, …) + the Layout/border longhands, so a value the\n// panel wrote (e.g. an alt-scrub `padding-top`) fell through to customStyles and\n// the box-model widget showed it as a \"custom CSS property\" instead of in the box.\nconst KNOB_PROPS = [\n  // Layout\n  'display',\n  'flex-direction',\n  'align-items',\n  'justify-content',\n  'gap',\n  // Typography\n  'font-family',\n  'color',\n  'font-size',\n  'font-weight',\n  'line-height',\n  'letter-spacing',\n  'text-align',\n  // Spacing — shorthand (for customStyles exclusion + whole-side authoring) AND\n  // the 8 longhands the box-model widget actually reads/writes.\n  'margin',\n  'margin-top',\n  'margin-right',\n  'margin-bottom',\n  'margin-left',\n  'padding',\n  'padding-top',\n  'padding-right',\n  'padding-bottom',\n  'padding-left',\n  // Size\n  'width',\n  'height',\n  'max-width',\n  // Appearance\n  'background-color',\n  'border-radius',\n  'border-top-left-radius',\n  'border-top-right-radius',\n  'border-bottom-left-radius',\n  'border-bottom-right-radius',\n  'border-width',\n  'border-style',\n  'border-color',\n  'box-shadow',\n  'opacity',\n] as const;\n\n// Phase 12.3 — HTML attributes the custom-attribute hatch may have written, so a\n// just-added `data-*`/`aria-*`/`role`/`title` round-trips back into a panel row.\n// Excludes the structural ones the panel manages elsewhere (style, class,\n// data-cd-id pipeline anchor, the data-dc-* canvas chrome markers).\nconst ATTR_SKIP = /^(style|class|data-cd-id|data-dc-|data-dcid$)/;\n\nfunction styleMapsFor(el: Element | null): {\n  authored: Record<string, string>;\n  computed: Record<string, string>;\n  customStyles: Record<string, string>;\n  attrs: Record<string, string>;\n} {\n  if (!el || typeof window === 'undefined' || !window.getComputedStyle) {\n    return { authored: {}, computed: {}, customStyles: {}, attrs: {} };\n  }\n  try {\n    const inline = (el as HTMLElement).style;\n    const cs = window.getComputedStyle(el as HTMLElement);\n    const authored: Record<string, string> = {};\n    const computed: Record<string, string> = {};\n    const knob = new Set<string>(KNOB_PROPS as readonly string[]);\n    // Curated knob props: authored value (knob pre-fill) + computed (placeholder).\n    for (const p of KNOB_PROPS) {\n      const a = inline.getPropertyValue(p);\n      if (a) authored[p] = a.trim();\n      const c = cs.getPropertyValue(p);\n      if (c) computed[p] = c.trim();\n    }\n    // Every OTHER authored inline property → customStyles, so the panel can show\n    // a custom CSS property the user added that no curated row covers. EXCLUDE\n    // the panel-managed FAMILIES wholesale: setting `border`/`border-radius` (or\n    // their 3-way shorthands) makes the CSSOM expand them to the per-side\n    // longhands — `border-top-width`, `border-left-color`, … — which the panel\n    // controls but can't enumerate in the knob set. Without the family guard they\n    // leak into \"custom CSS properties\" (the same class of bug fixed for spacing).\n    const MANAGED_FAMILY = /^(margin|padding|border)(-|$)/;\n    const customStyles: Record<string, string> = {};\n    for (let i = 0; i < inline.length; i++) {\n      const p = inline.item(i);\n      if (!p || knob.has(p) || MANAGED_FAMILY.test(p)) continue;\n      const v = inline.getPropertyValue(p);\n      if (v) customStyles[p] = v.trim();\n    }\n    // Custom HTML attributes (the escape-hatch surface).\n    const attrs: Record<string, string> = {};\n    for (const a of Array.from((el as HTMLElement).attributes)) {\n      if (ATTR_SKIP.test(a.name)) continue;\n      attrs[a.name] = a.value;\n    }\n    return { authored, computed, customStyles, attrs };\n  } catch {\n    return { authored: {}, computed: {}, customStyles: {}, attrs: {} };\n  }\n}\n\nexport function hoverTargetToSelection(target: HoverTarget, file?: string): Selection {\n  const el = target.el;\n  const rect =\n    el && (el as HTMLElement).getBoundingClientRect\n      ? (el as HTMLElement).getBoundingClientRect()\n      : null;\n  // `cdId` is the hit element's OWN data-cd-id (deep mode); resolver never\n  // climbs to an ancestor. Falls back to cssPath of the hit when no stable\n  // anchor exists.\n  const cdId = target.cdId;\n  // Selector resolution order:\n  //   1. data-cd-id anchor — stable pipeline-stamped id (preferred). SCOPED by\n  //      the hit's artboard (`[data-dc-screen=…] [data-cd-id=…]`) — a component\n  //      shared across artboards carries the SAME data-cd-id in each, so an\n  //      unscoped `[data-cd-id]` selector resolves (via querySelector) to the\n  //      FIRST artboard's instance and the pin/select lands on the wrong board.\n  //      Prefixing the artboard makes the anchor per-instance.\n  //   2. data-dc-screen — chrome click promoted to whole-artboard select\n  //      (T24.5 G8 multi-artboard gesture).\n  //   3. cssPath of the hit — last-resort path string.\n  const selector = cdId\n    ? scopedCdSelector(cdId, target.artboardId)\n    : target.artboardId\n      ? `[data-dc-screen=\"${target.artboardId}\"]`\n      : cssPath(el);\n  // Disambiguate repeated instances within the same artboard (list rows, a\n  // reusable used twice) — the index is which `querySelectorAll(selector)`\n  // match this element is. cssPath is already unique, so 0 there.\n  const index = cdId && typeof document !== 'undefined' ? selectorIndex(document, selector, el) : 0;\n  return {\n    file: file ?? deriveFile(),\n    id: cdId ?? undefined,\n    selector,\n    artboardId: target.artboardId,\n    index,\n    tag: el?.tagName.toLowerCase() ?? '',\n    classes: realClasses(el),\n    text: shortText(el, 240),\n    dom_path: domPath(el),\n    bounds: rect\n      ? {\n          x: Math.round(rect.left),\n          y: Math.round(rect.top),\n          w: Math.round(rect.width),\n          h: Math.round(rect.height),\n        }\n      : null,\n    html: el ? (el.outerHTML ?? '').slice(0, 4000) : '',\n    ...styleMapsFor(el),\n  };\n}\n",
    "/**\n * @file       input-router.tsx — canvas pointer/keyboard classifier + hook\n * @scope      apps/studio/input-router.tsx\n * @purpose    Owned by canvas-lib's DesignCanvas. Classifies the NON-WHEEL\n *             subset of pointer + key events into discrete router actions.\n *             `useViewportController` keeps owning wheel + middle-mouse +\n *             space-pan + Cmd+0/1/+/- — the two stacks coexist without a\n *             listener race (DDR-026).\n *\n * Event ownership (read this before adding handlers):\n *\n *   ┌──────────────────────────────────┬─────────────────────────┐\n *   │ Event                            │ Owner                    │\n *   ├──────────────────────────────────┼─────────────────────────┤\n *   │ wheel / shift-wheel / cmd-wheel  │ useViewportController    │\n *   │ pointerdown btn=1 / space-held   │ useViewportController    │\n *   │ keydown Space / Cmd+0/1/+/-      │ useViewportController    │\n *   │ pointermove (hover)              │ input-router             │\n *   │ pointerdown btn=0 (select)       │ input-router             │\n *   │ pointerdown btn=2 (right-click)  │ input-router             │\n *   │ keydown V / H / C / Esc          │ input-router             │\n *   └──────────────────────────────────┴─────────────────────────┘\n *\n * The router does no DOM work itself — `classify()` is pure (testable without\n * a DOM) and `useInputRouter()` attaches listeners that dispatch through the\n * caller-supplied callbacks. Hover-target resolution + selection persistence\n * live in the consumer (DesignCanvas).\n */\n\nimport { type RefObject, useEffect } from 'react';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Drag-vs-click threshold (T25)\n//\n// 4 px screen-pixel hypot separates \"click\" from \"drag\" — Microsoft Win32\n// canonical (`SM_CXDRAG`/`SM_CYDRAG` default), also d3-drag and tldraw default.\n// Owned here so artboard-drag, artboard-marquee, element-marquee, annotation-\n// drag-vs-tap, and any future drag-class gesture all read the same constant.\n// Wheel + pinch-zoom are EXEMPT — threshold is for `pointerdown → pointermove`\n// drag classification only.\n\nexport const DRAG_THRESHOLD_PX = 4;\n\n/** True once the pointer has moved ≥ DRAG_THRESHOLD_PX from its start. */\nexport function crossedDragThreshold(\n  startX: number,\n  startY: number,\n  curX: number,\n  curY: number\n): boolean {\n  const dx = curX - startX;\n  const dy = curY - startY;\n  return Math.hypot(dx, dy) >= DRAG_THRESHOLD_PX;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Types\n\n/**\n * Tool union. Phase 4.1 shipped V/H/C; Phase 5 adds the draw set\n * (pen / rect / arrow / eraser). Draw-tool pointer events are owned by\n * `AnnotationsLayer` — the router classifies their letter shortcuts but\n * returns `no-op` for the corresponding pointer events so the SVG overlay\n * can grab them natively.\n */\nexport type Tool =\n  | 'move'\n  | 'hand'\n  | 'comment'\n  | 'pen'\n  // Annotation polish (item 8) — FigJam-style highlighter. A `pen`-shaped tool\n  // that produces a translucent wide multiply stroke (a PenStroke with\n  // `highlighter:true`), not a new stroke type.\n  | 'highlighter'\n  // Phase 24 — `shape` is the single active draw tool that produces rect /\n  // ellipse / polygon strokes (the kind is chosen via the palette popover).\n  // `rect` / `ellipse` stay in the union as the stroke discriminants they\n  // always were, but are no longer directly selectable active tools.\n  | 'shape'\n  | 'rect'\n  | 'ellipse'\n  | 'arrow'\n  | 'sticky'\n  | 'text'\n  // FigJam v3 — labelled organizing container (Shift+S).\n  | 'section'\n  | 'eraser';\n\nconst ANNOTATION_TOOLS = new Set<Tool>([\n  'pen',\n  'highlighter',\n  'shape',\n  'rect',\n  'ellipse',\n  'arrow',\n  'sticky',\n  'text',\n  'section',\n  'eraser',\n]);\n\nexport function isAnnotationTool(t: Tool): boolean {\n  return ANNOTATION_TOOLS.has(t);\n}\n\nexport type RouterAction =\n  | { kind: 'no-op' }\n  | { kind: 'hover'; deep: boolean; clientX: number; clientY: number }\n  | {\n      kind: 'select';\n      /** `replace` swaps the selection set, `add` merges into it. */\n      mode: 'replace' | 'add';\n      /**\n       * `true` resolves to the deepest descendant under the cursor (Cmd-held\n       * mode). `false` resolves to the topmost interesting ancestor (top mode).\n       * Phase 4.1 Move-tool selection always uses deep=true — bare clicks\n       * are passthrough (no select), and the only entry points are Cmd\n       * (replace deep) and Cmd+Shift (add deep).\n       */\n      deep: boolean;\n      clientX: number;\n      clientY: number;\n    }\n  | { kind: 'drop-comment'; clientX: number; clientY: number }\n  | { kind: 'context-menu'; clientX: number; clientY: number }\n  | { kind: 'tool'; tool: Tool }\n  | { kind: 'escape' }\n  | { kind: 'undo' }\n  | { kind: 'redo' };\n\nexport interface ClassifyInput {\n  type: 'pointermove' | 'pointerdown' | 'contextmenu' | 'keydown';\n  /** PointerEvent.button: 0 = left, 1 = middle, 2 = right. */\n  button?: number;\n  metaKey?: boolean;\n  ctrlKey?: boolean;\n  shiftKey?: boolean;\n  altKey?: boolean;\n  key?: string;\n  clientX?: number;\n  clientY?: number;\n  /** Spacebar held — shared signal with `useViewportController`'s pan-drag. */\n  spaceHeld?: boolean;\n  /** Event target is editable (input/textarea/contentEditable) — caller computes. */\n  isEditable?: boolean;\n  activeTool: Tool;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// classify — pure function. All branching lives here so unit tests cover every\n// row of the dispatch table without spinning up a DOM.\n\nconst metaOrCtrl = (i: ClassifyInput): boolean => !!(i.metaKey || i.ctrlKey);\n\nexport function classify(input: ClassifyInput): RouterAction {\n  if (input.type === 'keydown') {\n    if (input.isEditable) return { kind: 'no-op' };\n    // Tool letters are bare keys — Cmd/Ctrl/Alt+letter belongs to shell / browser.\n    if (input.metaKey || input.ctrlKey || input.altKey) {\n      // Esc with modifiers still dismisses.\n      if (input.key === 'Escape') return { kind: 'escape' };\n      // Undo / redo (Phase 20). Alt is reserved — Cmd+Opt+Z is a browser\n      // text-input gesture we don't claim. `metaKey || ctrlKey` covers both\n      // mac and Windows / Linux without a platform sniff.\n      const k = (input.key || '').toLowerCase();\n      if (!input.altKey && (input.metaKey || input.ctrlKey)) {\n        if (k === 'z' && input.shiftKey) return { kind: 'redo' };\n        if (k === 'z') return { kind: 'undo' };\n        if (k === 'y' && !input.shiftKey) return { kind: 'redo' };\n      }\n      return { kind: 'no-op' };\n    }\n    const k = (input.key || '').toLowerCase();\n    if (k === 'v') return { kind: 'tool', tool: 'move' };\n    if (k === 'h') return { kind: 'tool', tool: 'hand' };\n    if (k === 'c') return { kind: 'tool', tool: 'comment' };\n    if (k === 'b') return { kind: 'tool', tool: 'pen' };\n    // I = hIghlighter (a free bare letter; 'H' is taken by Hand).\n    if (k === 'i') return { kind: 'tool', tool: 'highlighter' };\n    // Phase 24 — R (and legacy O) both arm the single Shape tool; the specific\n    // primitive is picked from the palette's shape-kind popover.\n    if (k === 'r' || k === 'o') return { kind: 'tool', tool: 'shape' };\n    if (k === 'a') return { kind: 'tool', tool: 'arrow' };\n    // Phase 21 — N = sticky Note ('S' is taken by the shell Design-system view\n    // + Shift-marquee); T = standalone Text. Both are bare letters the shell\n    // yields when focus is inside the canvas iframe (app.jsx onKey bail).\n    if (k === 'n') return { kind: 'tool', tool: 'sticky' };\n    if (k === 't') return { kind: 'tool', tool: 'text' };\n    // FigJam v3 — Shift+S arms the Section tool (FigJam's own binding; bare S\n    // stays with the shell's Design-system view). Checked here because the\n    // modifier guard above only filters Cmd/Ctrl/Alt.\n    if (k === 's' && input.shiftKey) return { kind: 'tool', tool: 'section' };\n    if (k === 'e') return { kind: 'tool', tool: 'eraser' };\n    if (input.key === 'Escape') return { kind: 'escape' };\n    return { kind: 'no-op' };\n  }\n\n  if (input.type === 'contextmenu') {\n    return {\n      kind: 'context-menu',\n      clientX: input.clientX ?? 0,\n      clientY: input.clientY ?? 0,\n    };\n  }\n\n  if (input.type === 'pointermove') {\n    // Phase 5 draw tools: pen / rect / arrow / eraser own all their pointer\n    // events through `AnnotationsLayer`. The router never paints a hover halo\n    // while drawing — that affordance is reserved for select / comment.\n    if (isAnnotationTool(input.activeTool)) return { kind: 'no-op' };\n    // Hand tool: drag pan is owned by useViewportController; no hover paint.\n    if (input.activeTool === 'hand') return { kind: 'no-op' };\n    // Comment tool: always paint a preview halo on the deepest element under\n    // cursor — that's the element the user is about to comment on. Comment\n    // pin attachment is to the same element they were hovering.\n    if (input.activeTool === 'comment') {\n      return {\n        kind: 'hover',\n        deep: true,\n        clientX: input.clientX ?? 0,\n        clientY: input.clientY ?? 0,\n      };\n    }\n    // Move tool: bare hover does nothing (native interactions pass through);\n    // Cmd-held hover paints a halo on the deepest element (preview).\n    if (!metaOrCtrl(input)) return { kind: 'no-op' };\n    return {\n      kind: 'hover',\n      deep: true,\n      clientX: input.clientX ?? 0,\n      clientY: input.clientY ?? 0,\n    };\n  }\n\n  if (input.type === 'pointerdown') {\n    if (input.button === 2) {\n      return {\n        kind: 'context-menu',\n        clientX: input.clientX ?? 0,\n        clientY: input.clientY ?? 0,\n      };\n    }\n    if (input.button === 1 || input.spaceHeld) return { kind: 'no-op' };\n    if (input.button !== 0) return { kind: 'no-op' };\n\n    // Phase 5 draw tools own bare left-clicks; the router returns no-op so\n    // the SVG layer's own listeners (no preventDefault) fire normally. Cmd-\n    // modified clicks still flow into the move-tool select path below — that\n    // stays available as an escape hatch even while a draw tool is active.\n    if (isAnnotationTool(input.activeTool) && !metaOrCtrl(input)) {\n      return { kind: 'no-op' };\n    }\n\n    if (input.activeTool === 'comment') {\n      // Comment tool: bare click drops a pin. Cmd / Shift modifiers reserved\n      // for future \"scope comment to deepest\" variants — for now they fall\n      // through to the same drop.\n      return {\n        kind: 'drop-comment',\n        clientX: input.clientX ?? 0,\n        clientY: input.clientY ?? 0,\n      };\n    }\n\n    // Hand tool: pan is owned by useViewportController via `isPanDragActive`.\n    // Router returns no-op so it doesn't preventDefault or stopPropagation —\n    // the controller's pointerdown listener on the same host claims the drag.\n    if (input.activeTool === 'hand') return { kind: 'no-op' };\n\n    // Move tool. Selection ONLY fires with Cmd / Cmd+Shift. Bare clicks and\n    // Shift-without-Cmd pass through so native canvas interactions (button\n    // presses, link clicks, input focus) still work — exactly the same as\n    // pre-Phase-4.1 behavior for everything except Cmd-modified gestures.\n    const cmd = metaOrCtrl(input);\n    if (!cmd) return { kind: 'no-op' };\n    const shift = !!input.shiftKey;\n    return {\n      kind: 'select',\n      mode: shift ? 'add' : 'replace',\n      deep: true,\n      clientX: input.clientX ?? 0,\n      clientY: input.clientY ?? 0,\n    };\n  }\n\n  return { kind: 'no-op' };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// useInputRouter — attach listeners scoped to `hostRef.current`. Dispatches\n// through `callbacks`. Returns nothing; cleans up on unmount.\n\nexport interface RouterCallbacks {\n  onHover?: (a: Extract<RouterAction, { kind: 'hover' }>) => void;\n  onSelect?: (a: Extract<RouterAction, { kind: 'select' }>) => void;\n  onDropComment?: (a: Extract<RouterAction, { kind: 'drop-comment' }>) => void;\n  onContextMenu?: (a: Extract<RouterAction, { kind: 'context-menu' }>) => void;\n  onTool?: (a: Extract<RouterAction, { kind: 'tool' }>) => void;\n  onEscape?: () => void;\n  /** Phase 20 — Cmd+Z / Ctrl+Z. */\n  onUndo?: () => void;\n  /** Phase 20 — Cmd+Shift+Z / Ctrl+Y / Cmd+Y. */\n  onRedo?: () => void;\n}\n\nexport interface UseInputRouterOptions {\n  hostRef: RefObject<HTMLElement | null>;\n  /** Latest active tool — read at event time, not captured. */\n  getActiveTool: () => Tool;\n  /** Optional spacebar-held signal shared with useViewportController. */\n  isSpaceHeld?: () => boolean;\n  callbacks: RouterCallbacks;\n  /** When false, listeners are not attached. Defaults to true. */\n  enabled?: boolean;\n  /**\n   * Allowlist of action kinds this router is permitted to CLAIM (preventDefault\n   * + stopImmediatePropagation + dispatch). Any classified action outside the\n   * set is downgraded to `no-op` so it propagates untouched to other listeners.\n   * Omit to claim everything (the default — used by the full DesignCanvas\n   * router). The shell-owned comment mount layer passes a narrow set so it can\n   * coexist as an ANCESTOR capture-listener over a UI canvas's own router\n   * without swallowing select / context-menu / undo gestures it doesn't own.\n   */\n  claimableActions?: ReadonlySet<RouterAction['kind']>;\n}\n\nexport function isEditableTarget(t: EventTarget | null): boolean {\n  if (!t || !(t as HTMLElement).tagName) return false;\n  const el = t as HTMLElement;\n  const tag = el.tagName;\n  if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return true;\n  if (el.isContentEditable) return true;\n  return false;\n}\n\n/**\n * Phase 6 — the comments overlay (pins / composer / thread popover / mention\n * popup) lives INSIDE the canvas world, which means its DOM nodes are inside\n * the input-router's capture host. Without an explicit bail-out the router\n * would `preventDefault + stopImmediatePropagation` every click on a\n * composer button while comment mode is active, blocking Save / Cancel.\n *\n * We treat the overlay nodes like editable form widgets — the router yields,\n * the React event handler runs.\n */\nexport function isOverlayTarget(t: EventTarget | null): boolean {\n  if (!t || !(t as Element).closest) return false;\n  return !!(t as Element).closest('.cm-composer, .cm-thread, .cm-mention-popup, .cm-pin');\n}\n\nexport function useInputRouter(opts: UseInputRouterOptions): void {\n  const { hostRef, getActiveTool, isSpaceHeld, callbacks, enabled = true, claimableActions } = opts;\n\n  useEffect(() => {\n    if (!enabled) return;\n    const host = hostRef.current;\n    if (!host) return;\n\n    // Downgrade any action this router isn't permitted to claim to no-op so it\n    // propagates untouched (no preventDefault / no dispatch). Identity pass-\n    // through when no allowlist is configured.\n    const claim = (action: RouterAction): RouterAction =>\n      claimableActions && action.kind !== 'no-op' && !claimableActions.has(action.kind)\n        ? { kind: 'no-op' }\n        : action;\n\n    const dispatch = (action: RouterAction): void => {\n      switch (action.kind) {\n        case 'hover':\n          callbacks.onHover?.(action);\n          break;\n        case 'select':\n          callbacks.onSelect?.(action);\n          break;\n        case 'drop-comment':\n          callbacks.onDropComment?.(action);\n          break;\n        case 'context-menu':\n          callbacks.onContextMenu?.(action);\n          break;\n        case 'tool':\n          callbacks.onTool?.(action);\n          break;\n        case 'escape':\n          callbacks.onEscape?.();\n          break;\n        case 'undo':\n          callbacks.onUndo?.();\n          break;\n        case 'redo':\n          callbacks.onRedo?.();\n          break;\n        case 'no-op':\n          break;\n      }\n    };\n\n    const onPointerMove = (e: PointerEvent): void => {\n      const action = claim(\n        classify({\n          type: 'pointermove',\n          button: e.button,\n          metaKey: e.metaKey,\n          ctrlKey: e.ctrlKey,\n          shiftKey: e.shiftKey,\n          altKey: e.altKey,\n          clientX: e.clientX,\n          clientY: e.clientY,\n          spaceHeld: isSpaceHeld?.() ?? false,\n          activeTool: getActiveTool(),\n        })\n      );\n      dispatch(action);\n    };\n\n    const onPointerDown = (e: PointerEvent): void => {\n      // Phase 6 — overlay surfaces (composer / thread / mention popup) own\n      // their own clicks. The router is in capture phase, so we have to\n      // bail HERE before classify can claim the event.\n      if (isOverlayTarget(e.target)) return;\n      const action = claim(\n        classify({\n          type: 'pointerdown',\n          button: e.button,\n          metaKey: e.metaKey,\n          ctrlKey: e.ctrlKey,\n          shiftKey: e.shiftKey,\n          altKey: e.altKey,\n          clientX: e.clientX,\n          clientY: e.clientY,\n          spaceHeld: isSpaceHeld?.() ?? false,\n          activeTool: getActiveTool(),\n        })\n      );\n      if (action.kind !== 'no-op') {\n        // Suppress native behavior on every event the router claims —\n        // button presses don't fire, inputs don't focus, the canvas\n        // content's own click handlers don't run. The router lives in\n        // capture phase so this fires before descendants.\n        e.preventDefault();\n        e.stopImmediatePropagation();\n      }\n      dispatch(action);\n    };\n\n    /**\n     * Paired mousedown listener — preventDefault on pointerdown does NOT\n     * suppress the mousedown event that browsers fire alongside, and\n     * `<input>` / `<button>` focus is driven by mousedown's default behavior.\n     * We mirror the same gate as pointerdown so suppressed pointerdowns also\n     * stop their twin mousedown.\n     */\n    const onMouseDown = (e: MouseEvent): void => {\n      if (isOverlayTarget(e.target)) return;\n      const action = claim(\n        classify({\n          type: 'pointerdown',\n          button: e.button,\n          metaKey: e.metaKey,\n          ctrlKey: e.ctrlKey,\n          shiftKey: e.shiftKey,\n          altKey: e.altKey,\n          clientX: e.clientX,\n          clientY: e.clientY,\n          spaceHeld: isSpaceHeld?.() ?? false,\n          activeTool: getActiveTool(),\n        })\n      );\n      if (action.kind !== 'no-op') {\n        e.preventDefault();\n        e.stopImmediatePropagation();\n      }\n    };\n\n    /**\n     * Click listener — fires AFTER pointerdown+pointerup. Even with\n     * preventDefault on mousedown, the click event still synthesizes for\n     * non-form elements. We suppress it whenever the router claimed the\n     * matching pointerdown (re-classify with the same modifiers).\n     */\n    const onClick = (e: MouseEvent): void => {\n      if (isOverlayTarget(e.target)) return;\n      const tool = getActiveTool();\n      const mod = e.metaKey || e.ctrlKey;\n      // Map the click to the action kind the matching pointerdown would have\n      // produced, then honor the claim allowlist so a scoped router (the\n      // comment mount layer) doesn't suppress clicks it never claimed.\n      const wouldRouteKind: RouterAction['kind'] | null =\n        tool === 'comment'\n          ? 'drop-comment'\n          : tool === 'move' && mod && e.button === 0\n            ? 'select'\n            : e.button === 2\n              ? 'context-menu'\n              : null;\n      if (wouldRouteKind && (!claimableActions || claimableActions.has(wouldRouteKind))) {\n        e.preventDefault();\n        e.stopImmediatePropagation();\n      }\n    };\n\n    const onContextMenu = (e: MouseEvent): void => {\n      const action = claim(\n        classify({\n          type: 'contextmenu',\n          clientX: e.clientX,\n          clientY: e.clientY,\n          metaKey: e.metaKey,\n          ctrlKey: e.ctrlKey,\n          shiftKey: e.shiftKey,\n          altKey: e.altKey,\n          activeTool: getActiveTool(),\n        })\n      );\n      if (action.kind === 'no-op') return; // not ours to claim — let it bubble\n      e.preventDefault();\n      e.stopImmediatePropagation();\n      dispatch(action);\n    };\n\n    const onKeyDown = (e: KeyboardEvent): void => {\n      const action = claim(\n        classify({\n          type: 'keydown',\n          key: e.key,\n          metaKey: e.metaKey,\n          ctrlKey: e.ctrlKey,\n          shiftKey: e.shiftKey,\n          altKey: e.altKey,\n          isEditable: isEditableTarget(e.target),\n          activeTool: getActiveTool(),\n        })\n      );\n      if (\n        action.kind === 'tool' ||\n        action.kind === 'escape' ||\n        action.kind === 'undo' ||\n        action.kind === 'redo'\n      ) {\n        e.preventDefault();\n      }\n      dispatch(action);\n    };\n\n    // Capture phase for pointer/mouse/click events — router runs BEFORE\n    // descendants (buttons, inputs, canvas content listeners). For events the\n    // classifier claims, we preventDefault + stopImmediatePropagation so the\n    // descendants never see them.\n    host.addEventListener('pointermove', onPointerMove, { passive: true });\n    host.addEventListener('pointerdown', onPointerDown, { capture: true });\n    host.addEventListener('mousedown', onMouseDown, { capture: true });\n    host.addEventListener('click', onClick, { capture: true });\n    host.addEventListener('contextmenu', onContextMenu, { capture: true });\n    // Key events: attach on document so focus inside any descendant is OK;\n    // the editable-target gate handles the \"user is typing\" case.\n    const doc = host.ownerDocument ?? document;\n    doc.addEventListener('keydown', onKeyDown, true);\n\n    return () => {\n      host.removeEventListener('pointermove', onPointerMove);\n      host.removeEventListener('pointerdown', onPointerDown, {\n        capture: true,\n      } as EventListenerOptions);\n      host.removeEventListener('mousedown', onMouseDown, { capture: true } as EventListenerOptions);\n      host.removeEventListener('click', onClick, { capture: true } as EventListenerOptions);\n      host.removeEventListener('contextmenu', onContextMenu, {\n        capture: true,\n      } as EventListenerOptions);\n      doc.removeEventListener('keydown', onKeyDown, true);\n    };\n  }, [enabled, hostRef, getActiveTool, isSpaceHeld, callbacks, claimableActions]);\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// resolveHoverTarget — walks from a clientX/clientY pair to the canvas element\n// of interest. Default = topmost `[data-cd-id]` ancestor (the stable\n// pipeline-stamped anchor). `deep = true` returns the deepest descendant\n// (Cmd-hover behavior).\n\nexport interface HoverTarget {\n  el: Element;\n  cdId: string | null;\n  artboardId: string | null;\n}\n\nexport function resolveHoverTarget(\n  doc: Document,\n  clientX: number,\n  clientY: number,\n  opts: { deep: boolean }\n): HoverTarget | null {\n  const hit = doc.elementFromPoint(clientX, clientY);\n  if (!hit) return null;\n  // Skip the floating chrome (MiniMap / ZoomToolbar / ToolPalette / ContextMenu)\n  // AND the canvas/world frame itself — the user is never asking to \"select\n  // the entire canvas viewport,\" that's a UI accident from climbing too high.\n  if (hit.closest?.('.dc-mm, .dc-zoom-tb, .dc-tool-palette, .dc-context-menu, .dc-cv-group-bbox')) {\n    return null;\n  }\n\n  const artboardEl = hit.closest?.('[data-dc-screen]') ?? null;\n  const artboardId = artboardEl?.getAttribute('data-dc-screen') ?? null;\n\n  // Hover-target hard ceiling = `.dc-artboard-body`. Inner DOM content lives\n  // there; chrome lives outside (label, header, article root). The two paths\n  // diverge from here:\n  //   * hit ∈ body → resolve to the deepest stamped element (existing\n  //     deep/top logic below).\n  //   * hit ∈ chrome (label/header/article-root) → the user wants to select\n  //     the WHOLE artboard. Return the article element itself with no cdId;\n  //     consumers (hoverTargetToSelection) fall back to a\n  //     `[data-dc-screen=\"…\"]` selector that wraps the whole frame. This is\n  //     what enables Cmd+Shift+Click multi-select of artboards (T24 / G8).\n  const bodyEl = hit.closest?.('.dc-artboard-body') ?? null;\n  if (!bodyEl) {\n    if (artboardEl && artboardId) {\n      return { el: artboardEl, cdId: null, artboardId };\n    }\n    return null;\n  }\n  if (hit === bodyEl) {\n    // Clicked the body wrapper itself (empty padding inside an artboard, no\n    // user content under the cursor). Promote to \"select whole artboard\" so\n    // the gesture stays consistent with chrome clicks above.\n    if (artboardEl && artboardId) {\n      return { el: artboardEl, cdId: null, artboardId };\n    }\n    return null;\n  }\n\n  if (opts.deep) {\n    // Deepest mode — the hit element IS the target. Use its OWN data-cd-id\n    // when present; never climb to an ancestor's id (climbing was the cause\n    // of \"Cmd-click on a deep span selects the whole artboard root\"). When\n    // the hit lacks a stamped id, consumers fall back to a CSS-path selector.\n    const cdId = hit.getAttribute?.('data-cd-id') ?? null;\n    return { el: hit, cdId, artboardId };\n  }\n\n  // Top mode — climb to the topmost descendant of the artboard body that\n  // still carries a data-cd-id. Hard ceiling is bodyEl itself (never select\n  // the body wrapper or higher).\n  let cur: Element | null = hit;\n  let topCdEl: Element | null = null;\n  while (cur && cur !== bodyEl) {\n    if (cur.hasAttribute?.('data-cd-id')) topCdEl = cur;\n    cur = cur.parentElement;\n  }\n  const el = topCdEl ?? hit;\n  const cdId = el.getAttribute?.('data-cd-id') ?? null;\n  return { el, cdId, artboardId };\n}\n",
    "/**\n * @file       use-tool-mode.tsx — Phase 4.1 tool-mode store\n * @scope      apps/studio/use-tool-mode.tsx\n * @purpose    Context + hook for the active canvas tool. Wired into\n *             DesignCanvas. Phase 5 will\n *             register additional tools (pen, circle, arrow, eraser) via\n *             the same provider — the API is intentionally open.\n *\n * The router's `onTool` callback (input-router.tsx) writes into this store.\n * The ToolPalette + cursor sync read from it. Selecting a tool also mutates\n * `document.body.style.cursor` so the affordance matches across the iframe.\n */\n\nimport {\n  createContext,\n  type ReactNode,\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\n\nimport { TOOL_CURSORS } from './canvas-cursors.ts';\nimport type { Tool } from './input-router.tsx';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Types\n\nexport interface ToolDescriptor {\n  id: Tool;\n  label: string;\n  /** Letter-key shortcut shown in the palette tooltip. */\n  shortcut: string;\n  /** CSS cursor value applied to <body> when this tool is active. */\n  cursor: string;\n}\n\n/**\n * Phase 24 — the six primitives the single Shape tool can draw. Maps onto the\n * stroke model: square/rounded → `rect` (cornerRadius 0 / 8); circle →\n * `ellipse`; diamond/triangle/triangle-down → `polygon`.\n */\nexport type ShapeKind = 'square' | 'rounded' | 'circle' | 'diamond' | 'triangle' | 'triangle-down';\n\n// Phase 21 — every tool ships a custom 32×32 SVG cursor (canvas-cursors.ts)\n// with a white outline halo so the glyph reads on any background. The native\n// crosshair/text/cell were thin + tiny (\"pen almost invisible\"); these mirror\n// the tool-palette icons. `move` keeps the system arrow on purpose.\nexport const DEFAULT_TOOLS: readonly ToolDescriptor[] = Object.freeze([\n  { id: 'move', label: 'Move', shortcut: 'V', cursor: TOOL_CURSORS.move },\n  { id: 'hand', label: 'Hand', shortcut: 'H', cursor: TOOL_CURSORS.hand },\n  { id: 'comment', label: 'Comment', shortcut: 'C', cursor: TOOL_CURSORS.comment },\n  { id: 'pen', label: 'Pen', shortcut: 'B', cursor: TOOL_CURSORS.pen },\n  // Annotation polish (item 8) — highlighter sits next to the pen.\n  { id: 'highlighter', label: 'Highlighter', shortcut: 'I', cursor: TOOL_CURSORS.highlighter },\n  // Phase 24 — one Shape tool replaces the separate Rect (R) + Ellipse (O)\n  // buttons; the primitive is chosen from the palette popover.\n  { id: 'shape', label: 'Shape', shortcut: 'R', cursor: TOOL_CURSORS.shape },\n  { id: 'sticky', label: 'Sticky', shortcut: 'N', cursor: TOOL_CURSORS.sticky },\n  // FigJam v3 — labelled organizing container.\n  { id: 'section', label: 'Section', shortcut: '⇧S', cursor: TOOL_CURSORS.shape },\n  { id: 'arrow', label: 'Arrow', shortcut: 'A', cursor: TOOL_CURSORS.arrow },\n  { id: 'text', label: 'Text', shortcut: 'T', cursor: TOOL_CURSORS.text },\n  { id: 'eraser', label: 'Eraser', shortcut: 'E', cursor: TOOL_CURSORS.eraser },\n]);\n\ninterface ToolContextValue {\n  tool: Tool;\n  setTool: (t: Tool) => void;\n  tools: readonly ToolDescriptor[];\n  /** T19 — sticky-tool double-click lock. When `sticky.locked === true` AND\n   *  `sticky.tool === tool`, draw tools stay armed after each shape commit\n   *  (T18 auto-flip is suppressed). Single-click on any other tool clears\n   *  sticky; Esc clears + flips to Move. */\n  sticky: { tool: Tool | null; locked: boolean };\n  toggleSticky: (t: Tool) => void;\n  clearSticky: () => void;\n  /** Phase 24 — the primitive the Shape tool will draw next. */\n  shapeKind: ShapeKind;\n  setShapeKind: (k: ShapeKind) => void;\n}\n\nconst ToolContext = createContext<ToolContextValue | null>(null);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Provider\n\nexport function ToolProvider({\n  children,\n  tools = DEFAULT_TOOLS,\n  initial = 'move',\n}: {\n  children: ReactNode;\n  tools?: readonly ToolDescriptor[];\n  initial?: Tool;\n}) {\n  const [tool, setToolState] = useState<Tool>(initial);\n  const [sticky, setSticky] = useState<{ tool: Tool | null; locked: boolean }>(() => ({\n    tool: null,\n    locked: false,\n  }));\n  const setTool = useCallback((t: Tool) => {\n    setToolState(t);\n    // Single-click on a different tool clears any sticky lock — sticky is\n    // a per-tool flag, not global.\n    setSticky((prev) => (prev.locked && prev.tool === t ? prev : { tool: null, locked: false }));\n  }, []);\n  const toggleSticky = useCallback((t: Tool) => {\n    setSticky((prev) => {\n      if (prev.locked && prev.tool === t) return { tool: null, locked: false };\n      return { tool: t, locked: true };\n    });\n    setToolState(t);\n  }, []);\n  const clearSticky = useCallback(() => {\n    setSticky({ tool: null, locked: false });\n  }, []);\n  // FigJam v3 — soft default: a fresh Shape tool draws ROUNDED squares (the\n  // FigJam look); sharp squares stay one popover click away.\n  const [shapeKind, setShapeKind] = useState<ShapeKind>('rounded');\n\n  // Cursor sync — applied inside the canvas (this hook runs in the canvas\n  // context). The active tool's cursor is set on <body> AND forced across the\n  // whole canvas working area via an `!important` rule, so the custom cursor\n  // shows EVERYWHERE — including over artboard CONTENT, whose own `cursor:\n  // pointer`/`text`/… would otherwise win (Phase 24, the \"custom cursors in the\n  // whole app\" requirement; FigJam behaviour). Chrome that lives OUTSIDE\n  // `.dc-world` (tool palette, context toolbar, resize handles) is intentionally\n  // NOT matched, so its buttons/handles keep their affordance cursors. The\n  // viewport-controller still owns the grab/grabbing swap during space-pan.\n  useEffect(() => {\n    if (typeof document === 'undefined') return;\n    const desc = tools.find((t) => t.id === tool);\n    if (!desc) return;\n    const prev = document.body.style.cursor;\n    document.body.style.cursor = desc.cursor;\n    let styleEl = document.getElementById('dc-tool-cursor') as HTMLStyleElement | null;\n    if (!styleEl) {\n      styleEl = document.createElement('style');\n      styleEl.id = 'dc-tool-cursor';\n      document.head.appendChild(styleEl);\n    }\n    // Truly GLOBAL inside the canvas document — `*` so it covers the empty grid\n    // host, `.dc-world`, every artboard + its content, AND the floating chrome\n    // (minimap, toolbar). The earlier `.dc-world`-scoped rule left the empty\n    // canvas / minimap on their own cursors; the brief is \"prostě všude\". (Mirrors\n    // the outer-shell `*` rule so both documents are uniformly covered.)\n    styleEl.textContent = `* { cursor: ${desc.cursor} !important; }`;\n    // Phase 24 — broadcast the active tool TOKEN to the OUTER app shell (this\n    // hook runs in the canvas iframe) so the shell shows the same custom cursor\n    // across the whole maude UI (sidebar / top bar). We send the tool *id*, NOT\n    // the cursor string: the shell resolves it against its own trusted\n    // TOOL_CURSORS copy (resolveToolCursor), so an untrusted synced canvas\n    // (DDR-054) can only pick a known, always-visible glyph — it can't inject an\n    // invisible/displaced cursor as a clickjacking aid (phase-24 ethical-hacker\n    // Finding 2; DDR-067).\n    if (typeof window !== 'undefined' && window.parent && window.parent !== window) {\n      try {\n        window.parent.postMessage({ dgn: 'tool-cursor', tool }, '*');\n      } catch {\n        /* cross-origin parent rejected — shell keeps its default cursor */\n      }\n    }\n    return () => {\n      document.body.style.cursor = prev;\n      const el = document.getElementById('dc-tool-cursor');\n      if (el) el.textContent = '';\n    };\n  }, [tool, tools]);\n\n  const value = useMemo<ToolContextValue>(\n    () => ({ tool, setTool, tools, sticky, toggleSticky, clearSticky, shapeKind, setShapeKind }),\n    [tool, setTool, tools, sticky, toggleSticky, clearSticky, shapeKind]\n  );\n\n  return <ToolContext.Provider value={value}>{children}</ToolContext.Provider>;\n}\n\n/**\n * Mount a `ToolProvider` only when none exists above us. When the shell-owned\n * comment mount layer (canvas-comment-mount.tsx) already provides one,\n * `DesignCanvas` consumes that instance instead of double-mounting. The hook\n * is called unconditionally; only the returned tree branches (hook rules).\n */\nexport function MaybeToolProvider({ children }: { children: ReactNode }) {\n  const outer = useContext(ToolContext);\n  if (outer) return <>{children}</>;\n  return <ToolProvider>{children}</ToolProvider>;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Hook\n\nexport function useToolMode(): ToolContextValue {\n  const ctx = useContext(ToolContext);\n  if (!ctx) {\n    throw new Error('useToolMode must be used inside <ToolProvider>');\n  }\n  return ctx;\n}\n\n/**\n * Read-only variant — returns `null` when no provider mounted. Used by\n * components that can render outside a ToolProvider tree (the input\n * router's optional path).\n */\nexport function useToolModeOptional(): ToolContextValue | null {\n  return useContext(ToolContext);\n}\n",
    "/**\n * @file       canvas-cursors.ts — Phase 24 custom tool cursors (Kenney CC0)\n * @scope      apps/studio/canvas-cursors.ts\n * @purpose    FigJam/Figma-style custom cursors for EVERY canvas tool. The\n *             native crosshair / text / arrow cursors are tiny + thin and\n *             vanish on busy canvases; these are 32×32 SVG cursors that read on\n *             any background.\n *\n *             Phase 24 — ALL tools draw from ONE library, the **Kenney Cursor\n *             Pack (1.1)** \"Outline\" set, which is **CC0 / public domain**\n *             (https://kenney.nl/assets/cursor-pack — no attribution required,\n *             redistributable inside this MIT package + marketplace clone). See\n *             DDR-067 for the licence gate (Bibata GPL-3.0 was rejected as\n *             copyleft). One library = one visual identity across move / hand /\n *             comment / pen / shape / sticky / text / eraser. The glyph paths\n *             are Kenney's; we RECOLOUR them (see `kenney()`) to a dark-glyph +\n *             white-halo treatment so they read crisply on light AND dark\n *             canvases. Per-tool glyph map:\n *               move→pointer_a · hand→hand_open · comment→message_dots_square ·\n *               pen→drawing_pencil · shape→line_cross · eraser→drawing_eraser.\n *             text (I-beam) + sticky (folded-corner note) have no clean Kenney\n *             equivalent, so they are AUTHORED in the identical dark-glyph +\n *             white-halo treatment to keep one visual identity.\n *\n *             Delivered as CSS `cursor: url(\"data:image/svg+xml,…\") hx hy, fb`\n *             — no runtime dependency, no asset files. 32×32 is the\n *             cross-browser-safe ceiling; (hx, hy) is the click hotspot.\n */\n\nimport type { Tool } from './input-router.tsx';\n\n/** Build a CSS cursor value from an inline SVG + hotspot + native fallback. */\nfunction svgCursor(svg: string, hx: number, hy: number, fallback: string): string {\n  // encodeURIComponent is the safest escaping for a data: URI inside url(\"…\").\n  return `url(\"data:image/svg+xml,${encodeURIComponent(svg.trim())}\") ${hx} ${hy}, ${fallback}`;\n}\n\n// Phase 24 — 24px rendered box (down from 32) so cursors aren't oversized; the\n// glyph coords stay in the 32-unit viewBox and scale into 24px. Hotspots are\n// scaled to match (see the generator).\nconst W = `width='24' height='24' viewBox='0 0 32 32' xmlns='http://www.w3.org/2000/svg'`;\nconst INK = '#1f1f1f';\nconst HALO = \"stroke='#ffffff' stroke-linejoin='round' stroke-linecap='round'\";\n\n// Kenney CC0 glyph, recoloured to a FigJam-style **dark glyph + white halo**:\n// Kenney's outline band (`b`) is painted WHITE (the halo) and its inner fill\n// (`w`) is painted dark INK. Reads crisply on a LIGHT canvas (solid dark glyph)\n// AND a dark one (white halo edge).\nfunction kenney(b: string, w: string, transform?: string): string {\n  // Optional `<g transform>` for the drawing tools whose Kenney glyph needs\n  // re-orienting so the writing tip lands at the hotspot (user steer\n  // 2026-06-04: pen / highlighter \"kreslí pod koncem, ne na špičce\" → flipped so\n  // the nib points down-LEFT, top-right→bottom-left).\n  const open = transform ? `<g transform='${transform}'>` : '';\n  const close = transform ? '</g>' : '';\n  return `<svg ${W}>${open}<path fill='#ffffff' d='${b}'/><path fill='${INK}' d='${w}'/>${close}</svg>`;\n}\n\n// Vertical mirror about the 32-viewBox horizontal centre: (x,y) → (x, 32−y).\n// Applied to pen/highlighter so the glyph lies along the top-right→bottom-left\n// diagonal with the nib at bottom-left.\nconst FLIP_V = 'translate(0,32) scale(1,-1)';\n\n// move → Kenney `pointer_b` (user steer 2026-06-04 — the plain variant, not the\n// shaded one). Hotspot at the arrow tip (top).\nconst MOVE = svgCursor(\n  kenney(\n    'M10.25 8.25 L10.05 8.65 10 9 10 23.1 10.05 23.4 10.25 23.75 10.8 24 11.45 23.85 11.6 23.7 11.75 23.45 14.65 19.8 14.85 19.65 14.95 19.5 15.4 19.2 15.95 19.1 21.05 19.1 21.2 19.1 21.35 19.05 21.65 18.9 21.9 18.6 22 18.3 22 17.9 21.9 17.65 21.75 17.35 21.65 17.3 21.55 17.15 11.5 8.25 11.25 8.05 10.95 8 10.6 8.05 10.25 8.25 M9.15 6.6 L9.7 6.25 10 6.15 10.95 6 11.9 6.15 13 6.9 22.9 15.65 23 15.8 23.2 15.95 23.75 16.75 24 17.9 24 18.3 23.9 18.95 23.8 19.25 23.6 19.7 23.1 20.35 22.75 20.6 22.1 20.9 22.05 20.95 22 20.95 21.2 21.1 21.05 21.1 16.2 21.1 16.1 21.25 16.05 21.25 13.4 24.6 13.05 25.15 12.9 25.3 12.55 25.55 Q11.6 26.15 10.55 26 L10.5 26 Q9.65 25.85 9 25.3 L8.45 24.65 8.4 24.5 8.15 24.05 8 23.1 8 9 Q8 8.45 8.15 8.05 L8.25 7.75 8.45 7.35 9.15 6.6',\n    'M10.25 8.25 L10.6 8.05 10.95 8 11.25 8.05 11.5 8.25 21.55 17.15 21.65 17.3 21.75 17.35 21.9 17.65 22 17.9 22 18.3 21.9 18.6 21.65 18.9 21.35 19.05 21.2 19.1 21.05 19.1 15.95 19.1 15.4 19.2 14.95 19.5 14.85 19.65 14.65 19.8 11.75 23.45 11.6 23.7 11.45 23.85 10.8 24 10.25 23.75 10.05 23.4 10 23.1 10 9 10.05 8.65 10.25 8.25'\n  ),\n  8,\n  5,\n  'default'\n);\nconst HAND = svgCursor(\n  kenney(\n    'M28.55 17.8 Q29.4 20.3 28.75 22.8 L28.7 23 28.15 24.55 28.05 24.75 Q26.4 28.2 22.75 29.4 L22.45 29.5 18 29.9 17.75 29.85 Q15.8 29.25 13.8 28.1 L13.45 27.95 Q12 27.05 10.35 26.8 L10.25 26.75 7.9 26.7 7.8 26.7 Q6.1 26.9 4.8 25.8 L4.75 25.8 4.65 25.7 4.6 25.65 Q3.25 24.5 3.05 22.85 L3 22.75 Q2.8 20.95 4 19.5 5.05 18.15 6.75 17.95 L8.4 17.9 7.5 15.55 7.3 15.2 7.2 15 5 10.95 Q3.9 9.15 4.3 7.75 L4.4 7.5 Q4.75 6.15 6.45 5.2 9 3.65 11 5 11.05 4.1 11.5 3.45 12.15 2.1 14.2 1.6 L14.35 1.6 Q18.05 0.6 19.6 4.4 L19.65 4.55 Q20.75 3.65 22.7 3.75 L22.75 3.75 Q26.75 4 27 8.15 L27 8.25 27 8.35 27 8.45 Q26.9 10.75 27.1 12.6 27.15 14.65 28.2 16.75 L28.55 17.8 M26.65 18.4 L26.1 16.8 26.1 16.85 Q24.8 13.7 25 8.35 L25 8.25 Q24.85 5.9 22.6 5.75 20.7 5.65 20.4 7.35 L20.1 7.95 19.5 8.2 18.85 8.05 18.45 7.5 17.75 5.15 Q16.85 2.95 14.7 3.55 L14.65 3.55 Q12.55 4.05 13.15 6.15 L13.85 8.75 13.75 9.45 13.25 9.95 12.55 9.95 12 9.55 10.9 7.7 Q9.5 5.7 7.45 6.9 6.5 7.45 6.25 8.15 6.1 8.9 6.7 9.85 9.2 13.9 10.8 18.65 L10.8 19.3 10.4 19.8 9.75 19.95 Q8.35 19.8 6.95 19.95 6.1 20.05 5.55 20.75 4.9 21.55 5 22.55 5.15 23.55 6 24.2 L6.05 24.25 Q6.75 24.85 7.65 24.7 L7.7 24.7 10.65 24.8 Q12.7 25.15 14.45 26.2 L14.5 26.2 Q16.4 27.35 18.3 27.9 L22.05 27.5 22.1 27.5 Q24.95 26.55 26.25 23.85 L26.8 22.3 Q27.3 20.35 26.65 18.4',\n    'M26.65 18.4 Q27.3 20.35 26.8 22.3 L26.25 23.85 Q24.95 26.55 22.1 27.5 L22.05 27.5 18.3 27.9 Q16.4 27.35 14.5 26.2 L14.45 26.2 Q12.7 25.15 10.65 24.8 L7.7 24.7 7.65 24.7 Q6.75 24.85 6.05 24.25 L6 24.2 Q5.15 23.55 5 22.55 4.9 21.55 5.55 20.75 6.1 20.05 6.95 19.95 8.35 19.8 9.75 19.95 L10.4 19.8 10.8 19.3 10.8 18.65 Q9.2 13.9 6.7 9.85 6.1 8.9 6.25 8.15 6.5 7.45 7.45 6.9 9.5 5.7 10.9 7.7 L12 9.55 12.55 9.95 13.25 9.95 13.75 9.45 13.85 8.75 13.15 6.15 Q12.55 4.05 14.65 3.55 L14.7 3.55 Q16.85 2.95 17.75 5.15 L18.45 7.5 18.85 8.05 19.5 8.2 20.1 7.95 20.4 7.35 Q20.7 5.65 22.6 5.75 24.85 5.9 25 8.25 L25 8.35 Q24.8 13.7 26.1 16.85 L26.1 16.8 26.65 18.4'\n  ),\n  12,\n  12,\n  'grab'\n);\n// comment → Kenney `message_round` (user steer 2026-06-04). Hotspot at the\n// tail tip (bottom-centre), where the comment pin is dropped.\nconst COMMENT = svgCursor(\n  kenney(\n    'M28 14 Q28 9.85 24.45 6.9 20.95 4 16 4 11.05 4 7.5 6.9 L7.45 7 Q4 9.9 4 14 4 18.15 7.55 21.05 L7.5 21.05 Q9.2 22.45 11.2 23.2 L15.3 27.3 16 27.6 16.7 27.3 20.85 23.2 Q22.7 22.45 24.3 21.15 L24.45 21.05 Q28 18.15 28 14 M25.75 5.35 Q30.05 8.95 30 14 30.05 19.05 25.75 22.6 L25.4 22.85 Q23.8 24.1 22 24.9 L18.1 28.75 18.15 28.75 Q17.2 29.6 16 29.6 14.8 29.6 13.85 28.75 L13.9 28.75 10 24.9 6.6 22.85 6.25 22.6 Q1.95 19.05 2 14 1.95 8.95 6.25 5.35 10.3 2 16 2 21.7 2 25.75 5.35',\n    'M28 14 Q28 18.15 24.45 21.05 L24.3 21.15 Q22.7 22.45 20.85 23.2 L16.7 27.3 16 27.6 15.3 27.3 11.2 23.2 Q9.2 22.45 7.5 21.05 L7.55 21.05 Q4 18.15 4 14 4 9.9 7.45 7 L7.5 6.9 Q11.05 4 16 4 20.95 4 24.45 6.9 28 9.85 28 14'\n  ),\n  12,\n  21,\n  'crosshair'\n);\n// pen → Kenney `drawing_pen`, mirrored vertically (FLIP_V) so the nib points\n// down-LEFT (top-right→bottom-left diagonal). Source gradient-shade path dropped.\n// Hotspot at the nib, bottom-left.\nconst PEN = svgCursor(\n  kenney(\n    'M4 13.1 L4 6 Q4 5.15 4.6 4.6 5.15 4 6 4 L13.1 4 Q13.95 4 14.55 4.6 L28.65 18.75 Q29.8 19.9 29.75 21.45 L29.75 21.6 29.75 21.7 Q29.75 23.2 28.7 24.35 L24.45 28.65 24.35 28.75 Q23.15 29.85 21.65 29.8 L21.55 29.8 21.4 29.8 Q20.2 29.8 19.25 29.15 L18 29.35 Q16.6 29.4 15.25 28 L15.2 27.95 8.2 20.95 Q7.6 20.35 7.6 19.55 7.6 18.7 8.2 18.1 L4.6 14.5 Q4 13.9 4 13.1 M19.5 26.65 L20.1 27.25 Q20.7 27.85 21.5 27.8 22.35 27.85 23 27.25 L27.25 22.95 Q27.8 22.35 27.75 21.55 27.8 20.75 27.2 20.15 L13.1 6 6 6 6 13.1 12.35 19.45 9.6 19.5 16.65 26.55 Q18.05 28.05 19.5 26.65 M8.05 12.3 L8 8 12.25 8.05 13.8 9.6 9.6 13.85 8.05 12.3 M15.25 11.05 L23 18.8 18.8 23.05 11.05 15.3 15.25 11.05',\n    'M15.25 11.05 L11.05 15.3 18.8 23.05 23 18.8 15.25 11.05 M12.35 19.45 L6 13.1 6 6 13.1 6 27.2 20.15 Q27.8 20.75 27.75 21.55 27.8 22.35 27.25 22.95 L23 27.25 Q22.35 27.85 21.5 27.8 20.7 27.85 20.1 27.25 L19.5 26.65 12.35 19.45 M8.05 12.3 L9.6 13.85 13.8 9.6 12.25 8.05 8 8 8.05 12.3',\n    FLIP_V\n  ),\n  6,\n  18,\n  'crosshair'\n);\n// highlighter → Kenney `drawing_pencil`, also mirrored vertically (distinct from\n// the pen glyph). Hotspot at the lead tip, bottom-left.\nconst HIGHLIGHTER = svgCursor(\n  kenney(\n    'M5.15 10.85 Q4 9.65 4 8.1 L4 7.95 4 7.85 Q3.95 6.2 5.1 5.15 6.25 4 7.85 4 L7.95 4 8.1 4 Q9.65 4 10.85 5.15 L11 5.3 14.3 5.25 Q15.15 5.25 15.75 5.85 L29.9 20 Q31 21.15 31 22.75 L31 22.85 31 23 Q31.05 24.5 29.9 25.7 L29.55 25.95 25.65 29.9 25.65 29.95 Q24.45 31.1 22.75 31.1 21.2 31.15 20 29.95 L5.85 15.8 Q5.25 15.2 5.25 14.35 L5.25 10.95 5.15 10.85 M19.95 24.2 L18.55 22.8 22.8 18.55 24.2 19.95 19.95 24.2 M28.45 21.4 L14.3 7.25 10.15 7.3 9.4 6.55 Q8.8 5.95 7.95 6 7.1 5.95 6.5 6.55 5.95 7.1 6 7.95 5.95 8.8 6.55 9.4 L7.25 10.1 7.25 14.35 21.4 28.5 Q22 29.1 22.75 29.1 23.6 29.1 24.2 28.5 L28.45 24.25 Q29.05 23.65 29 22.85 29.05 22 28.45 21.4 M9.25 13.5 L9.25 9.3 13.5 9.25 14.3 10.05 10.05 14.3 9.25 13.5 M17.15 21.4 L11.5 15.75 15.75 11.5 21.4 17.15 17.15 21.4',\n    'M17.15 21.4 L21.4 17.15 15.75 11.5 11.5 15.75 17.15 21.4 M28.45 21.4 Q29.05 22 29 22.85 29.05 23.65 28.45 24.25 L24.2 28.5 Q23.6 29.1 22.75 29.1 22 29.1 21.4 28.5 L7.25 14.35 7.25 10.1 6.55 9.4 Q5.95 8.8 6 7.95 5.95 7.1 6.5 6.55 7.1 5.95 7.95 6 8.8 5.95 9.4 6.55 L10.15 7.3 14.3 7.25 28.45 21.4 M19.95 24.2 L24.2 19.95 22.8 18.55 18.55 22.8 19.95 24.2 M9.25 13.5 L10.05 14.3 14.3 10.05 13.5 9.25 9.25 9.3 9.25 13.5',\n    FLIP_V\n  ),\n  6,\n  18,\n  'crosshair'\n);\nconst CROSSHAIR = svgCursor(\n  kenney(\n    'M17 2 Q18.2 2 19.15 2.9 20 3.8 20 5 L20 12 27 12 Q28.2 12 29.15 12.9 30 13.8 30 15 L30 17 Q30 18.2 29.15 19.15 28.2 20 27 20 L20 20 20 27 Q20 28.2 19.15 29.15 18.2 30 17 30 L15 30 Q13.8 30 12.9 29.15 12 28.2 12 27 L12 20 5 20 Q3.8 20 2.9 19.15 2 18.2 2 17 L2 15 Q2 13.8 2.9 12.9 3.8 12 5 12 L12 12 12 5 Q12 3.8 12.9 2.9 13.8 2 15 2 L17 2 M14 27 L14.3 27.7 Q14.6 28 15 28 L17 28 17.7 27.7 18 27 18 18.05 18.05 18 27 18 Q27.4 18 27.7 17.7 L28 17 28 15 27.7 14.3 Q27.4 14 27 14 L18 14 18 5 17.7 4.3 17 4 15 4 Q14.6 4 14.3 4.3 14 4.6 14 5 L14 14 5 14 Q4.6 14 4.3 14.3 4 14.6 4 15 L4 17 Q4 17.4 4.3 17.7 4.6 18 5 18 L14 18 14 27',\n    'M14 27 L14 18 5 18 Q4.6 18 4.3 17.7 4 17.4 4 17 L4 15 Q4 14.6 4.3 14.3 4.6 14 5 14 L14 14 14 5 Q14 4.6 14.3 4.3 14.6 4 15 4 L17 4 17.7 4.3 18 5 18 14 27 14 Q27.4 14 27.7 14.3 L28 15 28 17 27.7 17.7 Q27.4 18 27 18 L18.05 18 18 18.05 18 27 17.7 27.7 17 28 15 28 Q14.6 28 14.3 27.7 L14 27'\n  ),\n  12,\n  12,\n  'crosshair'\n);\nconst ERASER = svgCursor(\n  kenney(\n    'M3.9 11.35 Q2.3 12.5 3.7 13.9 L16.4 26.65 Q17.85 28.05 19.45 26.9 L27.65 21.15 Q29.3 20 27.85 18.6 L15.15 5.85 Q13.75 4.45 12.1 5.6 L3.9 11.35 M1.05 12.4 Q1 10.95 2.75 9.75 L10.95 4 10.95 3.95 Q14 1.85 16.6 4.45 L29.3 17.2 Q30.8 18.65 30.55 20.1 30.55 21.55 28.8 22.8 L20.6 28.55 20.65 28.55 Q17.7 30.65 15 28.1 L15 28.05 2.3 15.3 2.3 15.35 Q0.8 13.85 1.05 12.4 M13.5 7 L19.85 13.35 11.65 19.15 5.3 12.75 13.5 7',\n    'M13.5 7 L5.3 12.75 11.65 19.15 19.85 13.35 13.5 7 M3.9 11.35 L12.1 5.6 Q13.75 4.45 15.15 5.85 L27.85 18.6 Q29.3 20 27.65 21.15 L19.45 26.9 Q17.85 28.05 16.4 26.65 L3.7 13.9 Q2.3 12.5 3.9 11.35'\n  ),\n  6,\n  14,\n  'cell'\n);\n\n// Text — a classic I-beam (vertical stem + top/bottom serifs). Authored in the\n// same dark-INK glyph + white-HALO treatment as the Kenney glyphs (Kenney's\n// pointer_i reads as a small bracket, not an I-beam). Hotspot dead-centre.\nconst TEXT = svgCursor(\n  `<svg ${W}><path d='M16 4V28M11 4H21M11 28H21' fill='none' ${HALO} stroke-width='5'/><path d='M16 4V28M11 4H21M11 28H21' fill='none' stroke='${INK}' stroke-width='2.25' stroke-linecap='round'/></svg>`,\n  12,\n  12,\n  'text'\n);\n\n// Sticky — a note with a peeled/folded top-right corner (the universal sticky\n// glyph). Authored in the same treatment (Kenney has no sticky-note). Hotspot\n// at the note's top-left, where the note is dropped.\nconst STICKY = svgCursor(\n  `<svg ${W}><path d='M6 5H21L26 10V27H6Z' fill='${INK}' ${HALO} stroke-width='2.5'/><path d='M21 5V11H26' fill='none' ${HALO} stroke-width='2.25'/></svg>`,\n  5,\n  5,\n  'crosshair'\n);\n\n/**\n * Tool → CSS cursor value. Phase 24 — every tool ships a Kenney glyph (no\n * system fallback for `move` anymore; the brief is ONE unified library). The\n * single Shape tool uses the crosshair; `rect`/`ellipse` stay keyed (still in\n * the Tool union) but are no longer directly selectable.\n */\n// Frozen so the docstring's \"frozen map\" guarantee is real: `resolveToolCursor`\n// is a pure lookup into this object, and freezing forecloses any same-realm\n// shell-side code ever mutating an entry out from under the lookup (the canvas\n// runs cross-origin and can't reach it regardless — this is belt-and-braces).\nexport const TOOL_CURSORS: Record<Tool, string> = Object.freeze({\n  move: MOVE,\n  hand: HAND,\n  comment: COMMENT,\n  pen: PEN,\n  // FigJam v3 — the section container draws like a shape (crosshair glyph).\n  section: CROSSHAIR,\n  // Highlighter = Kenney `drawing_pencil` rot180; pen = `drawing_pen` rot180 —\n  // distinct glyphs, both from the Kenney pack (user steer 2026-06-04).\n  highlighter: HIGHLIGHTER,\n  shape: CROSSHAIR,\n  rect: CROSSHAIR,\n  ellipse: CROSSHAIR,\n  sticky: STICKY,\n  arrow: CROSSHAIR,\n  text: TEXT,\n  eraser: ERASER,\n});\n\n/**\n * Resolve a tool token — received over the **untrusted** canvas→shell\n * `tool-cursor` postMessage bridge — to a TRUSTED cursor string from\n * {@link TOOL_CURSORS}, or `null` when the token is not a known tool.\n *\n * The app shell applies the value this RETURNS, never the raw message. That is\n * the security boundary: a malicious *synced* canvas (DDR-054 — canvas content\n * is untrusted and may be hub-pushed) can call\n * `window.parent.postMessage({ dgn: 'tool-cursor', tool: … }, '*')` directly,\n * bypassing the honest `ToolProvider` sender. By echoing only a token and\n * looking the cursor up here, the worst that canvas can do is pick *which*\n * known, always-visible glyph the shell shows — it can no longer smuggle an\n * invisible / displaced / zero-content SVG cursor that would act as a\n * clickjacking aid over the un-CSP'd shell (phase-24 ethical-hacker Finding 2;\n * see DDR-067). `hasOwnProperty` (not `in`) keeps `constructor`/`__proto__`\n * off the allowlist, and the `[a-z-]` shape gate bars anything but a tool id.\n */\nexport function resolveToolCursor(token: unknown): string | null {\n  if (typeof token !== 'string' || !/^[a-z-]+$/.test(token)) return null;\n  if (!Object.hasOwn(TOOL_CURSORS, token)) return null;\n  return TOOL_CURSORS[token as Tool];\n}\n"
  ],
  "mappings": "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",
  "debugId": "7F1482847AF8ADD864756E2164756E21",
  "names": []
}