@1agh/maude 1.2.0 → 1.3.1

package/apps/studio/sync/writer-registry.ts

@@ -0,0 +1,236 @@
+// The executable half of the persistent-writer registry — DDR-241, plan T6.
+//
+// `docs/architecture/project-writer-registry.md` explains every writer; this
+// module is the part a test can hold the code to. Every `/_api/*` route the
+// studio serves is classified here by HOW its persistent effect reaches the
+// project in accepted-revisions mode. A route that is not listed fails
+// `test/sync-writer-registry.test.ts` — a new mutating route cannot ship
+// without someone deciding which lane carries it.
+//
+// Classes:
+//   read        — no persistent project effect.
+//   lane        — rewrites canvas source/meta/annotations/comments; reaches the
+//                 project as a `lane.replace` proposal (watcher import with the
+//                 base announced by `activity:suppress`, or an API hook that
+//                 hands the runtime its base).
+//   structural  — canvas/folder create, move, delete: one manifest action.
+//   file-plane  — assets, media sidecars, support files: the file plane's own
+//                 CAS journal (DDR-226), not the canvas kernel (DDR-241 §8).
+//   git         — operates on the checkout's Git graph; never a project action.
+//   local       — this machine only: credentials, caches, jobs, activity, UI.
+
+export type WriterClass = 'read' | 'lane' | 'structural' | 'file-plane' | 'git' | 'local';
+
+export interface WriterEntry {
+  class: WriterClass;
+  /** Registry row(s) in project-writer-registry.md. */
+  rows?: string;
+  /** How the effect travels in accepted mode (lane / structural only). */
+  via?: string;
+  /** The test that proves it (lane / structural only). */
+  test?: string;
+}
+
+const LANE_SOURCE = {
+  class: 'lane',
+  via: 'source write announced by activity:suppress → watcher import → html lane.replace with the announced base',
+  test: 'test/sync-accepted-projection.test.ts',
+} as const;
+
+export const WRITER_REGISTRY: Record<string, WriterEntry> = {
+  // --- canvas source edits (S01–S18, V01–V10)
+  '/_api/edit-text': { ...LANE_SOURCE, rows: 'S01' },
+  '/_api/edit-css': { ...LANE_SOURCE, rows: 'S02' },
+  '/_api/edit-attr': { ...LANE_SOURCE, rows: 'S03' },
+  '/_api/reorder': { ...LANE_SOURCE, rows: 'S04' },
+  '/_api/delete-element': { ...LANE_SOURCE, rows: 'S05' },
+  '/_api/insert-element': { ...LANE_SOURCE, rows: 'S06' },
+  '/_api/duplicate-element': { ...LANE_SOURCE, rows: 'S07' },
+  '/_api/convert-to-absolute': { ...LANE_SOURCE, rows: 'S08' },
+  '/_api/detach-component': { ...LANE_SOURCE, rows: 'S09' },
+  '/_api/insert-artboard': { ...LANE_SOURCE, rows: 'S10' },
+  '/_api/duplicate-artboard': { ...LANE_SOURCE, rows: 'S11' },
+  '/_api/delete-artboard': { ...LANE_SOURCE, rows: 'S12' },
+  '/_api/resize-artboard': { ...LANE_SOURCE, rows: 'S13' },
+  '/_api/set-artboard-hug': { ...LANE_SOURCE, rows: 'S14' },
+  '/_api/set-artboard-style': { ...LANE_SOURCE, rows: 'S15' },
+  '/_api/set-artboard-kind': { ...LANE_SOURCE, rows: 'S16' },
+  '/_api/set-artboard-label': { ...LANE_SOURCE, rows: 'S16' },
+  '/_api/set-artboard-guides': { ...LANE_SOURCE, rows: 'S17' },
+  '/_api/set-artboard-print': { ...LANE_SOURCE, rows: 'S17' },
+  '/_api/reorder-revert': { ...LANE_SOURCE, rows: 'S18' },
+  '/_api/retime-sequence': { ...LANE_SOURCE, rows: 'V01' },
+  '/_api/remove-sequence': { ...LANE_SOURCE, rows: 'V02' },
+  '/_api/insert-sequence': { ...LANE_SOURCE, rows: 'V03' },
+  '/_api/reorder-sequence': { ...LANE_SOURCE, rows: 'V04' },
+  '/_api/toggle-hide': { ...LANE_SOURCE, rows: 'V05' },
+  '/_api/edit-array-src': { ...LANE_SOURCE, rows: 'V06' },
+  '/_api/clip-edit': { ...LANE_SOURCE, rows: 'V07–V10' },
+  // --- shared meta, annotations, comments (S19, S23, S24)
+  '/_api/canvas-meta': {
+    class: 'lane',
+    rows: 'S19',
+    via: 'onMetaChanged hook → meta lane.replace with the replaced file as base; camera/overlays/locked stay local',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/annotations': {
+    class: 'lane',
+    rows: 'S23',
+    via: 'onAnnotationsChanged hook → annotations lane.replace with the base the layer sent',
+    test: 'test/sync-accepted-projection.test.ts',
+  },
+  // --- accepted history (T27/T28)
+  '/_api/project/history': { class: 'read' },
+  '/_api/project/restore': {
+    class: 'lane',
+    rows: 'X15',
+    via: 'history.restore — a NEW action restoring the canvas lanes (not comments) to a revision',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/project/conflict': {
+    class: 'lane',
+    rows: 'X15',
+    via: 'mine: html lane.replace on top of the accepted version (a new action); theirs: accepted body back to disk',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/project/ai-action': {
+    class: 'lane',
+    rows: 'I02',
+    via: 'publish: the held AI stage as ONE history action (lane.replace ops); discard: accepted value back to disk',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/project/undo': {
+    class: 'lane',
+    rows: 'S18',
+    via: 'history.undo/redo — effect-aware compensation of one of this actor’s actions',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  // --- manifest (S20–S22)
+  '/_api/canvas': {
+    class: 'structural',
+    rows: 'S20',
+    via: 'create: cold start doc.create; delete: canvas-deleted → doc.delete; folders: dir.delete',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/fs-move': {
+    class: 'structural',
+    rows: 'S21',
+    via: 'retireForMove → doc.move; folders: proposeFolder dir.move',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/fs-mkdir': {
+    class: 'structural',
+    rows: 'S22',
+    via: 'proposeFolder dir.create before mkdir',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  '/_api/design/init': {
+    class: 'structural',
+    rows: 'I12',
+    via: 'scaffolded canvases join by cold start doc.create',
+    test: 'test/sync-accepted-runtime.test.ts',
+  },
+  // --- file plane (S25–S30, I04–I11)
+  '/_api/photo-edit': { class: 'file-plane', rows: 'S25' },
+  '/_api/footage': { class: 'file-plane', rows: 'S26' },
+  '/_api/asset': { class: 'file-plane', rows: 'S27' },
+  '/_api/assets': { class: 'file-plane', rows: 'S27' },
+  '/_api/import-asset': { class: 'file-plane', rows: 'S28/I08' },
+  '/_api/import-brand': { class: 'file-plane', rows: 'S28/I07' },
+  '/_api/figma/import': { class: 'file-plane', rows: 'I04/I05 (canvases join by cold start)' },
+  '/_api/figma/explode': { class: 'file-plane', rows: 'I04/I05 (canvases join by cold start)' },
+  '/_api/generate-jobs': { class: 'file-plane', rows: 'S29' },
+  '/_api/generate/audio-reuse': { class: 'file-plane', rows: 'S30' },
+  '/_api/stickers': { class: 'file-plane', rows: 'S27' },
+  '/_api/generate/prefs': { class: 'local', rows: 'S31 (config.assign schema gap)' },
+  // --- git (H09/H10)
+  '/_api/git/branch': { class: 'git', rows: 'H10' },
+  '/_api/git/branches': { class: 'read' },
+  '/_api/git/checkout': { class: 'git', rows: 'H09' },
+  '/_api/git/commit': { class: 'git', rows: 'H10' },
+  '/_api/git/diff': { class: 'read' },
+  '/_api/git/discard': { class: 'git', rows: 'H09' },
+  '/_api/git/fetch': { class: 'git', rows: 'H10' },
+  '/_api/git/fold': { class: 'git', rows: 'H09' },
+  '/_api/git/log': { class: 'read' },
+  '/_api/git/pull': { class: 'git', rows: 'H09' },
+  '/_api/git/push': { class: 'git', rows: 'H10' },
+  '/_api/git/resolve': { class: 'git', rows: 'H09' },
+  '/_api/git/status': { class: 'read' },
+  '/_api/github/clone': { class: 'git', rows: 'H10' },
+  '/_api/github/create-project': { class: 'local', rows: 'I12' },
+  '/_api/github/create-repo': { class: 'local' },
+  '/_api/github/identity': { class: 'local' },
+  '/_api/github/invite': { class: 'local' },
+  '/_api/github/repos': { class: 'read' },
+  '/_api/project/create-local': { class: 'local', rows: 'I12' },
+  '/_api/projects/prepare': {
+    class: 'local',
+    rows: 'H13 (credential + project description for a managed copy)',
+  },
+  // --- reads
+  '/_api/canvas-source': { class: 'read' },
+  '/_api/comp-clips': { class: 'read' },
+  '/_api/component-map': { class: 'read' },
+  '/_api/edit-scope': { class: 'read' },
+  '/_api/git-committers': { class: 'read' },
+  '/_api/git-user': { class: 'read' },
+  '/_api/preflight': { class: 'read' },
+  '/_api/setup-readiness': { class: 'read' },
+  '/_api/whats-new': { class: 'read' },
+  '/_api/figma/probe': { class: 'read' },
+  '/_api/figma/status': { class: 'read' },
+  '/_api/generate/providers': { class: 'read' },
+  '/_api/generate/audio-search': { class: 'read' },
+  '/_api/export-history': { class: 'read' },
+  // --- this machine only
+  '/_api/acp/activity': { class: 'local' },
+  '/_api/acp/attachment': { class: 'local' },
+  '/_api/acp/chat': { class: 'local' },
+  '/_api/acp/chats': { class: 'local' },
+  '/_api/acp/focus': { class: 'local' },
+  '/_api/acp/running': { class: 'local' },
+  '/_api/acp/status': { class: 'local' },
+  '/_api/ai': { class: 'local', rows: 'I02' },
+  '/_api/ai/end': { class: 'local', rows: 'I02' },
+  '/_api/ai/heartbeat': { class: 'local', rows: 'I02' },
+  '/_api/ai/start': { class: 'local', rows: 'I02' },
+  '/_api/claude/install': { class: 'local' },
+  '/_api/claude/install-status': { class: 'local' },
+  '/_api/claude/signin': { class: 'local' },
+  '/_api/claude/signin-cancel': { class: 'local' },
+  '/_api/claude/signin-status': { class: 'local' },
+  '/_api/cloud/attach': { class: 'local' },
+  '/_api/cloud/attach/code': { class: 'local' },
+  '/_api/cloud/detach': { class: 'local' },
+  '/_api/cloud/history': { class: 'read' },
+  '/_api/cloud/projects': { class: 'read' },
+  '/_api/cloud/signin/poll': { class: 'local' },
+  '/_api/cloud/signin/start': { class: 'local' },
+  '/_api/cloud/signout': { class: 'local' },
+  '/_api/cloud/status': { class: 'read' },
+  '/_api/debug-bundle': { class: 'local' },
+  '/_api/export': { class: 'local' },
+  '/_api/export-assemble': { class: 'local' },
+  '/_api/export-jobs': { class: 'local' },
+  '/_api/export-jobs/download': { class: 'local' },
+  '/_api/export-warmup': { class: 'local' },
+  '/_api/figma/connect': { class: 'local' },
+  '/_api/generate/keyframe-model': { class: 'local' },
+  '/_api/generate/keys': { class: 'local' },
+  '/_api/generate/whisper-model': { class: 'local' },
+  '/_api/hub/link': { class: 'local' },
+  '/_api/report': { class: 'local' },
+  '/_api/report-fallback': { class: 'local' },
+  '/_api/shell-shot': { class: 'local' },
+  '/_api/sync/cancel-assets': { class: 'local' },
+  '/_api/sync/ownership': { class: 'local' },
+  '/_api/sync/resync': { class: 'local', rows: 'X16' },
+  '/_api/sync/offline': { class: 'local', rows: 'T19 (pull the whole file plane now)' },
+  '/_api/sync/settings': { class: 'local' },
+  '/_api/sync/trash': { class: 'local', rows: 'X15 (restore re-enters through cold start)' },
+  '/_api/timeline-media': { class: 'local' },
+  '/_api/ui-prefs': { class: 'local' },
+  '/_api/workspace/disclosure': { class: 'local' },
+  '/_api/workspace/sign-in': { class: 'local' },
+};

package/apps/studio/text-caret.ts

@@ -76,6 +76,41 @@ export function placeCaretAt(
   }
 }
 
+/**
+ * Collapse an ENTRY select-all to the end of the content, if that is what the
+ * selection still is. issue-106: keyboard entry into a text surface (select the
+ * stroke, press Enter) leaves `placeCaretAt`'s select-all fallback in place, so
+ * the first keystroke replaces the whole body — which is exactly what the
+ * retype/rename convention wants for a typed CHARACTER, but never for
+ * Shift+Enter, whose entire documented meaning is "add a new line". Without
+ * this, Shift+Enter deleted the note and left a blank line in its place.
+ *
+ * Deliberately narrow: only a selection whose boundaries are still BOTH ends of
+ * the editable is collapsed. A user's own drag-selection or a partial range is
+ * left alone, so ordinary "replace the selected words" editing keeps native
+ * semantics. Returns true when it collapsed something.
+ */
+export function collapseEntrySelectAll(editable: HTMLElement, win: Window): boolean {
+  try {
+    const sel = win.getSelection();
+    if (!sel || sel.rangeCount === 0 || sel.isCollapsed) return false;
+    const cur = sel.getRangeAt(0);
+    const all = editable.ownerDocument.createRange();
+    all.selectNodeContents(editable);
+    // Range.START_TO_START / END_TO_END via the instance so no global lookup is
+    // needed (the editable may live in another document/realm).
+    if (cur.compareBoundaryPoints(cur.START_TO_START, all) !== 0) return false;
+    if (cur.compareBoundaryPoints(cur.END_TO_END, all) !== 0) return false;
+    all.collapse(false); // to the end
+    sel.removeAllRanges();
+    sel.addRange(all);
+    return true;
+  } catch {
+    /* selection API unavailable */
+    return false;
+  }
+}
+
 const STYLE_ID = 'maude-caret-css';
 
 const CARET_CSS = `

package/apps/studio/undo-hud.tsx

@@ -1,94 +1,16 @@
-/**
- * @file       undo-hud.tsx — top-right toast announcing the last undo edit
- * @scope      apps/studio/undo-hud.tsx
- * @purpose    Subscribes to `useUndoStack().lastLabel` + `.lastTick` and
- *             surfaces a 1.2 s aria-live toast so the user (and a screen
- *             reader) knows which edit just got pushed / undone / redone.
- *
- * a11y. The toast renders into `aria-live="polite"` so a screen reader
- * announces "Undo: move 3 artboards" without interrupting in-flight speech.
- * Pointer events are disabled — the HUD is informational only and must
- * never absorb clicks meant for the canvas behind it.
- */
-
-import { useEffect, useState } from 'react';
-
+/** Announces canvas edit/undo/redo operations through the shared toast stack. */
+import { useEffect, useRef } from 'react';
+import { showCanvasToast } from './canvas-notifications.tsx';
 import { useUndoStackOptional } from './use-undo-stack.tsx';
 
-const HUD_CSS = `
-.dc-undo-hud {
-  position: fixed;
-  top: 16px;
-  right: 16px;
-  z-index: 7;
-  pointer-events: none;
-  padding: 6px 10px;
-  background: var(--maude-chrome-bg-2, rgba(20, 20, 20, 0.85));
-  color: var(--maude-chrome-fg-1, rgba(255, 255, 255, 0.85));
-  border: 1px solid var(--maude-chrome-border, rgba(255, 255, 255, 0.08));
-  border-radius: 6px;
-  font: 11px var(--maude-chrome-font-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
-  letter-spacing: 0.02em;
-  user-select: none;
-  opacity: 0;
-  transform: translateY(-4px);
-  transition: opacity 200ms linear, transform 200ms ease-out;
-}
-.dc-undo-hud[data-visible="true"] {
-  opacity: 1;
-  transform: translateY(0);
-  transition-duration: 120ms;
-}
-@media (prefers-reduced-motion: reduce) {
-  .dc-undo-hud {
-    transition-duration: 1ms !important;
-  }
-}
-`.trim();
-
-function ensureStyles(): void {
-  if (typeof document === 'undefined') return;
-  if (document.getElementById('dc-undo-hud-css')) return;
-  const s = document.createElement('style');
-  s.id = 'dc-undo-hud-css';
-  s.textContent = HUD_CSS;
-  document.head.appendChild(s);
-}
-
-/** Auto-dismiss timeout — matches the post-Wave-3 toast cadence. */
-const DISMISS_MS = 1200;
-
 export function UndoHud() {
-  ensureStyles();
   const undo = useUndoStackOptional();
-  const [visible, setVisible] = useState(false);
-
-  // Bump visibility every time `lastTick` increments — same tick value means
-  // the underlying state did NOT change (provider's no-op fallback returns
-  // `lastTick: 0` constantly, so the HUD stays hidden when no provider).
-  const tick = undo.lastTick;
-  const label = undo.lastLabel;
-
+  const lastTick = useRef(0);
   useEffect(() => {
-    if (tick === 0 || !label) {
-      setVisible(false);
-      return;
-    }
-    setVisible(true);
-    const id = window.setTimeout(() => setVisible(false), DISMISS_MS);
-    return () => window.clearTimeout(id);
-  }, [tick, label]);
-
-  return (
-    <div
-      className="dc-undo-hud"
-      data-visible={visible ? 'true' : 'false'}
-      role="status"
-      aria-live="polite"
-      aria-atomic="true"
-    >
-      {label ?? ''}
-    </div>
-  );
+    if (!undo.lastTick || !undo.lastLabel || lastTick.current === undo.lastTick) return;
+    lastTick.current = undo.lastTick;
+    showCanvasToast(undo.lastLabel, 'undo');
+  }, [undo.lastTick, undo.lastLabel]);
+  return null;
 }
 UndoHud.displayName = 'UndoHud';

package/apps/studio/use-canvas-media-drop.tsx

@@ -22,6 +22,9 @@
  */
 
 import { useEffect } from 'react';
+import { showCanvasToast } from './canvas-notifications.tsx';
+
+export { showCanvasToast } from './canvas-notifications.tsx';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Pure helpers (exported for unit tests)
@@ -194,25 +197,6 @@ export async function uploadAsset(file: Blob): Promise<{ path: string } | { erro
 // Transient toast (no React state — self-contained DOM, mirrors ensure*Styles)
 
 const TOAST_CSS = `
-.dc-media-toast {
-  position: fixed;
-  left: 50%;
-  bottom: 108px;
-  transform: translateX(-50%);
-  z-index: 9;
-  max-width: 360px;
-  padding: 8px 14px;
-  border-radius: 8px;
-  background: #26262b;
-  color: #fff;
-  font-family: var(--maude-chrome-font-mono, ui-monospace, SFMono-Regular, Menlo, monospace);
-  font-size: 12px;
-  box-shadow: 0 8px 28px rgba(0,0,0,0.34);
-  opacity: 0;
-  transition: opacity 140ms ease;
-  pointer-events: none;
-}
-.dc-media-toast[data-show="1"] { opacity: 1; }
 /* Drop affordance — a focus-accent inset frame while a media drag is over the
    canvas, so the surface reads as a drop target. */
 .dc-media-dragover::after {
@@ -224,9 +208,6 @@ const TOAST_CSS = `
   border-radius: 12px;
   pointer-events: none;
 }
-@media (prefers-reduced-motion: reduce) {
-  .dc-media-toast { transition: none; }
-}
 /* feature-4 (2026-07-19) — sandbox-safe confirm dialog (window.confirm is
    silently blocked in the allow-modals-less canvas iframe). HUD-token styled. */
 .dc-confirm-backdrop {
@@ -364,22 +345,6 @@ export function canvasConfirm(
   });
 }
 
-/** Show a brief auto-dismissing toast in the canvas (e.g. an upload failure). */
-export function showCanvasToast(message: string): void {
-  if (typeof document === 'undefined') return;
-  ensureMediaStyles();
-  const el = document.createElement('div');
-  el.className = 'dc-media-toast';
-  el.setAttribute('role', 'status');
-  el.textContent = message;
-  document.body.appendChild(el);
-  requestAnimationFrame(() => el.setAttribute('data-show', '1'));
-  setTimeout(() => {
-    el.setAttribute('data-show', '0');
-    setTimeout(() => el.remove(), 200);
-  }, 2600);
-}
-
 // ─────────────────────────────────────────────────────────────────────────────
 // Hook
 
@@ -414,7 +379,7 @@ export async function uploadAndAnnounceMedia(
   const sizeMb = file.size / (1024 * 1024);
   const res = await uploadAsset(file);
   if ('error' in res) {
-    showCanvasToast(`Couldn't add ${mediaKind}: ${res.error}`);
+    showCanvasToast(`Couldn't add ${mediaKind}: ${res.error}`, 'error');
     return;
   }
   const snippet = mediaSnippet(mediaKind, res.path);

package/apps/studio/use-tool-mode.tsx

@@ -18,6 +18,7 @@ import {
   useContext,
   useEffect,
   useMemo,
+  useRef,
   useState,
 } from 'react';
 
@@ -53,6 +54,9 @@ export type ShapeKind = 'square' | 'rounded' | 'circle' | 'diamond' | 'triangle'
  */
 export type CanvasMode = 'preview' | 'edit';
 
+/** Document event two provider instances keep one active tool through. */
+export const TOOL_SYNC_EVENT = 'maude:tool-sync';
+
 /** The resting tool each mode arms (and returns to via `resetTool`). */
 export const MODE_DEFAULT_TOOL: Readonly<Record<CanvasMode, Tool>> = Object.freeze({
   preview: 'browse',
@@ -231,6 +235,46 @@ export function ToolProvider({
   // FigJam look); sharp squares stay one popover click away.
   const [shapeKind, setShapeKind] = useState<ShapeKind>('rounded');
 
+  // ONE ACTIVE TOOL PER CANVAS DOCUMENT, across provider instances.
+  //
+  // A UI canvas carries TWO providers: the comment-mount layer's (it owns the
+  // comment drop) and canvas-lib's own (it owns the palette) — separate
+  // bundles, so separate contexts. They used to converge only through a tool
+  // KEYDOWN, which both routers see; a palette CLICK reached canvas-lib's
+  // provider alone. So "Comment" in the palette lit up while the comment
+  // layer stayed in browse, and clicking the canvas dropped nothing — you had
+  // to know to press C (plan T31/L11). A change here is announced on the
+  // document and every other instance adopts it. The boot posture is NOT
+  // announced (the two instances deliberately boot differently — see
+  // `initial`); only a change after mount is.
+  const syncId = useRef(Math.random().toString(36).slice(2));
+  const toolRef = useRef(tool);
+  toolRef.current = tool;
+  const announced = useRef(false);
+  useEffect(() => {
+    if (!announced.current) {
+      announced.current = true;
+      return;
+    }
+    if (typeof document === 'undefined') return;
+    document.dispatchEvent(
+      new CustomEvent(TOOL_SYNC_EVENT, { detail: { tool, from: syncId.current } })
+    );
+  }, [tool]);
+  useEffect(() => {
+    if (typeof document === 'undefined') return;
+    const onSync = (e: Event) => {
+      const d = (e as CustomEvent<{ tool?: unknown; from?: unknown }>).detail;
+      if (!d || d.from === syncId.current || typeof d.tool !== 'string') return;
+      // Already there: nothing to do, and — for a sticky-locked tool — not
+      // touching it keeps the lock.
+      if (d.tool === toolRef.current) return;
+      setTool(d.tool as Tool);
+    };
+    document.addEventListener(TOOL_SYNC_EVENT, onSync);
+    return () => document.removeEventListener(TOOL_SYNC_EVENT, onSync);
+  }, [setTool]);
+
   // Cursor sync — applied inside the canvas (this hook runs in the canvas
   // context). The active tool's cursor is set on <body> AND forced across the
   // whole canvas working area via an `!important` rule, so the custom cursor