@1agh/maude 1.0.11 → 1.3.0

package/apps/studio/annotations-layer.tsx

@@ -1,3 +1,4 @@
+import { createAnnotationEchoGuard, observeAnnotationSnapshots } from './annotations-sync.ts';
 /**
  * @file       annotations-layer.tsx — FigJam-style annotation overlay
  * @scope      apps/studio/annotations-layer.tsx
@@ -76,6 +77,7 @@ import {
   type EllipseStroke,
   FILL_PALETTE,
   fmtEqual,
+  grownStickyBox,
   HALO_PAD_PX,
   HIGHLIGHTER_PALETTE,
   HIGHLIGHTER_WIDTHS,
@@ -169,7 +171,7 @@ import { buildAnnotationStrokesRecord } from './commands/annotation-strokes-comm
 import { ensureMenuStyles as ensureCtxMenuStyles } from './context-menu.tsx';
 import { crossedDragThreshold, type Tool } from './input-router.tsx';
 import { createMediaCommitChain, type MediaCommitResult } from './media-commit-chain.ts';
-import { mountCaret, placeCaretAt } from './text-caret.ts';
+import { collapseEntrySelectAll, mountCaret, placeCaretAt } from './text-caret.ts';
 import {
   AnnotationResizeOverlay,
   bboxResize,
@@ -414,7 +416,7 @@ function resolveAssetHref(href: string): string {
  * recognize — keeping the `<image>` element, dropping only the attribute —
  * so the server's STORED + broadcast SVG silently diverges from whatever the
  * client just sent. That divergence defeats the collab-echo self-suppression
- * guard (the `recentSelfSvgsRef` history, near `putStrokes` below): the
+ * guard (the `annotationEchoRef` operation history, near `putStrokes` below): the
  * echo's content no longer matches anything we recorded as "already
  * applied", so a real `setStrokesState` fires from the (href-stripped)
  * server copy — which can wipe out a SIBLING stroke's still-in-flight
@@ -467,6 +469,17 @@ export function reconcileCommit(
  * ones that are still purely local, not-yet-synced optimistic previews (an
  * ephemeral blob:/data: href image mid-upload) that a foreign broadcast could
  * never have known about in the first place.
+ *
+ * issue-106 deliberately does NOT carve out the stroke a local editor has open.
+ * That was tried: hold back its `text` so a peer's commit could not overwrite
+ * the editor. But this function's output IS the persisted store — it is
+ * serialized to `*.annotations.svg` and re-broadcast on the next commit of ANY
+ * stroke — so holding a field back doesn't shield a view, it silently reverts
+ * the peer's write and republishes the stale text under the local user's name,
+ * for as long as the editor stays open. The editor never needed it: the clobber
+ * was React rewriting an UNCONTROLLED contentEditable, which `useSessionValue`
+ * fixes at the DOM, and the commit reads `innerText` off the node rather than
+ * off the stroke. Last-write-wins stays the model here.
  */
 export function reconcileForeignEcho(
   prev: readonly Stroke[],
@@ -1101,7 +1114,7 @@ export function AnnotationsLayer() {
   // the resurrection to every collab peer). Tracked explicitly here instead
   // of inferred: `deleteStrokes` records every id it removes; the swap
   // checks (and consumes) this before assuming absence means lag. Bounded
-  // like `recentSelfSvgsRef` below — only ever holds ids a delete has
+  // like the annotation echo history below — only ever holds ids a delete has
   // touched, which is small in practice, but capped for safety.
   const DELETED_STROKE_IDS_CAP = 128;
   const deletedStrokeIdsRef = useRef<Set<string>>(new Set());
@@ -1140,29 +1153,10 @@ export function AnnotationsLayer() {
     if (!ghostCapable || !visible) setGhost(null);
   }, [ghostCapable, visible]);
 
-  // Load existing annotations on mount.
-  // Self-echo suppression (Phase 8 Task 5, hardened — feature-bulk-media-
-  // insert follow-up). A single "last applied" string only catches the MOST
-  // RECENT self-write: when the chain fires several rapid commits (a batch
-  // drop), the server's broadcast of an EARLIER commit can arrive after a
-  // LATER local commit has already moved "last applied" on — so the earlier
-  // echo no longer matches, gets misread as a foreign change, and rolls
-  // local state BACK to that stale snapshot. This is the confirmed cause of
-  // images silently vanishing after a multi-file drop (live-tested: 12
-  // mismatched/misapplied echoes correlated exactly with lost strokes across
-  // a 30-batch stress run). Track a bounded HISTORY of our own recent writes
-  // instead of just the latest one, so an out-of-order echo of any recent
-  // self-write is still recognized and suppressed.
-  const RECENT_SELF_SVG_CAP = 64;
-  const recentSelfSvgsRef = useRef<Set<string>>(new Set());
-  const rememberSelfSvg = useCallback((svg: string) => {
-    const set = recentSelfSvgsRef.current;
-    set.add(svg);
-    if (set.size > RECENT_SELF_SVG_CAP) {
-      const oldest = set.values().next().value;
-      if (oldest !== undefined) set.delete(oldest);
-    }
-  }, []);
+  // Match specific authored operations, including delayed earlier PUTs. A
+  // peer undo/delete can legitimately return to any previously rendered SVG.
+  const annotationEchoRef = useRef(createAnnotationEchoGuard());
+  const annotationsChangedRef = useRef(false);
   useEffect(() => {
     const file = deriveFile();
     fileRef.current = file;
@@ -1173,11 +1167,10 @@ export function AnnotationsLayer() {
     })
       .then((r) => (r.ok ? r.text() : ''))
       .then((text) => {
-        if (cancelled) return;
+        if (cancelled || annotationsChangedRef.current) return;
         const loaded = svgToStrokes(text);
         if (loaded.length) {
           setStrokesState(loaded);
-          rememberSelfSvg(text);
         }
       })
       .catch(() => {
@@ -1186,37 +1179,18 @@ export function AnnotationsLayer() {
     return () => {
       cancelled = true;
     };
-  }, [rememberSelfSvg]);
-
-  // Phase 8 Task 5 — observe the Y.Map.annotations for live updates from
-  // other tabs. Bail when the incoming SVG STRING matches any RECENT
-  // self-write (covers the local echo round-trip, including an
-  // out-of-order one, without missing real foreign changes). The prior
-  // length+first/last-id check was wrong: a resize / move keeps the same id
-  // list, so all three predicates matched even though geometry changed —
-  // foreign edits silently disappeared.
+  }, []);
+
   const collab = useCollab();
   useEffect(() => {
     if (!collab) return;
-    const map = collab.doc.getMap<string>('annotations');
-    const apply = () => {
-      const svg = map.get('svg');
-      if (typeof svg !== 'string' || !svg) return;
-      if (recentSelfSvgsRef.current.has(svg)) return;
-      rememberSelfSvg(svg);
+    return observeAnnotationSnapshots(collab.doc, (svg, writeId) => {
+      annotationsChangedRef.current = true;
+      if (annotationEchoRef.current.isOwn(svg, writeId)) return;
       const incoming = svgToStrokes(svg);
       setStrokesState((prev) => reconcileForeignEcho(prev, incoming));
-    };
-    apply();
-    map.observe(apply);
-    return () => {
-      try {
-        map.unobserve(apply);
-      } catch {
-        /* doc destroyed before unmount */
-      }
-    };
-  }, [collab, rememberSelfSvg]);
+    });
+  }, [collab]);
 
   const undoStack = useUndoStackOptional();
   const undoSinks = useUndoSinks();
