@1agh/maude 1.4.2 → 1.4.3

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 {