@1agh/maude 1.4.1 → 1.4.3

package/apps/studio/canvas-lib.tsx

@@ -3200,6 +3200,21 @@ export function PhotoPreviewBridge() {
   // clobbering a NEWER edit that already resolved first.
   const tokenRef = useRef<Map<string, number>>(new Map());
   const bakeTimers = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());
+  // Per-asset FETCH generation — the same guard one step earlier. Two synced
+  // edits in a row start two sidecar fetches, and the older answer can arrive
+  // last: applying it put the previous edit back on screen while every disk had
+  // the newer one (surface run 2026-09-16, L13 on the hub: shown, then
+  // reverted). A live preview counts as newer than any fetch in flight.
+  const fetchGenRef = useRef<Map<string, number>>(new Map());
+  const nextFetchGen = useCallback((asset: string): number => {
+    const g = (fetchGenRef.current.get(asset) ?? 0) + 1;
+    fetchGenRef.current.set(asset, g);
+    return g;
+  }, []);
+  const isLatestFetch = useCallback(
+    (asset: string, g: number): boolean => fetchGenRef.current.get(asset) === g,
+    []
+  );
 
   const bake = useCallback((asset: string, original: string, edit: PhotoEdit) => {
     const token = (tokenRef.current.get(asset) ?? 0) + 1;
@@ -3231,6 +3246,8 @@ export function PhotoPreviewBridge() {
       clearTimeout(timers.get(asset));
       if (!edit || isDefaultEdit(edit)) {
         timers.delete(asset);
+        // A bake already rendering an earlier edit must not land over this.
+        tokenRef.current.set(asset, (tokenRef.current.get(asset) ?? 0) + 1);
         setPhotoElSrc(el, original);
         return;
       }
@@ -3270,17 +3287,20 @@ export function PhotoPreviewBridge() {
         }
       }
       if (!asset) return; // no photo on this canvas uses that asset
-      fetch(`/_api/photo-edit?asset=${encodeURIComponent(asset)}`)
+      const target = asset;
+      const g = nextFetchGen(target);
+      fetch(`/_api/photo-edit?asset=${encodeURIComponent(target)}`)
         .then((r) => (r.ok ? r.json() : null))
         .then((edit) => {
+          if (!isLatestFetch(target, g)) return; // a newer answer owns the render
           // A deleted/reset edit applies as null → restores the original src.
-          apply(asset as string, edit && !isDefaultEdit(edit) ? (edit as PhotoEdit) : null);
+          apply(target, edit && !isDefaultEdit(edit) ? (edit as PhotoEdit) : null);
         })
         .catch(() => {});
     };
     document.addEventListener('maude:photo-edit-refreshed', onRefreshed);
     return () => document.removeEventListener('maude:photo-edit-refreshed', onRefreshed);
-  }, [apply]);
+  }, [apply, nextFetchGen, isLatestFetch]);
 
   useEffect(() => {
     const onMsg = (e: MessageEvent) => {
@@ -3304,11 +3324,12 @@ export function PhotoPreviewBridge() {
       if (m.dgn !== 'photo-preview' || typeof m.asset !== 'string') return;
       const asset = m.asset;
       const edit = (m.edit ?? null) as PhotoEdit | null;
+      nextFetchGen(asset);
       apply(asset, edit);
     };
     window.addEventListener('message', onMsg);
     return () => window.removeEventListener('message', onMsg);
-  }, [apply]);
+  }, [apply, nextFetchGen]);
   // Boot-time (+ ongoing) hydration from the PERSISTED sidecar, not just the
   // live `photo-preview` message above. Without this, a saved PhotoEdit is
   // invisible after anything that re-mounts the canvas doc (Cmd+R, an
@@ -3342,10 +3363,11 @@ export function PhotoPreviewBridge() {
         if (!asset || attempted.has(asset)) continue;
         if (++scanned > MAX_SCAN_PER_PASS) break;
         attempted.add(asset);
+        const g = nextFetchGen(asset);
         fetch(`/_api/photo-edit?asset=${encodeURIComponent(asset)}`)
           .then((r) => (r.ok ? r.json() : null))
           .then((edit) => {
-            if (cancelled || !edit || isDefaultEdit(edit)) return;
+            if (cancelled || !isLatestFetch(asset, g) || !edit || isDefaultEdit(edit)) return;
             apply(asset, edit);
           })
           .catch(() => {});
@@ -3367,7 +3389,7 @@ export function PhotoPreviewBridge() {
       cancelAnimationFrame(raf);
       observer.disconnect();
     };
-  }, [apply]);
+  }, [apply, nextFetchGen, isLatestFetch]);
   return null; // mutates the real elements directly — no visible DOM of its own.
 }
 PhotoPreviewBridge.displayName = 'PhotoPreviewBridge';

