@helping-ai-workflow/md2doc 3.4.2 → 3.6.0

package/lib/editor/wave-store.js

@@ -41,7 +41,6 @@
  *     about it — rewrite the block, cancel, edit by hand — belongs to the
  *     layer that can ask them, and re-serialising the block behind their back
  *     is the one answer this file may never give.
-" PLACEHOLDER 
  *
  * A throw inside an `apply` callback is NOT caught. The store's own state is
  * untouched when one happens (nothing is pushed until the new document is in
@@ -63,6 +62,17 @@ const C = require('./wave-codec.js');
  */
 const MAX_DEPTH = C.MAX_DEPTH;
 
+/**
+ * The undo stack's cap, in entries.
+ *
+ * Every entry holds a whole frozen document, so an unbounded stack grows with
+ * the length of the editing session rather than with anything about the
+ * document. 200 is a ruling, not a measurement of any observed cost — there is
+ * no profiling behind the number, just a decision that a session's undo depth
+ * stops mattering well before 200 steps back.
+ */
+const HISTORY_LIMIT = 200;
+
 /**
  * Open a store over one wavedrom block's source text.
  *
@@ -141,6 +151,23 @@ function createStore(sourceText) {
       origins: origins,
     });
     at++;
+    // Cap the stack, not just its growth: apply always leaves `at` on the
+    // entry it just pushed (the truncation above already dropped any redo
+    // tail), so history.length is always at + 1 here. Dropping the oldest
+    // entry when the cap is exceeded means `at` has to move down with it, or
+    // every canUndo/undoName/redo answer after the drop would be off by one —
+    // pointing one entry short of the one actually current.
+    // `while`, not `if`: apply today only ever pushes one entry per call, so
+    // the stack is never more than one over the cap and `if` is provably
+    // enough — but that "one entry per call" fact lives in this function, not
+    // in the invariant. A future batch-push (or a cap lowered at runtime)
+    // would leave history silently one-or-more over HISTORY_LIMIT forever,
+    // since nothing after this point ever re-checks. `while` costs nothing
+    // today and stops correctness depending on a fact this loop cannot see.
+    while (history.length > HISTORY_LIMIT) {
+      history.shift();
+      at--;
+    }
     return true;
   }
 
@@ -882,9 +909,44 @@ function diffMembers(ctx, path, was, now, skipKey, edits) {
     const r = diffValue(ctx, path.concat([key]), was[key], now[key], edits);
     if (r.ok !== true) return r;
   }
+  // v3.6.0 Task 13 fix round 1 (Critical 1): every new key on THIS object
+  // goes into ONE edit, not one `insert` per key.
+  //
+  // `toPatch()` (this file, `store.toPatch`) always diffs the WHOLE session
+  // against the document as it stood when the editor opened — not
+  // incrementally, gesture by gesture — so two new sibling fields set at any
+  // two points in the same session (the Lane panel's period then phase; two
+  // of the six ruler fields) both show up as "new" here in the SAME call.
+  // The old code pushed one independent `{op: 'insert', path: […key]}` per
+  // key, and `wave-codec.js`'s resolver turns EVERY one of those into a
+  // patch anchored at the object's same last EXISTING member — because
+  // neither edit can see the other, both compute the identical insertion
+  // point, and `patchSource`'s "two edits land at the same place" guard
+  // (which exists for exactly this ambiguity) refused the batch. Every
+  // session that set two new fields on one object failed, always, not
+  // intermittently.
+  //
+  // Folding them into one `insert-members` edit — resolved by
+  // `wave-codec.js`'s `resolveInsertMembers` — gives the object ONE new
+  // anchor for however many new keys it picked up this session. Key order
+  // inside it is `Object.keys(now)` order (insertion order for a plain
+  // object, so it matches the order the fields were actually set in); it
+  // does not have to be THE order, because `toPatch()`'s own read-back
+  // check just below in this file verifies the combined edit reproduces the
+  // exact document regardless of key order (`sameValue` does not compare
+  // key order either).
+  const newKeys = [];
   for (const key of Object.keys(now)) {
     if (key === skipKey) continue;
-    if (!has(was, key)) edits.push({ op: 'insert', path: path.concat([key]), value: now[key] });
+    if (!has(was, key)) newKeys.push(key);
+  }
+  if (newKeys.length === 1) {
+    edits.push({ op: 'insert', path: path.concat([newKeys[0]]), value: now[newKeys[0]] });
+  } else if (newKeys.length > 1) {
+    edits.push({
+      op: 'insert-members', path: path,
+      entries: newKeys.map(function (key) { return [key, now[key]]; }),
+    });
   }
   return OK;
 }