@@ -1252,50 +1226,55 @@ export function AnnotationsLayer() {
    * we push a command, so the server only sees one PUT per edit instead
    * of two-step racing.
    */
-  const putStrokes = useCallback(
-    (next: readonly Stroke[], before: readonly Stroke[]) => {
-      // See reconcileCommit — a direct setStrokesState(next) here can
-      // clobber a sibling file's concurrent optimistic insert; folding
-      // blindly against `prev` (no baseline) can just as easily revert this
-      // very mutation's own delete. `before` (this command's own baseline)
-      // disambiguates the two.
-      setStrokesState((prev) => reconcileCommit(prev, before, next));
-      const file = fileRef.current;
-      if (!file) return Promise.resolve();
-      const persistable = next.some(isEphemeralHref)
-        ? next.filter((s) => !isEphemeralHref(s))
-        : next;
-      const svg = strokesToSvg(persistable);
-      // Phase 8 Task 5 — record the SVG we just authored locally so the
-      // server-broadcast echo (PUT → onAnnotationsChanged → syncRoom* →
-      // Y.Map.observe) doesn't trigger a redundant setStrokesState.
-      rememberSelfSvg(svg);
-      const dispatch = () =>
-        fetch('/_api/annotations', {
-          method: 'PUT',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ file, svg }),
+  const putStrokes = useCallback((next: readonly Stroke[], before: readonly Stroke[]) => {
+    // See reconcileCommit — a direct setStrokesState(next) here can
+    // clobber a sibling file's concurrent optimistic insert; folding
+    // blindly against `prev` (no baseline) can just as easily revert this
+    // very mutation's own delete. `before` (this command's own baseline)
+    // disambiguates the two.
+    annotationsChangedRef.current = true;
+    setStrokesState((prev) => reconcileCommit(prev, before, next));
+    const file = fileRef.current;
+    if (!file) return Promise.resolve();
+    const persistable = next.some(isEphemeralHref) ? next.filter((s) => !isEphemeralHref(s)) : next;
+    const svg = strokesToSvg(persistable);
+    // What this edit was derived from — the project merges a peer's
+    // concurrent strokes from it instead of replacing them (DDR-241).
+    const persistableBefore = before.some(isEphemeralHref)
+      ? before.filter((s) => !isEphemeralHref(s))
+      : before;
+    const base = strokesToSvg(persistableBefore);
+    // Phase 8 Task 5 — record the SVG we just authored locally so the
+    // server-broadcast echo (PUT → onAnnotationsChanged → syncRoom* →
+    // Y.Map.observe) doesn't trigger a redundant setStrokesState.
+    const writeId = crypto.randomUUID();
+    annotationEchoRef.current.remember(writeId, svg);
+    const dispatch = () =>
+      fetch('/_api/annotations', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ file, svg, writeId, base }),
+      })
+        .then((r) => {
+          // A refused save (403 read-only, 405 at a proxy door) previously
+          // dissolved here without a trace — the user kept drawing on state
+          // that never reached disk, a peer, or a reload (the cloud
+          // canvas-writes RCA). Optimistic local state is still the right
+          // UX; a persistence failure being INVISIBLE is not.
+          if (!r.ok) {
+            annotationEchoRef.current.forget(writeId);
+            console.warn(`[annotations] save refused (${r.status}) — strokes are local-only`);
+          }
+          return undefined;
         })
-          .then((r) => {
-            // A refused save (403 read-only, 405 at a proxy door) previously
-            // dissolved here without a trace — the user kept drawing on state
-            // that never reached disk, a peer, or a reload (the cloud
-            // canvas-writes RCA). Optimistic local state is still the right
-            // UX; a persistence failure being INVISIBLE is not.
-            if (!r.ok) {
-              console.warn(`[annotations] save refused (${r.status}) — strokes are local-only`);
-            }
-            return undefined;
-          })
-          .catch(() => {
-            /* swallow — user sees uncommitted state until the next stroke */
-          });
-      const chained = putChainRef.current.then(dispatch, dispatch);
-      putChainRef.current = chained;
-      return chained;
-    },
-    [rememberSelfSvg]
-  );
+        .catch(() => {
+          annotationEchoRef.current.forget(writeId);
+          /* Pending persistence UX is handled by the project outbox work. */
+        });
+    const chained = putChainRef.current.then(dispatch, dispatch);
+    putChainRef.current = chained;
+    return chained;
+  }, []);
 
   // Register the strokes put sink with the undo provider so the rebuilt
   // AnnotationStrokesCommand (after a canvas switch + return) routes through