package/apps/studio/client/app.jsx

@@ -12,6 +12,7 @@ import { createRoot } from 'react-dom/client';
 // import that Bun erases), so this pulls only string constants into the client
 // bundle — no React, no input-router. See the tool-cursor handler below.
 import { resolveToolCursor } from '../canvas-cursors.ts';
+import { commandForEnter, matchCommands } from './command-palette-match.js';
 import {
   defaultScopeForFormat,
   isScopeValidForFormat,
@@ -878,15 +879,7 @@ function CommandPalette({ open, onClose, actions }) {
       ?.querySelector('.st-pal-item.is-active')
       ?.scrollIntoView({ block: 'nearest' });
   }, [active]);
-  const filtered = useMemo(() => {
-    const needle = q.trim().toLowerCase();
-    if (!needle) return actions;
-    return actions.filter(
-      (a) =>
-        a.label.toLowerCase().includes(needle) ||
-        (a.group && a.group.toLowerCase().includes(needle))
-    );
-  }, [q, actions]);
+  const filtered = useMemo(() => matchCommands(actions, q), [q, actions]);
   useEffect(() => {
     if (active >= filtered.length) setActive(0);
   }, [filtered.length, active]);
@@ -925,7 +918,8 @@ function CommandPalette({ open, onClose, actions }) {
                 setActive((i) => Math.max(0, i - 1));
               } else if (e.key === 'Enter') {
                 e.preventDefault();
-                if (filtered[active]) run(filtered[active]);
+                const pick = commandForEnter(actions, q, e.currentTarget.value, active);
+                if (pick) run(pick);
               }
             }}
           />

package/apps/studio/client/command-palette-match.js

@@ -0,0 +1,35 @@
+// command-palette-match.js — which ⌘K command a query names.
+//
+// Kept out of app.jsx so the one decision that matters — what Enter runs —
+// can be tested on its own.
+
+/** The commands a query matches, in list order (label or group substring). */
+export function matchCommands(actions, query) {
+  const needle = String(query ?? '')
+    .trim()
+    .toLowerCase();
+  if (!needle) return actions;
+  return actions.filter(
+    (a) => a.label.toLowerCase().includes(needle) || (a.group && a.group.toLowerCase().includes(needle))
+  );
+}
+
+/**
+ * The command Enter runs.
+ *
+ * WHAT IS IN THE BOX, not what the last render saw. A query typed or pasted
+ * and confirmed at once can reach Enter before the list re-rendered for it;
+ * the rendered list is then the unfiltered one and its first row — "New brief
+ * board" — ran instead of the command that was asked for (surface run
+ * 2026-09-16, "New video" on the hub). When the box and the rendered query
+ * disagree, the box wins and its first match runs; when they agree, the
+ * highlighted row does.
+ */
+export function commandForEnter(actions, renderedQuery, liveQuery, activeIndex) {
+  const norm = (s) =>
+    String(s ?? '')
+      .trim()
+      .toLowerCase();
+  if (norm(liveQuery) !== norm(renderedQuery)) return matchCommands(actions, liveQuery)[0] ?? null;
+  return matchCommands(actions, renderedQuery)[activeIndex] ?? null;
+}

package/apps/studio/collab/index.ts

@@ -1,14 +1,15 @@
 // Public surface of the collab module. Bundles the registry + persistence
 // wiring so ws.ts + server.ts don't need to know about the internal split.
 
-import { readFileSync } from 'node:fs';
+import { readFileSync, statSync } from 'node:fs';
 import path from 'node:path';
 
 import type { Api } from '../api.ts';
 import type { Context } from '../context.ts';
 
+import { applyCommentsToDoc } from '../sync/codec.ts';
 import { createPersistence, Y_TYPES } from './persistence.ts';
-import { createRegistry, type Registry } from './registry.ts';
+import { applyAnnotationsToDoc, createRegistry, type Registry } from './registry.ts';
 
 export type { CollabConn } from './protocol.ts';
 export type { Registry } from './registry.ts';
