@1agh/maude 1.2.0 → 1.3.0

package/apps/studio/sync/agent.ts

@@ -52,12 +52,10 @@ import {
   cssFromDoc,
   htmlFromDoc,
   isEmptyAnnotationsSvg,
-  markSeeded,
   mergeSharedMetaIntoLocal,
   metaFromDoc,
   movedToFromDoc,
   repairSharedMeta,
-  seededByFromDoc,
   stampAnnotationsEdit,
   stampBodyEdit,
   Y_SYNC_TYPES,
@@ -66,13 +64,13 @@ import {
   decideAnnotationsColdStart,
   decideColdStart,
   decideCssColdStart,
-  isExactRepeat,
   unionCommentsById,
 } from './cold-start.ts';
 import { applyColdStart, type ColdStartSnapshotReason } from './cold-start-apply.ts';
 import { dedupeCommentsById, hasDuplicateComments } from './comment-identity.ts';
 import { type EchoGuard, hashBytes } from './echo-guard.ts';
 import type { SyncJournal } from './journal.ts';
+import { rememberSeed, repairSeedDuplication } from './seed-repair.ts';
 
 export const DOC_FLUSH_MS = 800;
 
@@ -82,7 +80,7 @@ export const DOC_FLUSH_MS = 800;
  * the cold-start race — a genuine peer edit that arrives minutes later is NEVER
  * collapsed back to our original seed. Generous relative to the hub sync RTT.
  */
-export const SEED_REPAIR_WINDOW_MS = 10_000;
+export { SEED_REPAIR_WINDOW_MS } from './seed-repair.ts';
 
 export interface CanvasSyncPaths {
   /** Absolute path to <designRoot>/<canvas>.html. */
@@ -187,18 +185,6 @@ export function createCanvasSyncAgent(opts: CanvasSyncAgentOptions): CanvasSyncA
   let lastMeta: string | null = null;
   let lastCss: string | null = null;
 
-  // F1 — the content this agent pushed on `seed-local-up`, plus the deadline
-  // past which the de-dup repair stops firing. Set on seed; nulled only when the
-  // window lapses (after convergence the repair is a cheap no-op — the
-  // `=== seedInfo.x` guards short-circuit, so we don't bother clearing).
-  // Null = this agent never seeded (so it never repairs).
-  //
-  // `css` rides along with the body (issue #114): a seed writes BOTH lanes in
-  // the same breath, so both can collide with a concurrent peer's identical
-  // seed, and repairing only the body left the canvas un-buildable anyway —
-  // duplicated css is as fatal to the build as a duplicated `export default`.
-  let seedInfo: { body: string; css: string | null; until: number } | null = null;
-
   function onDocUpdate(_update: Uint8Array, updateOrigin: unknown): void {
     if (stopped) return;
     // Self-applied (we just synced from disk) — disk is already current.
@@ -246,45 +232,14 @@ export function createCanvasSyncAgent(opts: CanvasSyncAgentOptions): CanvasSyncA
    * variant is an accepted follow-up, not handled in-flight.
    */
   function maybeRepairSeedDuplication(): void {
-    if (!seedInfo) return;
-    if (Date.now() > seedInfo.until) {
-      seedInfo = null;
-      return;
-    }
-    const owner = seededByFromDoc(doc);
-    if (owner === null || owner !== doc.clientID) return; // not the elected writer
-    const seeded = seedInfo;
-    const repaired: string[] = [];
-
-    const body = htmlFromDoc(doc);
-    // `=== seeded.body` → already a single copy; not an exact repeat → a
-    // divergent edit, which carries genuine bytes and belongs to the conflict
-    // path, not to a silent collapse.
-    if (body !== seeded.body && isExactRepeat(body, seeded.body)) {
-      const canonical = seeded.body;
-      doc.transact(() => {
-        if (applyHtmlToDoc(doc, canonical, origin)) stampBodyEdit(doc, origin);
-      }, origin);
-      lastHtml = canonical;
-      opts.journal?.record(slug, { bodyHash: hashBytes(canonical) });
-      repaired.push('body');
+    const repaired = repairSeedDuplication(doc, origin);
+    if (repaired.includes('body')) {
+      lastHtml = htmlFromDoc(doc);
+      opts.journal?.record(slug, { bodyHash: hashBytes(lastHtml) });
     }
-
-    // The css half of the same collision (issue #114). Same proof obligation as
-    // the body — an exact integer repeat of what WE seeded — and the same
-    // idempotence: the collapse deletes the same CRDT items on every peer that
-    // runs it, so concurrent recoveries converge instead of fighting.
-    if (paths.css && seeded.css !== null) {
-      const css = cssFromDoc(doc);
-      if (css !== null && css !== seeded.css && isExactRepeat(css, seeded.css)) {
-        const canonicalCss = seeded.css;
-        doc.transact(() => {
-          applyCssToDoc(doc, canonicalCss, origin);
-        }, origin);
-        lastCss = canonicalCss;
-        opts.journal?.record(slug, { cssHash: hashBytes(canonicalCss) });
-        repaired.push('css');
-      }
+    if (repaired.includes('css')) {
+      lastCss = cssFromDoc(doc);
+      if (lastCss !== null) opts.journal?.record(slug, { cssHash: hashBytes(lastCss) });
     }
 
     if (repaired.length > 0) {
@@ -518,9 +473,8 @@ export function createCanvasSyncAgent(opts: CanvasSyncAgentOptions): CanvasSyncA
           // F1 — adopt is also a "seed local up" (first link / fresh hub); claim
           // it + arm the repair window so two peers adopting the same draft into
           // one hub at once self-heal the same way the decision-table seed does.
-          markSeeded(doc, origin);
+          rememberSeed(doc, localHtml, localCss, origin);
         }, origin);
-        seedInfo = { body: localHtml, css: localCss, until: Date.now() + SEED_REPAIR_WINDOW_MS };
       }
       if (localComments !== null) {
         const parsed = tryParseJsonArray(localComments);
@@ -575,15 +529,13 @@ export function createCanvasSyncAgent(opts: CanvasSyncAgentOptions): CanvasSyncA
         if (applyHtmlToDoc(doc, body, origin)) stampBodyEdit(doc, origin);
         // F1 — claim the seed (clientID marker) in the SAME update so a
         // concurrent second seeder's merge resolves a single elected writer.
-        markSeeded(doc, origin);
+        rememberSeed(doc, body, localCss, origin);
       }, origin);
       lastHtml = body;
       // Arm the de-dup repair window: if another peer seeded the same content at
       // the same instant, the merged Y.Text will double — maybeRepairSeedDuplication
       // (on the elected owner) collapses it back during this window. `localCss`
-      // is armed too: the css lane is seeded by the same cold start a few lines
-      // below and collides identically (issue #114).
-      seedInfo = { body, css: localCss, until: Date.now() + SEED_REPAIR_WINDOW_MS };
+      // is remembered too, since it collides identically (issue #114).
       opts.journal?.record(slug, { bodyHash: hashBytes(body) });
     };
 

package/apps/studio/sync/cell-file-events.ts

@@ -89,6 +89,9 @@ export function startCellFileEvents(
     url: target.url,
     token: target.token,
     onPoke: (head) => healer.onPoke(head),
+    // The paired cell runtime does not open a second control provider. Route
+    // metadata invalidation to its bounded discovery queue, not the journal.
+    onDocuments: () => ctx.bus.emit('sync:documents-changed'),
   });
 
   // Every write this process makes surfaces here, because both synthetic-event

package/apps/studio/sync/codec.ts

@@ -1,3 +1,4 @@
+import { ANNOTATION_WRITE_ID } from '../annotations-sync.ts';
 // Y.Doc ↔ disk codecs for the bidirectional file sync agent (Phase 9 Task 4).
 //
 // The agent shuttles three classes of files between disk and the Y.Doc the
@@ -22,11 +23,11 @@
 // in the unchanged regions.
 
 import { hostname } from 'node:os';
-
+import { diffChars } from 'diff';
 import type * as Y from 'yjs';
 
 import { Y_TYPES } from '../collab/persistence.ts';
-import { commentKey } from './comment-identity.ts';
+import { commentKey, dedupeCommentsById } from './comment-identity.ts';
 import {
   MAX_ANNOTATIONS_BYTES,
   MAX_COMMENTS_BYTES,
@@ -97,8 +98,8 @@ export function htmlFromDoc(doc: Y.Doc): string {
 }
 
 /**
- * Apply `next` to one Y.Text lane as a minimal common-prefix / common-suffix
- * replace, so peers see a small op rather than a full replace.
+ * Apply `next` as bounded text hunks, preserving unchanged interior CRDT
+ * anchors as well as the common prefix/suffix (#121).
  *
  * THIS SHAPE IS A CONVERGENCE PROPERTY, NOT AN OPTIMIZATION (issue #114).
  * Collapsing a concurrency-duplicated lane — `X + X` back to `X` — comes out of
@@ -137,12 +138,37 @@ function applyTextLane(doc: Y.Doc, lane: string, next: string, origin?: unknown)
     suffix++;
   }
 
+  // Y.Text offsets are UTF-16; never leave half a surrogate outside a hunk.
+  if (prefix > 0 && /[\uD800-\uDBFF]/.test(current[prefix - 1] ?? '')) prefix--;
+  if (suffix > 0 && /[\uDC00-\uDFFF]/.test(current[current.length - suffix] ?? '')) suffix--;
   const deleteLen = current.length - prefix - suffix;
   const insertStr = next.slice(prefix, next.length - suffix);
 
+  // Keep pure inserts/deletes (especially repeat collapse) as one operation.
+  // For replacements preserve interior anchors: one prefix/suffix splice can
+  // move a concurrent insertion inside an unrelated JSX attribute (#121).
+  const changes =
+    deleteLen > 0 && insertStr.length > 0
+      ? diffChars(current.slice(prefix, current.length - suffix), insertStr, {
+          maxEditLength: 4096,
+          timeout: 50,
+        })
+      : null;
+  if (changes === undefined) throw new Error('Source diff exceeds the safe merge budget');
   doc.transact(() => {
-    if (deleteLen > 0) yText.delete(prefix, deleteLen);
-    if (insertStr.length > 0) yText.insert(prefix, insertStr);
+    if (changes) {
+      let offset = prefix;
+      for (const change of changes) {
+        if (change.removed) yText.delete(offset, change.value.length);
+        else {
+          if (change.added) yText.insert(offset, change.value);
+          offset += change.value.length;
+        }
+      }
+    } else {
+      if (deleteLen > 0) yText.delete(prefix, deleteLen);
+      if (insertStr.length > 0) yText.insert(prefix, insertStr);
+    }
   }, origin);
 
   return true;
@@ -306,6 +332,8 @@ export function applyAnnotationsToDoc(doc: Y.Doc, next: string | null, origin?:
   if (currentStr === next) return false;
 
   doc.transact(() => {
+    // A filesystem import is a new operation, never the previous UI author's echo.
+    map.delete(ANNOTATION_WRITE_ID);
     if (next === null || next === '') {
       map.delete('svg');
     } else {
@@ -389,6 +417,45 @@ function parsesAsObject(s: string): boolean {
 }
 
 /** The synced shared-meta JSON string held in the doc, or null when unset. */
+/**
+ * The canonical LANE value for a file's text — what the accepted-revisions
+ * kernel stores and what `readLaneFromDoc` returns once it is accepted
+ * (DDR-241). `null` when the file text cannot be a value of that lane.
+ */
+export function laneValueFromFile(
+  lane: 'html' | 'css' | 'meta' | 'annotations' | 'comments',
+  text: string
+): string | null {
+  if (lane === 'html' || lane === 'css' || lane === 'annotations') return text;
+  let parsed: unknown;
+  try {
+    parsed = parseJsonSafe(text);
+  } catch {
+    return null;
+  }
+  if (lane === 'meta') {
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+    return sharedMetaCanonical(parsed as Record<string, unknown>);
+  }
+  if (!Array.isArray(parsed)) return null;
+  const list = dedupeCommentsById(parsed);
+  return list.length ? JSON.stringify(list) : '';
+}
+
+/** A lane's value as the accepted replica holds it (same canonical form). */
+export function readLaneFromDoc(
+  doc: Y.Doc,
+  lane: 'html' | 'css' | 'meta' | 'annotations' | 'comments'
+): string {
+  if (lane === 'html' || lane === 'css' || lane === 'meta') return doc.getText(lane).toString();
+  if (lane === 'annotations') {
+    const svg = doc.getMap<unknown>(Y_TYPES.annotations).get('svg');
+    return typeof svg === 'string' ? svg : '';
+  }
+  const list = doc.getArray<unknown>(Y_TYPES.comments).toArray();
+  return list.length ? JSON.stringify(list) : '';
+}
+
 export function metaFromDoc(doc: Y.Doc): string | null {
   return normalizeSharedMeta(doc.getText(Y_SYNC_TYPES.meta).toString());
 }

package/apps/studio/sync/ctl-provider.ts

@@ -95,6 +95,8 @@ export interface CtlProviderOptions {
   token: string;
   /** Fired with the hub's head on every well-formed poke. */
   onPoke: (head: number) => void;
+  /** Optional fast document-list invalidation; older consumers use onPoke. */
+  onDocuments?: () => void;
   documentName?: string;
   log?: Pick<Console, 'log' | 'warn' | 'error'>;
   /** Injected in tests; production builds one from `@hocuspocus/provider`. */
@@ -155,9 +157,19 @@ export function createCtlProvider(opts: CtlProviderOptions): CtlProvider {
 
   const wire = (p: CtlProviderLike): void => {
     p.on('status', (data: { status?: string }) => {
-      if (typeof data?.status === 'string') status = data.status;
+      if (typeof data?.status !== 'string') return;
+      const reconnect = data.status === 'connected' && status !== 'connected';
+      status = data.status;
+      if (reconnect && !stopped) {
+        try {
+          opts.onDocuments?.();
+        } catch (error) {
+          log.error?.(`[sync/ctl] discovery handler threw: ${(error as Error).message}`);
+        }
+      }
     });
     p.on('stateless', (data: { payload: string }) => {
+      if (stopped) return;
       const poke = parsePoke(data?.payload);
       if (poke === null) {
         malformed += 1;
@@ -172,7 +184,8 @@ export function createCtlProvider(opts: CtlProviderOptions): CtlProvider {
       }
       received += 1;
       try {
-        opts.onPoke(poke.head);
+        if (poke.documents && opts.onDocuments) opts.onDocuments();
+        else opts.onPoke(poke.head);
       } catch (err) {
         log.error?.(`[sync/ctl] poke handler threw: ${(err as Error).message}`);
       }

package/apps/studio/sync/document-discovery.ts

@@ -0,0 +1,81 @@
+// A bounded metadata read queue. File walks/uploads have their own scheduler.
+// A notification during a read requires another read: the first response may
+// already describe the old head. Keep one pending pass, never an unbounded queue.
+export function createDocumentDiscovery(opts: {
+  run: () => Promise<void>;
+  onError: (error: unknown) => void;
+  delayMs?: number;
+  minIntervalMs?: number;
+  now?: () => number;
+  setTimer?: (cb: () => void, ms: number) => ReturnType<typeof setTimeout>;
+  clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
+}) {
+  const now = opts.now ?? Date.now;
+  const setTimer = opts.setTimer ?? setTimeout;
+  const clearTimer = opts.clearTimer ?? clearTimeout;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let running = false;
+  let pending = false;
+  let stopped = false;
+  let lastStarted = -Infinity;
+  let waiters: Array<() => void> = [];
+
+  function arm(immediate = false) {
+    if (stopped || running || timer !== null || !pending) return;
+    const delay = Math.max(
+      immediate ? 0 : (opts.delayMs ?? 50),
+      (opts.minIntervalMs ?? 250) - (now() - lastStarted)
+    );
+    timer = setTimer(() => {
+      timer = null;
+      void drain();
+    }, delay);
+    timer.unref?.();
+  }
+
+  async function drain() {
+    if (stopped || running || !pending) return;
+    running = true;
+    pending = false;
+    lastStarted = now();
+    const currentWaiters = waiters;
+    waiters = [];
+    try {
+      await opts.run();
+    } catch (error) {
+      opts.onError(error);
+    } finally {
+      running = false;
+      for (const resolve of currentWaiters) resolve();
+      arm();
+    }
+  }
+
+  return {
+    schedule() {
+      if (!stopped) {
+        pending = true;
+        arm();
+      }
+    },
+    flush(): Promise<void> {
+      if (stopped) return Promise.resolve();
+      pending = true;
+      const done = new Promise<void>((resolve) => waiters.push(resolve));
+      if (timer !== null) {
+        clearTimer(timer);
+        timer = null;
+      }
+      arm(true);
+      return done;
+    },
+    stop() {
+      stopped = true;
+      pending = false;
+      if (timer !== null) clearTimer(timer);
+      timer = null;
+      for (const resolve of waiters) resolve();
+      waiters = [];
+    },
+  };
+}

package/apps/studio/sync/file-membership.ts

@@ -105,7 +105,7 @@ const INERT_MEDIA_EXTS = new Set([
   'ttf',
   'otf',
 ]);
-const COMPANION_TEXT_EXTS = new Set(['css', 'md', 'srt']);
+const COMPANION_TEXT_EXTS = new Set(['css', 'md', 'srt', 'vtt']);
 const CODE_MODULE_EXTS = new Set(['ts', 'tsx', 'js', 'mjs']);
 
 /**
@@ -118,7 +118,15 @@ const CODE_MODULE_EXTS = new Set(['ts', 'tsx', 'js', 'mjs']);
  * machine silently loses every photo edit — the exact bug class this module
  * exists to end.
  */
-const COMPANION_SIDECAR_SUFFIXES = ['.photo.json', '.audio.json'];
+// + the footage analysis, component registry, edit decision list: versioned
+// sidecars (DDR-115) the T32 scale run found never reaching a peer.
+const COMPANION_SIDECAR_SUFFIXES = [
+  '.photo.json',
+  '.audio.json',
+  '.footage.json',
+  '.registry.json',
+  '.edl.json',
+];
 
 /**
  * A DIRECTORY segment must start alphanumeric — the same rule as the hub's