@@ -1745,14 +1724,14 @@ export function AnnotationsLayer() {
             // chain-driven setStrokesState queued in the same batch.
             setStrokesState((prev) => prev.filter((s) => s.id !== id));
             deletedStrokeIdsRef.current.delete(id); // never reached the chain — nothing to consume there
-            showCanvasToast(`Image upload failed — ${res.error}`);
+            showCanvasToast(`Image upload failed — ${res.error}`, 'error');
           }
           URL.revokeObjectURL(blobUrl);
         });
       };
       probe.onerror = () => {
         URL.revokeObjectURL(blobUrl);
-        showCanvasToast('Could not read that image file');
+        showCanvasToast('Could not read that image file', 'error');
       };
       probe.src = blobUrl;
     },
@@ -1797,7 +1776,7 @@ export function AnnotationsLayer() {
       const h = mediaKind === 'video' ? MEDIAREF_VIDEO_H : MEDIAREF_DEFAULT_H;
       void uploadAsset(file).then((res) => {
         if (!('path' in res)) {
-          showCanvasToast(`Couldn't add ${mediaKind}: ${res.error}`);
+          showCanvasToast(`Couldn't add ${mediaKind}: ${res.error}`, 'error');
           return;
         }
         const id = rid();
@@ -2884,13 +2863,24 @@ export function AnnotationsLayer() {
   // Phase 21 — sticky body edit. Sticky text is freeform (newlines preserved,
   // no trim) and the card persists even when blank, so this only updates text.
   const commitStickyText = useCallback(
-    (id: string, text: string, fmt?: EditorFmt) => {
+    (id: string, text: string, fmt?: EditorFmt, measuredH?: number) => {
       const prev = strokesRef.current;
       const existing = prev.find((s) => s.id === id && s.tool === 'sticky') as
         | StickyStroke
         | undefined;
-      if (!existing || (existing.text === text && fmtEqual(existing, fmt))) return;
-      const next = prev.map((s) => (s.id === id ? { ...existing, text, ...normFmt(fmt) } : s));
+      if (!existing) return;
+      // issue-106 — grow the card to whatever the editor actually rendered, so
+      // the lines the user just typed survive the return to the clipped read
+      // view. Null when the text already fits (the common case).
+      // The growth rides along with a real edit — it is NOT itself a reason to
+      // write. Otherwise opening a peer's already-overflowing note and clicking
+      // away, having typed nothing, would produce an undo entry, a
+      // full-document PUT and a sync broadcast.
+      if (existing.text === text && fmtEqual(existing, fmt)) return;
+      const grown = measuredH == null ? null : grownStickyBox(existing, measuredH);
+      const next = prev.map((s) =>
+        s.id === id ? { ...existing, text, ...normFmt(fmt), ...(grown ?? {}) } : s
+      );
       commitStrokes(prev, next, 'edit sticky');
     },
     [commitStrokes]
@@ -2970,14 +2960,14 @@ export function AnnotationsLayer() {
   editingTargetRef.current = editingTarget;
 
   const commitEditing = useCallback(
-    (text: string, fmt?: EditorFmt) => {
+    (text: string, fmt?: EditorFmt, measuredH?: number) => {
       const target = editingTargetRef.current;
       setEditingId(null);
       setPendingText(null);
       setEditCaretPoint(null);
       if (!target) return;
       if (target.kind === 'anchored') commitText(target.anchorId, text, fmt);
-      else if (target.kind === 'sticky') commitStickyText(target.sticky.id, text, fmt);
+      else if (target.kind === 'sticky') commitStickyText(target.sticky.id, text, fmt, measuredH);
       else if (target.kind === 'standalone') commitStandaloneText(target.text.id, text, fmt);
       else if (target.kind === 'section') {
         const label = text.trim().replace(/\s*\n+\s*/g, ' ') || 'Section';
@@ -3902,7 +3892,7 @@ function AnnotationsSvg({
   editCaretPoint: { x: number; y: number } | null;
   /** Live default ink (theme-aware) for a not-yet-born pending text caret. */
   inkColor: string;
-  onCommitEdit: (text: string, fmt?: EditorFmt) => void;
+  onCommitEdit: (text: string, fmt?: EditorFmt, measuredH?: number) => void;
   onCancelEdit: () => void;
 }) {
   const [, force] = useState({});
@@ -4118,7 +4108,7 @@ function AnnotEditors({
   anchoredExisting: TextStroke | undefined;
   caretPoint: { x: number; y: number } | null;
   inkColor: string;
-  onCommitEdit: (text: string, fmt?: EditorFmt) => void;
+  onCommitEdit: (text: string, fmt?: EditorFmt, measuredH?: number) => void;
   onCancelEdit: () => void;
 }) {
   const target = worldRef?.current ?? null;
@@ -4346,6 +4336,33 @@ function useEditorCaret(
   return { onPointerDown, onPointerUp };
 }
 
+/**
+ * issue-106 — the body an annotation editor hands React as its contentEditable
+ * children, snapshotted for the life of ONE edit session.
+ *
+ * These editors are uncontrolled: the user types straight into the DOM. If the
+ * rendered children value changes while the session is open, React writes the
+ * new string into the live node and everything typed since — line breaks
+ * included — is gone. That is exactly what a peer's commit arriving over
+ * shared-doc sync (DDR-064) used to do, and what the hazard note above
+ * `useEditorFormat` warns about for local mutations. Snapshotting per target id
+ * makes the children a constant for the session, so no store update can reach
+ * the DOM; the commit path reads `innerText` from the node itself, which is the
+ * user's real content either way. Re-keys when the editor is reused for a
+ * different stroke.
+ *
+ * `listType` is snapshotted through the same hook: the body is prefixed with
+ * list markers at OPEN time and stripped again at commit, so if a peer flipped
+ * the stroke's list style mid-session the strip would run a different rule than
+ * the prefix did — turning a bullet into a literal "• " in the stored text, or
+ * eating a leading "1. " the user actually typed.
+ */
+function useSessionValue<T>(id: string, compute: () => T): T {
+  const ref = useRef<{ id: string; value: T } | null>(null);
+  if (ref.current === null || ref.current.id !== id) ref.current = { id, value: compute() };
+  return ref.current.value;
+}
+
 function TextEditor({
   anchorId,
   host,
@@ -4364,9 +4381,10 @@ function TextEditor({
   const ref = useRef<HTMLDivElement | null>(null);
   // Show list markers WHILE editing so the read↔edit swap doesn't flicker
   // (item 4c) — stripped back to raw text on commit.
-  const initial = listPrefixedBody(existing?.text ?? '', existing?.listType);
-  const initialRef = useRef(initial);
-  initialRef.current = initial;
+  const sessionListType = useSessionValue(anchorId, () => existing?.listType);
+  const initial = useSessionValue(anchorId, () =>
+    listPrefixedBody(existing?.text ?? '', sessionListType)
+  );
   // Cmd/Ctrl+B/I/U formatting while editing (item 4d).
   const {
     fmtRef,
@@ -4385,8 +4403,8 @@ function TextEditor({
   // effect below can depend on it directly instead of its own copy of
   // existing?.listType (lint/correctness/useExhaustiveDependencies).
   const toCommittedText = useCallback(
-    (raw: string) => stripEditorMarkers(stripJumpSentinel(raw), existing?.listType),
-    [existing?.listType]
+    (raw: string) => stripEditorMarkers(stripJumpSentinel(raw), sessionListType),
+    [sessionListType]
   );
 
   // Caret-at-click on entry + custom blinking caret + click re-placement
@@ -4471,6 +4489,14 @@ function TextEditor({
             onCancel();
             return;
           }
+          // issue-106 — Shift+Enter ADDS a line. On keyboard entry the whole
+          // body is still select-all'd (the retype convention), so letting the
+          // break replace the selection wiped the text. Collapse that entry
+          // selection to its end first; a user's own partial selection is left
+          // alone. See collapseEntrySelectAll.
+          if (e.key === 'Enter' && e.shiftKey && ref.current) {
+            collapseEntrySelectAll(ref.current, window);
+          }
           // Unified across every text surface: plain Enter commits,
           // Shift+Enter inserts a newline (falls through untouched). ⌘/Ctrl
           // +Enter also commits AND chains a connected sibling (quick-create).
@@ -4504,7 +4530,7 @@ function StickyEditor({
 }: {
   sticky: StickyStroke;
   caretPoint?: { x: number; y: number } | null;
-  onCommit: (text: string, fmt?: EditorFmt) => void;
+  onCommit: (text: string, fmt?: EditorFmt, measuredH?: number) => void;
   onCancel: () => void;
 }) {
   // A flex-centered contentEditable (NOT a textarea) so the edit view matches
@@ -4513,6 +4539,8 @@ function StickyEditor({
   // Esc cancels; blur commits; Cmd/Ctrl+B/I/U format (unified with the others).
   const ref = useRef<HTMLDivElement | null>(null);
   const doneRef = useRef(false);
+  const sessionListType = useSessionValue(sticky.id, () => sticky.listType);
+  const sessionBody = useSessionValue(sticky.id, () => stickyBodyText(sticky));
   const {
     fmtRef,
     style: fmtStyle,
@@ -4528,7 +4556,16 @@ function StickyEditor({
   const commit = () => {
     if (doneRef.current) return;
     doneRef.current = true;
-    onCommit(stripEditorMarkers(ref.current?.innerText ?? '', sticky.listType), fmtRef.current);
+    const el = ref.current;
+    // issue-106 — the editor IS the measurement: same class, same width, same
+    // font as the committed body, and laid out in world units (the pan/zoom
+    // transform on `.dc-world` doesn't change layout), so its scrollHeight is
+    // the height the card needs. No offscreen measuring rig required.
+    onCommit(
+      stripEditorMarkers(el?.innerText ?? '', sessionListType),
+      fmtRef.current,
+      el?.scrollHeight
+    );
   };
   // FigJam v3 — a toolbar click steals focus for a tick; don't treat it as
   // "done editing" (the button's onMouseDown preventDefault usually stops the
@@ -4544,10 +4581,33 @@ function StickyEditor({
   const y = Math.min(sticky.y, sticky.y + sticky.h);
   const w = Math.abs(sticky.w);
   const h = Math.abs(sticky.h);
+  const r = sticky.cornerRadius ?? STICKY_CORNER_RADIUS;
   return (
     <div
       data-annot-editor="1"
-      style={{ position: 'absolute', left: x, top: y, width: w, height: h, zIndex: 5 }}
+      style={{
+        position: 'absolute',
+        left: x,
+        top: y,
+        width: w,
+        // issue-106 — NOT a fixed `height: h`. The card clips at `overflow:
+        // hidden`, so on a sticky that is already full the line Shift+Enter
+        // inserts landed outside the box: the keystroke worked, nothing moved
+        // on screen, and it read as "shift+enter does nothing". While the
+        // editor is open it grows downward instead, painting its own paper so
+        // the overflow still reads as the note (the SVG card behind is still
+        // the old size until the commit below persists the grown height).
+        minHeight: h,
+        zIndex: 5,
+        // `backgroundColor`, never the `background` shorthand: `color` comes
+        // verbatim from a synced stroke's `fill` (peer-controlled, and the
+        // sanitizer does not touch `fill`), and the shorthand would accept a
+        // `url(...)` — an outbound request from the studio origin the moment a
+        // note is opened. `background-color` cannot take one.
+        backgroundColor: sticky.color,
+        // Mirrors stickyCornerPath: TL/TR/BL rounded, BR sharp.
+        borderRadius: `${r}px ${r}px 0 ${r}px`,
+      }}
     >
       <div
         ref={ref}
@@ -4561,6 +4621,11 @@ function StickyEditor({
           outline: 'none',
           cursor: 'text',
           ...CARET_FIX_STYLE,
+          // Beats `.dc-sticky-body { height: 100%; overflow: hidden }` for the
+          // duration of the edit — see the wrapper note above.
+          height: 'auto',
+          minHeight: h,
+          overflow: 'visible',
         }}
         onBlur={onBlur}
         onPointerDown={caretHandlers.onPointerDown}
@@ -4573,6 +4638,11 @@ function StickyEditor({
             onCancel();
             return;
           }
+          // issue-106 — see the same guard in TextEditor: Shift+Enter must add
+          // a line, never consume the entry select-all and delete the body.
+          if (e.key === 'Enter' && e.shiftKey && ref.current) {
+            collapseEntrySelectAll(ref.current, window);
+          }
           // Unified: plain Enter commits, Shift+Enter inserts a newline.
           // ⌘/Ctrl+Enter also commits AND chains the next sticky beside it.
           if (e.key === 'Enter' && !e.shiftKey) {
@@ -4588,7 +4658,7 @@ function StickyEditor({
       >
         {/* Show the list markers while editing (item 4c) so the read↔edit swap
             doesn't flicker; stripped back to raw text on commit. */}
-        {stickyBodyText(sticky)}
+        {sessionBody}
       </div>
     </div>
   );
@@ -4736,6 +4806,11 @@ function StandaloneTextEditor({
             onCancel();
             return;
           }
+          // issue-106 — same guard as the other two editors, for the multi-line
+          // case only (a singleLine field commits on Shift+Enter anyway).
+          if (e.key === 'Enter' && e.shiftKey && !singleLine && ref.current) {
+            collapseEntrySelectAll(ref.current, window);
+          }
           // Unified: plain Enter commits, Shift+Enter inserts a newline. A
           // singleLine field (section rename) is a title — Shift+Enter commits
           // too rather than adding a newline the one-line chip can't show.

package/apps/studio/annotations-model.ts

@@ -542,6 +542,45 @@ export const DEFAULT_HIGHLIGHTER_WIDTH = HIGHLIGHTER_WIDTHS[1];
 export const STICKY_DEFAULT_W = 200;
 export const STICKY_DEFAULT_H = 200;
 export const STICKY_MIN_SIZE = 40;
+/**
+ * Ceiling for the grow-to-fit in `grownStickyBox` — ~370 lines at the default
+ * type. `fontSize` comes from a synced stroke's `data-fs` and is only checked
+ * for finiteness, so without this a peer could set `data-fs="200000"`, wait for
+ * the local user to edit that note, and have THEIR client persist a card
+ * millions of units tall — grow-only, undoable by hand alone.
+ */
+export const STICKY_MAX_GROWN_H = 8000;
+
+/**
+ * issue-106 — the box a sticky needs so its committed text is not clipped, or
+ * null when the text already fits.
+ *
+ * `.dc-sticky-body` is `overflow: hidden` on a card whose size was fixed at
+ * creation, and nothing ever grew it: past a card's capacity every further line
+ * was simply invisible, which is what made Shift+Enter look inert on a full
+ * note. `measuredH` is the editor's own `scrollHeight` — same class, width and
+ * font as the committed body, in world units — so the growth is exact rather
+ * than estimated.
+ *
+ * GROWS ONLY, and never past `STICKY_MAX_GROWN_H`: a sticky the user
+ * deliberately made roomy never shrinks back on a text edit. The box is normalized on the way out (a sticky dragged bottom-up
+ * carries a negative w/h), which is idempotent — every renderer already reads
+ * it through the same min/abs pair.
+ */
+export function grownStickyBox(
+  s: Pick<StickyStroke, 'x' | 'y' | 'w' | 'h'>,
+  measuredH: number
+): { x: number; y: number; w: number; h: number } | null {
+  if (!Number.isFinite(measuredH) || measuredH <= 0) return null;
+  const next = Math.min(Math.ceil(measuredH), STICKY_MAX_GROWN_H);
+  if (next <= Math.abs(s.h)) return null;
+  return {
+    x: Math.min(s.x, s.x + s.w),
+    y: Math.min(s.y, s.y + s.h),
+    w: Math.abs(s.w),
+    h: next,
+  };
+}
 // Phase 24 — a bare tap with the Shape tool drops a default-sized shape at the
 // tap point (FigJam parity: click commits, drag sizes). Square aspect.
 export const SHAPE_DEFAULT_SIZE = 120;

package/apps/studio/annotations-sync.ts

@@ -0,0 +1,50 @@
+import type * as Y from 'yjs';
+
+/** Echo identity is transport metadata, never authorization or a durable ACK. */
+export const ANNOTATION_WRITE_ID = 'writeId';
+
+export function validAnnotationWriteId(value: unknown): value is string {
+  return typeof value === 'string' && /^[a-zA-Z0-9_-]{1,96}$/.test(value);
+}
+
+/** Remember authored operations, not previously rendered content (A → B → A). */
+export function createAnnotationEchoGuard() {
+  const authored = new Map<string, string>();
+  return {
+    remember(id: string, svg: string) {
+      authored.set(id, svg);
+      if (authored.size > 64) {
+        const oldest = authored.keys().next().value;
+        if (oldest !== undefined) authored.delete(oldest);
+      }
+    },
+    forget(id: string) {
+      authored.delete(id);
+    },
+    isOwn(svg: string, id: unknown) {
+      return validAnnotationWriteId(id) && authored.get(id) === svg;
+    },
+  };
+}
+
+/** Old clients/importers may change svg without changing its old writeId. */
+export function observeAnnotationSnapshots(
+  doc: Y.Doc,
+  receive: (svg: string, writeId: unknown) => void
+): () => void {
+  const map = doc.getMap<unknown>('annotations');
+  const apply = (event?: Y.YMapEvent<unknown>) => {
+    if (event && !event.keysChanged.has('svg') && !event.keysChanged.has(ANNOTATION_WRITE_ID))
+      return;
+    const svg = map.get('svg');
+    if (typeof svg !== 'string' && !event?.keysChanged.has('svg')) return;
+    const id =
+      !event || event.keysChanged.has(ANNOTATION_WRITE_ID)
+        ? map.get(ANNOTATION_WRITE_ID)
+        : undefined;
+    receive(typeof svg === 'string' ? svg : '', id);
+  };
+  map.observe(apply);
+  apply();
+  return () => map.unobserve(apply);
+}