@@ -63,6 +64,29 @@ export function createCollab(ctx: Context, api: Api): Collab {
     api,
     fileForSlug,
     shouldSeed: (slug) => !(ctx.sharedDoc && registryRef?.isPinned(slug)),
+    // A room restored from its own `.ydoc.bin` must not outrank a sidecar the
+    // hub (or an editor) wrote after that cache — see `reconcileAfterCache`.
+    // Only for rooms no hub provider owns: a pinned doc is the hub's replica
+    // and file→doc imports belong to the sync agent's diff-aware lane.
+    reconcileAfterCache: async (slug, doc, cachedAtMs) => {
+      if (registryRef?.isPinned(slug)) return;
+      const newerThanCache = (abs: string): boolean => {
+        try {
+          return statSync(abs).mtimeMs > cachedAtMs;
+        } catch {
+          return false;
+        }
+      };
+      const file = await fileForSlug(slug);
+      if (!file) return;
+      if (newerThanCache(path.join(ctx.paths.designRoot, `${slug}.annotations.svg`))) {
+        const svg = await api.loadAnnotations(file);
+        if (svg) applyAnnotationsToDoc(doc, svg, 'seed');
+      }
+      if (newerThanCache(path.join(ctx.paths.commentsDir, `${slug}.json`))) {
+        applyCommentsToDoc(doc, await api.loadCommentsForFile(file), 'seed');
+      }
+    },
   });
   // Accepted revisions: browser writes to a synced canvas's room are refused
   // (the room doc is the hub's accepted replica). Asked per frame — the save
