@1agh/maude 1.4.6 → 1.5.1

package/apps/studio/sync/remote-docs.ts

@@ -391,3 +391,37 @@ export function resolvePulledTarget(args: {
   }
   return { bodyAbs, fromPath };
 }
+
+/**
+ * The listing as an accepted-revisions project states it.
+ *
+ * In accepted mode the MANIFEST names the live canvases: an open Yjs room is
+ * not necessarily an accepted canvas (its author can connect before
+ * `doc.create` commits), so the documents come from the manifest, with the
+ * transport listing's byte counts where it has them.
+ *
+ * The same holds for DELETIONS. The transport's tombstones outlive the legacy
+ * era: a canvas deleted then and later re-created under the same name through
+ * `doc.create` stays tombstoned in the document store while the manifest lists
+ * it live — and every peer that honoured the tombstone skipped a live canvas
+ * (the web showed it, the desktop never pulled it). A tombstone for a name the
+ * manifest lists live is stale and dropped; one for a name the manifest
+ * retired, or does not carry, still stands. A peer's OWN just-made deletion is
+ * not affected: it is remembered locally and never passes through here.
+ */
+export function acceptedListing(
+  listing: RemoteListing | null,
+  manifestDocs: readonly { doc: string; retired: boolean }[]
+): RemoteListing {
+  const bytesByName = new Map((listing?.documents ?? []).map((d) => [d.name, d.bytes]));
+  const documents = manifestDocs
+    .filter((d) => !d.retired)
+    .map((d) => ({ name: d.doc, bytes: bytesByName.get(d.doc) ?? 1 }));
+  const live = new Set(
+    manifestDocs.filter((d) => !d.retired).map((d) => slugFromDocName(d.doc) ?? d.doc)
+  );
+  const tombstones = (listing?.tombstones ?? []).filter(
+    (t) => !live.has(slugFromDocName(t.name) ?? t.name)
+  );
+  return { documents, tombstones };
+}

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

@@ -79,6 +79,15 @@ export const WRITER_REGISTRY: Record<string, WriterEntry> = {
     via: 'onAnnotationsChanged hook → annotations lane.replace with the base the layer sent',
     test: 'test/sync-accepted-projection.test.ts',
   },