@@ -85,6 +109,10 @@ export function createCollab(ctx: Context, api: Api): Collab {
   //     a hub-pushed comment shows up on the peer's sidebar without a reload.
   // The registry's no-op guards make an identical re-seed free, so this can't
   // loop against the room's own persist (which also writes the file).
+  // A mounted room with no hub provider takes external disk changes; a pinned
+  // one leaves them to the sync agent.
+  const ownsRoomFromDisk = (slug: string): boolean =>
+    registry.peek(slug) !== null && !registry.isPinned(slug);
   const reseedFromDisk = async (rel: string): Promise<void> => {
     const cm = /^_comments\/(.+)\.json$/.exec(rel);
     const am = /^(.+)\.annotations\.svg$/.exec(rel);
@@ -101,15 +129,17 @@ export function createCollab(ctx: Context, api: Api): Collab {
           ? await api.loadCommentsForFile(file)
           : JSON.parse(readFileSync(abs, 'utf8'));
         if (!Array.isArray(parsed)) return;
-        // Phase 9.2 (DDR-064): under sharedDoc the hub provider is attached to
-        // the single room doc, so a hub-pushed comment is ALREADY in the room —
-        // the wholesale re-seed (last-writer-wins blob copy) is the retired
-        // clobber path. The agent's diff-aware applyFromFs handles external
-        // file→doc imports instead. The sidebar still needs the 'comments' bus
-        // emit, so keep that unconditionally.
-        if (!ctx.sharedDoc && registry.peek(slug)) registry.syncRoomFromComments(slug, parsed);
+        // Phase 9.2 (DDR-064): when a hub provider is attached to the room
+        // (pinned), a hub-pushed comment is ALREADY in the doc and the agent's
+        // diff-aware applyFromFs owns external file→doc imports — re-seeding
+        // would be the retired clobber path. The test is the PIN, not
+        // `ctx.sharedDoc`: sharedDoc defaults on everywhere, including a cell
+        // without live pairing, where no provider exists and disk is the only
+        // way the hub's accepted state reaches the room. The sidebar still
+        // needs the 'comments' bus emit, so keep that unconditionally.
+        if (ownsRoomFromDisk(slug)) registry.syncRoomFromComments(slug, parsed);
         if (file) ctx.bus.emit('comments', { file, comments: parsed });
-      } else if (!ctx.sharedDoc && registry.peek(slug)) {
+      } else if (ownsRoomFromDisk(slug)) {
         registry.syncRoomFromAnnotations(slug, readFileSync(abs, 'utf8'));
       }
     } catch {

package/apps/studio/collab/persistence.ts

@@ -49,6 +49,17 @@ export interface PersistenceDeps {
    * slugs. Absent → always seed (flag-OFF behavior, unchanged).
    */
   shouldSeed?: (slug: string) => boolean;
+  /**
+   * Called after `seed` restored a room from its `.ydoc.bin` cache, with the
+   * cache's mtime. The cache is this process's own snapshot, so it can be older
+   * than the on-disk sidecars: in a cell without live pairing the hub projects
+   * accepted comments/annotations onto disk while the room is closed, and a room
+   * rebuilt from the cache alone would serve the pre-projection board forever.
+   * The callback brings the doc forward from any sidecar written after the cache
+   * (a causal update ON TOP of the cached state, never a second independent
+   * seed). Absent → cache-only restore, the previous behavior.
+   */
+  reconcileAfterCache?: (slug: string, doc: Y.Doc, cachedAtMs: number) => Promise<void>;
 }
 
 /**
@@ -173,12 +184,12 @@ export function createPersistence(deps: PersistenceDeps): RoomCallbacks {
     return path.join(stateDir, `${slug}.ydoc.bin`);
   }
 
-  async function readBinary(slug: string): Promise<Uint8Array | null> {
+  async function readBinary(slug: string): Promise<{ bytes: Uint8Array; mtimeMs: number } | null> {
     try {
       const file = Bun.file(ydocBinPath(slug));
       if (!(await file.exists())) return null;
       const buf = await file.arrayBuffer();
-      return new Uint8Array(buf);
+      return { bytes: new Uint8Array(buf), mtimeMs: file.lastModified };
     } catch {
       return null;
     }
@@ -201,8 +212,9 @@ export function createPersistence(deps: PersistenceDeps): RoomCallbacks {
 
     // Step 1 — try the binary cache.
     const binary = await readBinary(slug);
-    if (binary && binary.byteLength > 0) {
-      Y.applyUpdate(doc, binary);
+    if (binary && binary.bytes.byteLength > 0) {
+      Y.applyUpdate(doc, binary.bytes);
+      await deps.reconcileAfterCache?.(slug, doc, binary.mtimeMs);
       return;
     }
 

package/apps/studio/collab/registry.ts

@@ -7,6 +7,7 @@
 // prompt — see DDR-051 §3.
 
 import type { Awareness } from 'y-protocols/awareness';
+import type * as Y from 'yjs';
 
 import { ANNOTATION_WRITE_ID, validAnnotationWriteId } from '../annotations-sync.ts';
 import { applyCommentsToDoc } from '../sync/codec.ts';
@@ -108,6 +109,30 @@ export interface Registry {
   size(): number;
 }
 
+/**
+ * Replace a doc's annotation SVG — the one write shape shared by the live
+ * disk→room bridge and the cache-restore reconcile (`collab/index.ts`).
+ * Identical disk notifications stay no-ops (no update → no persist loop); a UI
+ * operation may deliberately restore identical content under a new write id.
+ * Returns whether the doc changed.
+ */
+export function applyAnnotationsToDoc(
+  doc: Y.Doc,
+  svg: string,
+  origin: unknown,
+  writeId?: string
+): boolean {
+  const map = doc.getMap<string>(Y_TYPES.annotations);
+  const id = validAnnotationWriteId(writeId) ? writeId : undefined;
+  if (map.get('svg') === svg && (!id || map.get(ANNOTATION_WRITE_ID) === id)) return false;
+  doc.transact(() => {
+    map.set('svg', svg);
+    if (id) map.set(ANNOTATION_WRITE_ID, id);
+    else map.delete(ANNOTATION_WRITE_ID);
+  }, origin);
+  return true;
+}
+
 export function createRegistry(callbacks: RoomCallbacks): Registry {
   const rooms = new Map<string, Room>();
   // Hub-side Awareness per slug (lives as long as the sync provider). Rooms
@@ -196,16 +221,7 @@ export function createRegistry(callbacks: RoomCallbacks): Registry {
   function syncRoomFromAnnotations(slug: string, svg: string, writeId?: string): void {
     const room = rooms.get(slug);
     if (!room) return;
-    const map = room.doc.getMap<string>(Y_TYPES.annotations);
-    // Identical disk notifications remain no-ops. A new UI operation may
-    // deliberately restore identical content while an author has pending work.
-    const id = validAnnotationWriteId(writeId) ? writeId : undefined;
-    if (map.get('svg') === svg && (!id || map.get(ANNOTATION_WRITE_ID) === id)) return;
-    room.doc.transact(() => {
-      map.set('svg', svg);
-      if (id) map.set(ANNOTATION_WRITE_ID, id);
-      else map.delete(ANNOTATION_WRITE_ID);
-    }, 'inspector-write');
+    applyAnnotationsToDoc(room.doc, svg, 'inspector-write', writeId);
   }
 
   function setAgentEditing(slug: string, state: { name: string; since: number } | null): void {