+  // DDR-242 §4 — the canvas's op batches. Same lane, same hook: the api applies
+  // the ops to the board, then fires onAnnotationsChanged with the pre-batch
+  // board as base (the kernel's `annotations.apply` replaces this in Task 12).
+  '/_api/annotations/ops': {
+    class: 'lane',
+    rows: 'S23',
+    via: 'onAnnotationsChanged hook → annotations lane.replace with the pre-batch board as base',
+    test: 'test/sync-accepted-projection.test.ts',
+  },
   // --- accepted history (T27/T28)
   '/_api/project/history': { class: 'read' },
   '/_api/project/restore': {
@@ -230,6 +239,7 @@ export const WRITER_REGISTRY: Record<string, WriterEntry> = {
   '/_api/sync/settings': { class: 'local' },
   '/_api/sync/trash': { class: 'local', rows: 'X15 (restore re-enters through cold start)' },
   '/_api/timeline-media': { class: 'local' },
+  '/_api/tree-state': { class: 'local' },
   '/_api/ui-prefs': { class: 'local' },
   '/_api/workspace/disclosure': { class: 'local' },
   '/_api/workspace/sign-in': { class: 'local' },

package/apps/studio/text-caret.ts

@@ -146,7 +146,7 @@ interface CaretRect {
  * should hide (no collapsed selection inside the editable / editable not
  * focused / a range selection is active, where the native highlight is the
  * affordance). */
-function caretRectFor(editable: HTMLElement, win: Window): CaretRect | null {
+function caretRectFor(editable: HTMLElement, win: Window): CaretRect | 'native' | null {
   const doc = editable.ownerDocument;
   const active = doc.activeElement;
   if (active !== editable && !editable.contains(active)) return null;
@@ -165,6 +165,13 @@ function caretRectFor(editable: HTMLElement, win: Window): CaretRect | null {
     if (br && br.height > 0) r = br;
   }
   if (r && r.height > 0) return { x: r.left, y: r.top, h: r.height };
+  // A caret on a line with no text box yet — Shift+Enter's "\n" puts it at
+  // the start of an empty last line — has no client rect in Chromium or
+  // WebKit. Guessing a position from the editable's box painted it back at
+  // the top-left of line ONE (the "Shift+Enter throws the cursor somewhere
+  // weird" report). Only the engine knows where that caret is, so hand the
+  // caret back to it: the native caret shows until a rect exists again.
+  if ((editable.textContent ?? '').replace(/\u200b/g, '') !== '') return 'native';
   // Empty editable — no rect exists anywhere. Derive a caret box from the
   // editable's padding box + line metrics. (The annotation editors avoid this
   // path by mounting with a zero-width-space JUMP_SENTINEL, but the artboard
@@ -221,7 +228,9 @@ export function mountCaret(editable: HTMLElement, win: Window): () => void {
 
   const position = (): void => {
     const rc = caretRectFor(editable, win);
-    if (!rc) {
+    // The engine's own caret, while ours can't be placed (see caretRectFor).
+    editable.style.caretColor = rc === 'native' ? prevCaretColor || 'auto' : 'transparent';
+    if (!rc || rc === 'native') {
       if (shown) {
         caret.style.display = 'none';
         shown = false;

package/apps/studio/tree-state.ts

@@ -0,0 +1,45 @@
+// tree-state.ts — the Files panel's remembered disclosure (issue #124).
+//
+// `dirs` are the repo-relative folder paths the user left expanded (the same
+// `dirPath` the tree rows carry); `sections` maps a section label (PROJECT /
+// UI CANVASES / …) to open/closed. Anything absent is CLOSED — that default is
+// the point of the issue. Stored per project + per member by api.ts under
+// `_canvas-state/`; this module only owns the shape and its bounds, so a
+// hostile or corrupt body can neither grow the file without limit nor smuggle
+// a non-string into a path the client later splits.
+
+export interface TreeState {
+  dirs: string[];
+  sections: Record<string, boolean>;
+}
+
+export const TREE_STATE_MAX_DIRS = 2000;
+export const TREE_STATE_MAX_PATH = 1024;
+export const TREE_STATE_MAX_SECTIONS = 64;
+const MAX_LABEL = 128;
+
+/** Coerce anything into a bounded, de-duplicated TreeState. Never throws. */
+export function normalizeTreeState(raw: unknown): TreeState {
+  const o =
+    raw && typeof raw === 'object' && !Array.isArray(raw) ? (raw as Record<string, unknown>) : {};
+  const dirs = new Set<string>();
+  if (Array.isArray(o.dirs)) {
+    for (const d of o.dirs) {
+      if (dirs.size >= TREE_STATE_MAX_DIRS) break;
+      if (typeof d !== 'string' || !d || d.length > TREE_STATE_MAX_PATH || d.includes('\0'))
+        continue;
+      dirs.add(d);
+    }
+  }
+  const sections: Record<string, boolean> = {};
+  if (o.sections && typeof o.sections === 'object' && !Array.isArray(o.sections)) {
+    let n = 0;
+    for (const [k, v] of Object.entries(o.sections as Record<string, unknown>)) {
+      if (n >= TREE_STATE_MAX_SECTIONS) break;
+      if (typeof v !== 'boolean' || !k || k.length > MAX_LABEL || k === '__proto__') continue;
+      sections[k] = v;
+      n++;
+    }
+  }
+  return { dirs: [...dirs].sort(), sections };
+}

package/apps/studio/undo-stack.ts

@@ -69,8 +69,8 @@ export interface CommandRecord<P = unknown> {
 export interface CommandSinks {
   /** Wired by canvas-lib `DesignCanvasInner`. */
   layoutPatchFn?: unknown;
-  /** Wired by `AnnotationsLayer`. */
-  strokesPutFn?: unknown;
+  /** Wired by `AnnotationsLayer` (DDR-242): apply + send an annotation op batch. */
+  annotationOpsFn?: unknown;
   /**
    * Wired by `CanvasShell` (canvas-shell.tsx). Applies a single inline source
    * edit (CSS / text / attr) by posting `dgn:'apply-edit'` to the parent shell,

package/apps/studio/use-annotation-resize.tsx

@@ -18,10 +18,13 @@
  */
 
 import { type ReactNode, useCallback, useEffect, useMemo, useRef } from 'react';
+import { defOf } from './annotations/registry.ts';
+import { useAnnotationPipeline } from './annotations/ui/pipeline-context.ts';
 import { anchorPoint, BIND_THRESHOLD_PX, bindCandidate } from './annotations-bindings.ts';
 import {
   type ArrowStroke,
   canRotate,
+  type ElementStroke,
   type EllipseStroke,
   HALO_PAD_PX,
   type ImageStroke,
@@ -141,6 +144,7 @@ export const padDY = (c: Corner): number =>
 function isResizable(
   s: Stroke
 ): s is
+  | ElementStroke
   | RectStroke
   | EllipseStroke
   | PolygonStroke
@@ -150,6 +154,10 @@ function isResizable(
   | ImageStroke
   | LinkStroke
   | SectionStroke {
+  if (s.tool === 'element') {
+    const caps = defOf(s.el.type)?.caps;
+    return !!caps?.box && caps.resizable;
+  }
   return (
     s.tool === 'rect' ||
     s.tool === 'ellipse' ||
@@ -386,6 +394,15 @@ export function resizeStroke(
     const box = bboxResizeRotAware(start, b0, corner, wx, wy, mods, start.tool === 'sticky');
     return box as Partial<RectStroke | StickyStroke | PolygonStroke | LinkStroke>;
   }
+  if (start.tool === 'element') {
+    // A registry type: fit its box, the fields come from its definition.
+    const def = defOf(start.el.type);
+    const b0 = strokeBBox(start);
+    if (!def || !b0) return null;
+    const box = bboxResize(b0, corner, wx, wy, mods, !!def.caps.aspectLock);
+    const ctx = { origin: { x: 0, y: 0 }, resolve: () => null };
+    return { el: { ...start.el, ...def.resize(start.el, box, ctx) } } as Partial<Stroke>;
+  }
   if (start.tool === 'image') {
     // Phase 23 — images aspect-LOCK by default and free-resize with Shift held
     // (the inverse of the shape tools — Figma/FigJam image behaviour). Invert
@@ -560,6 +577,7 @@ export function AnnotationResizeOverlay({ store }: { store: StrokesStoreValue |
   const annotSel = useAnnotationSelection();
   const controller = useViewportControllerContext();
   const vp = controller?.viewport ?? null;
+  const pipeline = useAnnotationPipeline();
   const containerRef = useRef<HTMLDivElement | null>(null);
   const rafRef = useRef<number | null>(null);
   const dragRef = useRef<{
@@ -725,6 +743,17 @@ export function AnnotationResizeOverlay({ store }: { store: StrokesStoreValue |
       } catch {
         /* some browsers reject capture on synthetic events */
       }
+      // The layer's pointer pipeline owns the moves and the release (Task 21);
+      // mounted without a layer (tests), the overlay listens itself.
+      if (pipeline) {
+        const pointerId = e.pointerId;
+        pipeline.begin(pointerId, {
+          kind: isRotCorner(corner) ? 'rotating' : 'resizing',
+          move: onMove,
+          up: onUp,
+          cancel: (ev) => onUp(ev ?? ({ pointerId } as PointerEvent)),
+        });
+      }
     };
     const applyResize = (
       clientX: number,
@@ -810,19 +839,15 @@ export function AnnotationResizeOverlay({ store }: { store: StrokesStoreValue |
             matchIds.push(bestH.id);
           }
         }
-        document.dispatchEvent(
-          new CustomEvent('maude:resize-info', {
-            detail: {
-              box: { x: patch.x, y: patch.y, w: patch.w, h: patch.h },
-              matchIds,
-            },
-          })
-        );
+        store.setResizeInfo?.({
+          box: { x: patch.x, y: patch.y, w: patch.w, h: patch.h },
+          matchIds,
+        });
       }
       // FigJam v3 — dragging an arrow ENDPOINT re-anchors its bind: within the
       // magnet threshold of a bindable host the endpoint snaps + binds; free
       // space (or ⌘ held — Figma "suppress snap") clears the bind. The layer
-      // paints the candidate halo via the maude:bind-hint broadcast.
+      // paints the candidate halo (store.setBindHint).
       if (d.startStroke.tool === 'arrow' && (d.corner === 'ep1' || d.corner === 'ep2')) {
         const zoom = vp?.zoom || 1;
         const cand = suppressBind
@@ -852,9 +877,7 @@ export function AnnotationResizeOverlay({ store }: { store: StrokesStoreValue |
             [d.corner === 'ep1' ? 'startBind' : 'endBind']: undefined,
           } as Partial<Stroke>;
         }
-        document.dispatchEvent(
-          new CustomEvent('maude:bind-hint', { detail: { hostId: cand?.hostId ?? null } })
-        );
+        store.setBindHint?.(cand?.hostId ?? null);
       }
       // Wave H — transient preview tick: no undo record, no PUT. The gesture
       // commits ONCE on pointerup (undo used to walk every resize pixel).
@@ -898,26 +921,28 @@ export function AnnotationResizeOverlay({ store }: { store: StrokesStoreValue |
       );
       // Clear the bind-hint halo + size label regardless of what was dragged
       // (no-ops when nothing was hinted).
-      document.dispatchEvent(new CustomEvent('maude:bind-hint', { detail: { hostId: null } }));
-      document.dispatchEvent(
-        new CustomEvent('maude:resize-info', { detail: { box: null, matchIds: [] } })
-      );
+      store?.setBindHint?.(null);
+      store?.setResizeInfo?.(null);
     };
     c.addEventListener('pointerdown', onDown);
-    document.addEventListener('pointermove', onMove);
-    document.addEventListener('pointerup', onUp);
-    document.addEventListener('pointercancel', onUp);
+    if (!pipeline) {
+      document.addEventListener('pointermove', onMove);
+      document.addEventListener('pointerup', onUp);
+      document.addEventListener('pointercancel', onUp);
+    }
     document.addEventListener('keydown', onKey, true);
     document.addEventListener('keyup', onKey, true);
     return () => {
       c.removeEventListener('pointerdown', onDown);
-      document.removeEventListener('pointermove', onMove);
-      document.removeEventListener('pointerup', onUp);
-      document.removeEventListener('pointercancel', onUp);
+      if (!pipeline) {
+        document.removeEventListener('pointermove', onMove);
+        document.removeEventListener('pointerup', onUp);
+        document.removeEventListener('pointercancel', onUp);
+      }
       document.removeEventListener('keydown', onKey, true);
       document.removeEventListener('keyup', onKey, true);
     };
-  }, [selectedStroke, store, screenToWorld, vp]);
+  }, [selectedStroke, store, screenToWorld, vp, pipeline]);
 
   // Only render when there's exactly one resizable stroke selected. Multi
   // resize is undefined for v1 (no canonical UX); text inherits anchor bbox.

package/apps/studio/use-annotation-selection.tsx

@@ -24,6 +24,8 @@ export interface AnnotationSelectionValue {
   selectedIds: string[];
   replace: (id: string | string[]) => void;
   add: (id: string | string[]) => void;
+  /** Drop ids from the selection (shift-click on a selected element). */
+  remove: (id: string | string[]) => void;
   toggle: (id: string) => void;
   clear: () => void;
   contains: (id: string) => boolean;
@@ -55,6 +57,11 @@ export function AnnotationSelectionProvider({ children }: { children: ReactNode
     setSelectedIds((prev) => dedupe([...prev, ...incoming]));
   }, []);
 
+  const remove = useCallback((id: string | string[]) => {
+    const drop = new Set(Array.isArray(id) ? id : [id]);
+    setSelectedIds((prev) => prev.filter((x) => !drop.has(x)));
+  }, []);
+
   const toggle = useCallback((id: string) => {
     setSelectedIds((prev) => (prev.includes(id) ? prev.filter((x) => x !== id) : [...prev, id]));
   }, []);
@@ -76,8 +83,8 @@ export function AnnotationSelectionProvider({ children }: { children: ReactNode
   const contains = useCallback((id: string) => containsRef.current.includes(id), []);
 
   const value = useMemo<AnnotationSelectionValue>(
-    () => ({ selectedIds, replace, add, toggle, clear, contains }),
-    [selectedIds, replace, add, toggle, clear, contains]
+    () => ({ selectedIds, replace, add, remove, toggle, clear, contains }),
+    [selectedIds, replace, add, remove, toggle, clear, contains]
   );
 
   return (

package/apps/studio/use-collab.tsx

@@ -106,6 +106,12 @@ export interface CollabAwarenessState {
    * annotation-shaped is selected.
    */
   annotationSelection: string[];
+  /**
+   * DDR-242 AD5 / Task 22 — an annotation gesture in flight (drag, resize,
+   * draw), so peers see it move live. It never touches storage: the op
+   * commits once at gesture end, and this goes back to null.
+   */
+  annotationGesture?: AnnotationGesture | null;
   viewport: { x: number; y: number; zoom: number };
   /**
    * Soft editing-presence (Phase 30). Set while THIS peer (a human editing via
@@ -130,6 +136,20 @@ export interface CollabAwarenessState {
 
 export type ForeignAwareness = Omit<CollabAwarenessState, '__connId'> & { clientID: number };
 
+/** A live annotation gesture, in WORLD coordinates. */
+export interface AnnotationGesture {
+  kind: 'move' | 'resize' | 'draw';
+  /** Elements the gesture moves / resizes (empty while drawing a new one). */
+  ids: string[];
+  /** move: the drag offset. */
+  dx?: number;
+  dy?: number;
+  /** resize: the box being dragged out; draw: a shape / sticky / section being drawn. */
+  box?: { x: number; y: number; w: number; h: number };
+  /** draw: pen ink so far, flat [x0,y0,x1,y1,…] (the latest part, capped). */
+  points?: number[];
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Untrusted-input sanitization at the awareness trust boundary.
 //
@@ -214,6 +234,58 @@ function sanitizeCursor(raw: unknown): { x: number; y: number } | null {
   return isFiniteNum(c.x) && isFiniteNum(c.y) ? { x: c.x, y: c.y } : null;
 }
 
+const GESTURE_KINDS = new Set(['move', 'resize', 'draw']);
+const MAX_GESTURE_POINTS = 512; // numbers, i.e. 256 points
+const GESTURE_COORD_LIMIT = 1e6;
+
+function gestureNum(v: unknown): number | undefined {
+  if (typeof v !== 'number' || !Number.isFinite(v)) return undefined;
+  return Math.max(-GESTURE_COORD_LIMIT, Math.min(GESTURE_COORD_LIMIT, v));
+}
+
+/**
+ * Task 22 — a peer's gesture preview is untrusted like every other awareness
+ * field: kind allowlisted, ids through the same token + count gate as the
+ * selection, every number finite and clamped, pen points capped.
+ */
+export function sanitizeAnnotationGesture(raw: unknown): AnnotationGesture | null {
+  if (!raw || typeof raw !== 'object') return null;
+  const g = raw as Record<string, unknown>;
+  if (typeof g.kind !== 'string' || !GESTURE_KINDS.has(g.kind)) return null;
+  const out: AnnotationGesture = {
+    kind: g.kind as AnnotationGesture['kind'],
+    ids: sanitizeAnnotationSelection(g.ids),
+  };
+  const dx = gestureNum(g.dx);
+  const dy = gestureNum(g.dy);
+  if (dx !== undefined && dy !== undefined) {
+    out.dx = dx;
+    out.dy = dy;
+  }
+  const b = g.box as Record<string, unknown> | undefined;
+  if (b && typeof b === 'object') {
+    const x = gestureNum(b.x);
+    const y = gestureNum(b.y);
+    const w = gestureNum(b.w);
+    const h = gestureNum(b.h);
+    if (x !== undefined && y !== undefined && w !== undefined && h !== undefined) {
+      out.box = { x, y, w: Math.abs(w), h: Math.abs(h) };
+    }
+  }
+  if (Array.isArray(g.points)) {
+    const pts: number[] = [];
+    const src = g.points.slice(-MAX_GESTURE_POINTS);
+    for (const v of src) {
+      const n = gestureNum(v);
+      if (n === undefined) break;
+      pts.push(n);
+    }
+    if (pts.length % 2 === 1) pts.pop();
+    if (pts.length) out.points = pts;
+  }
+  return out;
+}
+
 function sanitizeViewport(raw: unknown): { x: number; y: number; zoom: number } {
   const fallback = { x: 0, y: 0, zoom: 1 };
   if (!raw || typeof raw !== 'object') return fallback;
@@ -284,6 +356,7 @@ export function sanitizeForeignState(clientID: number, state: unknown): ForeignA
     cursor: sanitizeCursor(s.cursor),
     selection: sanitizeSelection(s.selection),
     annotationSelection: sanitizeAnnotationSelection(s.annotationSelection),
+    annotationGesture: sanitizeAnnotationGesture(s.annotationGesture),
     viewport: sanitizeViewport(s.viewport),
     editing: sanitizeEditingState(s.editing),
   };
@@ -586,6 +659,7 @@ function createSession(slug: string): CollabSession {
       cursor: cur.cursor ?? null,
       selection: cur.selection ?? null,
       annotationSelection: cur.annotationSelection ?? [],
+      annotationGesture: null,
       viewport: cur.viewport ?? { x: 0, y: 0, zoom: 1 },
       editing: cur.editing ?? null,
       __connId: connId,
@@ -894,6 +968,8 @@ export function CollabProvider({ slug, children }: CollabProviderProps): JSX.Ele
           cursor: current.cursor ?? null,
           selection: current.selection ?? null,
           annotationSelection: current.annotationSelection ?? [],
+          // Kept across other fields' publishes (a cursor move mid-drag).
+          annotationGesture: current.annotationGesture ?? null,
           viewport: current.viewport ?? { x: 0, y: 0, zoom: 1 },
           editing: current.editing ?? null,
           __connId: myConnId,

package/apps/studio/whats-new.json

@@ -1,6 +1,33 @@
 {
   "$schema": "./whats-new.schema.json",
   "entries": [
+    {
+      "id": "whiteboard-text-sections-live-previews",
+      "version": "1.5.0",
+      "date": "2026-09-30",
+      "kind": "improvement",
+      "title": "Smoother whiteboard editing, live together",
+      "summary": "Typing in stickies and shapes now wraps exactly as it will look, works with any input method (accents, Japanese), and is never lost — it reaches teammates within a second, and if someone deletes the note you are typing in, Enter puts it back with your text. Sections move, copy and delete together with everything in them, teammates see your drag or resize live before you let go, and undo only takes back your own changes.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "whiteboard-edits-sync-per-element",
+      "version": "1.5.0",
+      "date": "2026-09-30",
+      "kind": "improvement",
+      "title": "Whiteboard edits no longer overwrite each other",
+      "summary": "Each sticky, shape and arrow now saves on its own, so two people editing the same board keep both changes, and even text typed into the same sticky at once is merged. Existing boards convert automatically on start, and editing text is steadier: the cursor stays on a new line after Shift+Enter, double-clicking a word selects it, and Shift+click removes an item from a selection.",
+      "surface": "design-ui"
+    },
+    {
+      "id": "file-tree-remembers-folders",
+      "version": "1.5.0",
+      "date": "2026-09-30",
+      "kind": "improvement",
+      "title": "The file tree remembers your folders",
+      "summary": "The Files panel now starts collapsed and keeps the folders you open, even after you switch panels, reload or restart the app. Opening a canvas unfolds the way to it.",
+      "surface": "design-ui"
+    },
     {
       "id": "comments-stay-where-you-put-them",
       "version": "1.4.6",

package/cli/lib/design-link.mjs

@@ -809,7 +809,11 @@ function collectAdoptManifest(cwd) {
   const files = [];
   try {
     for (const f of readdirSync(base)) {
-      if (f.endsWith('.html') || f.endsWith('.annotations.svg')) {
+      if (
+        f.endsWith('.html') ||
+        f.endsWith('.annotations.json') ||
+        f.endsWith('.annotations.svg')
+      ) {
         try {
           files.push({ rel: `.design/${f}`, bytes: statSync(resolve(base, f)).size });
         } catch {

package/cli/lib/gitignore-block.mjs

@@ -25,7 +25,7 @@ export function buildBlock(designRel = '.design', { s3Assets = false } = {}) {
   // The canonical IGNORED set is the DDR-115 runtime-state taxonomy — kept in
   // lockstep with `apps/studio/git/service.ts` (isMaudeRuntimeState backstop)
   // and the repo's own `.gitignore`. VERSIONED content (canvases, `.meta.json`,
-  // `*.annotations.svg`, `system/**`, `config.json`) is deliberately absent.
+  // `*.annotations.json` (v1 `.svg`), `system/**`, `config.json`) is deliberately absent.
   const lines = [
     BEGIN_MARKER,
     '# Maude design plugin runtime — gitignored even in linked mode (DDR-056/DDR-115).',

package/cli/lib/gitignore-drift.mjs

@@ -37,7 +37,8 @@
  * `gitignore-block.mjs` and the taxonomy in `apps/studio/git/service.ts`.
  */
 const VERSIONED_PATTERNS = [
-  { pattern: '*.annotations.svg', what: 'canvas draw layers (annotations)' },
+  { pattern: '*.annotations.json', what: 'canvas draw layers (annotations)' },
+  { pattern: '*.annotations.svg', what: 'canvas draw layers (annotations, v1 form)' },
   { pattern: '*.meta.json', what: 'canvas sidecars (layout, artboards, tags)' },
   { pattern: '*.tsx', what: 'canvas bodies' },
   { pattern: 'config.json', what: 'the project design config' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1agh/maude",
-  "version": "1.4.6",
+  "version": "1.5.1",
   "description": "Marketplace of Claude Code plugins by Michal Dovrtěl: `design` (canvas-first design iteration) + `flow` (generic agentic workflow loop with .ai second brain). Ships the `maude` CLI (with `mdcc` legacy alias) to scaffold workspace, run the design dev server, and manage configs.",
   "type": "module",
   "engines": {
@@ -58,13 +58,13 @@
     "test:e2e:desktop:parity:cloud": "pnpm --filter @maude/desktop-e2e e2e:parity:cloud"
   },
   "optionalDependencies": {
-    "@1agh/maude-darwin-arm64": "1.4.6",
-    "@1agh/maude-darwin-x64": "1.4.6",
-    "@1agh/maude-linux-arm64": "1.4.6",
-    "@1agh/maude-linux-arm64-musl": "1.4.6",
-    "@1agh/maude-linux-x64": "1.4.6",
-    "@1agh/maude-linux-x64-musl": "1.4.6",
-    "@1agh/maude-win32-x64": "1.4.6"
+    "@1agh/maude-darwin-arm64": "1.5.1",
+    "@1agh/maude-darwin-x64": "1.5.1",
+    "@1agh/maude-linux-arm64": "1.5.1",
+    "@1agh/maude-linux-arm64-musl": "1.5.1",
+    "@1agh/maude-linux-x64": "1.5.1",
+    "@1agh/maude-linux-x64-musl": "1.5.1",
+    "@1agh/maude-win32-x64": "1.5.1"
   },
   "files": [
     "cli",
@@ -131,6 +131,7 @@
     "@decimalturn/toml-patch": "3.0.5",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
+    "diff": "8.0.4",
     "happy-dom": "20.10.6",
     "svgo": "^4.0.1",
     "yaml": "2.9.0"

package/plugins/design/templates/brief-board.tsx.template

@@ -13,7 +13,7 @@
  * a VERBATIM brief and inserts the matching generated artboards right here, below
  * this frame — the board becomes a living brief you sketch and Claude fills in.
  *
- * The annotation layer lives in a sibling `<slug>.annotations.svg` (NEVER in this
+ * The annotation layer lives in a sibling `<slug>.annotations.json` (NEVER in this
  * file), so your notes stay floating on top across every regeneration. No design
  * system tokens or classes are wired in — the board is a neutral surface; the
  * generated artboards bring the DS with them on ingest.

package/apps/studio/annotation-edit-base.ts

@@ -1,36 +0,0 @@
-// Which SVG an annotation edit names as its base (DDR-241 accepted revisions).
-//
-// The project merges an annotation proposal element by element against the
-// text it was derived from. The canvas used to send the CANONICAL
-// re-serialization of the strokes it held — fine while the stored text is
-// canonical too, and silently fatal when it is not: an element written by an
-// older serializer, a hand edit or any other writer then looks changed on BOTH
-// sides, the merge refuses it as a conflict, and the person's edit is reverted
-// without a word (plan T31, L09 arrowheads on a non-canonical arrow).
-//
-// An edit made on exactly the state this canvas last RECEIVED names the text
-// it received — the project then sees "nothing changed underneath", accepts
-// the edit whole, and the stored text becomes canonical as a side effect. Any
-// other state (edits stacked before the echo returns) is this canvas's own
-// canonical output, which is what the project holds after accepting it.
-
-import { type Stroke, strokesToSvg } from './annotations-model.ts';
-
-export interface ReceivedAnnotations {
-  /** The SVG text exactly as the project delivered it. */
-  raw: string;
-  /** The same state as this client serializes it. */
-  canon: string;
-}
-
-export function receivedAnnotations(raw: string, strokes: readonly Stroke[]): ReceivedAnnotations {
-  return { raw, canon: strokesToSvg(strokes) };
-}
-
-export function annotationEditBase(
-  before: readonly Stroke[],
-  received: ReceivedAnnotations | null
-): string {
-  const canon = strokesToSvg(before);
-  return received && received.canon === canon ? received.raw : canon;
-}