isomorphic-jj 1.9.2 → 1.11.0

package/dist/index.cjs

@@ -3283,11 +3283,39 @@ class RevsetEngine {
       return parentKeys.every((k) => parentSnapshot[k] === ownSnapshot[k]);
     };
 
+    // issue #43(2): the original #37(b) rule above (unreachable + isEmpty +
+    // undescribed) only hides an orphan while it still happens to have
+    // zero file diff versus its CURRENT parent. Two real shapes slip past
+    // that once undo()/operations.restore() are involved, because both are
+    // purely internal rewrite/undo artifacts that were never "empty" in
+    // any way a user would recognize — they simply never held real user
+    // content of their own, and a later revert of something else can make
+    // isEmpty() disagree even though nothing about THIS change changed:
+    //
+    //   1. squash() creates a fresh empty `@` on top of `dest` when
+    //      squashing the working copy. If that squash is later undone,
+    //      the fresh `@` becomes unreferenced — but if `dest` itself gets
+    //      reverted back to its pre-squash content by the SAME undo,
+    //      isEmpty() now compares the orphan's (frozen, post-squash)
+    //      fileSnapshot against dest's (reverted, pre-squash) one and
+    //      finds a mismatch, even though the orphan is exactly as
+    //      "discardable" as it was the instant it was created.
+    //   2. new() creates a fresh empty change on top of the previous `@`.
+    //      If something writes into it (write()/snapshot()) before an
+    //      undo() unwinds back past the new(), the orphan is left with
+    //      real file content that no longer matches its parent, even
+    //      though the user never gave it a real description.
+    //
+    // Changes created by squash()/new() are tagged `autoCreated: true` at
+    // creation (see squash()/new() in repository.js) specifically so this
+    // filter can hide them on that basis alone — still gated on being
+    // unreachable and undescribed, so a change the user actually described
+    // (or that's still live) is never hidden by this rule.
     const hidden = new Set();
     for (const change of allChanges) {
       if (
         !reachable.has(change.changeId) &&
-        isEmpty(change) &&
+        (isEmpty(change) || change.autoCreated) &&
         UNDESCRIBED.has(change.description)
       ) {
         hidden.add(change.changeId);
@@ -8087,6 +8115,38 @@ async function createJJ(options) {
     // an earlier, unrelated merge(). Fixed as part of issue #29.)
   };
 
+  /**
+   * Compute the full current set of "head" changeIds — every non-abandoned
+   * change with no non-abandoned child. Used to record an accurate
+   * `view.heads` when an operation runs (issue #43).
+   *
+   * Before this helper existed, several oplog-recording call sites
+   * (squash(), rebase()/moveChange(), abandon()) hand-wrote a single-
+   * element or empty `heads` array covering only the changeId(s) that
+   * specific call happened to touch. That silently dropped any OTHER
+   * live head the operation didn't itself touch (e.g. a sibling branch
+   * left untouched by an abandon()/squash() of a different branch — "two
+   * sibling changes report only one head between them"), and squash() in
+   * particular recorded the OLD destination changeId instead of the fresh
+   * working-copy change it creates on top of it when squashing @ ("after
+   * a squash [heads] points at the parent instead of the new tip").
+   *
+   * @returns {Promise<string[]>}
+   */
+  const computeCurrentHeads = async () => {
+    await graph.load();
+    const allChanges = await graph.getAllChanges();
+    const nonAbandoned = allChanges.filter((/** @type {any} */ c) => !c.abandoned);
+    const nonAbandonedIds = new Set(nonAbandoned.map((/** @type {any} */ c) => c.changeId));
+    const heads = [];
+    for (const change of nonAbandoned) {
+      const children = graph.getChildren(change.changeId);
+      const hasLiveChild = children.some((/** @type {string} */ id) => nonAbandonedIds.has(id));
+      if (!hasLiveChild) heads.push(change.changeId);
+    }
+    return heads;
+  };
+
   /**
    * Re-parent every child of `changeId` onto `newParents` instead — used
    * when a change is being elided from the graph (abandon(), issue #30;
@@ -8118,6 +8178,18 @@ async function createJJ(options) {
     }
   };
 
+  // NOTE (issue #43(5), punted — see PR description): an earlier version of
+  // this file added a `rebaseDescendantsOntoUpdatedParent()` helper, called
+  // from edit(), to propagate an edited ancestor's content onto descendants
+  // automatically. It was reverted: it directly conflicts with absorb()'s
+  // job (folding a working-copy edit back into an ancestor it actually
+  // belongs to) — with the auto-rebase in place, edit()+write()+edit()-away
+  // already changes the descendant before absorb() ever runs, so absorb()
+  // finds nothing left to do (see tests/integration/absorb.test.js
+  // "should work after edit()", which regressed against this). Fixing
+  // #43(5) properly needs to account for that interaction rather than
+  // duplicate it; left for a follow-up.
+
   /**
    * Determine which operation a fresh undo() call should revert, matching
    * real jj's progressive-undo semantics (`jj-undo(1)`: "If used once after
@@ -8196,8 +8268,26 @@ async function createJJ(options) {
         const wcId = workingCopy.getCurrentChangeId();
         const change = await graph.getChange(wcId);
         if (change) {
+          const oldFileSnapshot = change.fileSnapshot ? structuredClone(change.fileSnapshot) : {};
           change.fileSnapshot = await snapshotFilesystem();
           await graph.updateChange(change);
+
+          // Issue #45: if the working-copy change isn't a leaf (e.g. we
+          // edit()'d into an older change earlier in the session), its
+          // descendants' fileSnapshot still reflects the OLD content and
+          // needs to be rebased onto the content just committed above —
+          // matching real jj's automatic rebase-on-edit. edit() itself is a
+          // pure checkout and never mutates content, so this is the actual
+          // moment content changes and the right place to propagate. `jj`
+          // (not `this`) is used here because this function is a plain
+          // closure, not a method of the `jj` object — but `jj` is a const
+          // in the same enclosing scope and this function only ever runs
+          // after `jj` is fully constructed, so the self-reference is safe
+          // (same pattern used elsewhere in this file, e.g. `jj.new(...)`).
+          const descendants = await jj._findDescendants(wcId, null);
+          if (descendants.length > 0) {
+            await jj._rebuildDescendants(wcId, null, oldFileSnapshot);
+          }
         }
       } catch {
         // Best-effort content refresh; tracking state is already updated.
@@ -8553,6 +8643,17 @@ async function createJJ(options) {
         });
       }
 
+      await workingCopy.load();
+
+      // Capture disk state right before this write mutates it, and record
+      // an operation for it (issue #43(1)): write() previously recorded NO
+      // operation at all, so an edit typed into a change's working copy
+      // could never be rewound by undo()/operations.restore() regardless
+      // of which op you targeted — the change kept its post-edit content
+      // forever. Mirrors the "snapshot before, record after" pattern every
+      // other mutator in this file uses (see describe(), moveChange()).
+      const fileSnapshotBefore = await snapshotFilesystem();
+
       const fullPath = `${dir}/${args.path}`;
 
       // Ensure directory exists
@@ -8568,7 +8669,6 @@ async function createJJ(options) {
       await fs.promises.writeFile(fullPath, data, 'utf8');
 
       // Track the file in working copy
-      await workingCopy.load();
       const stats = await fs.promises.stat(fullPath);
       await workingCopy.trackFile(args.path, {
         mtime: stats.mtime,
@@ -8576,6 +8676,20 @@ async function createJJ(options) {
         mode: stats.mode,
       });
 
+      await oplog.recordOperation({
+        timestamp: new Date().toISOString(),
+        user: await getUserOplogInfo(),
+        description: `write ${args.path}`,
+        parents: [],
+        view: {
+          bookmarks: {},
+          remoteBookmarks: {},
+          heads: await computeCurrentHeads(),
+          workingCopy: workingCopy.getCurrentChangeId(),
+          fileSnapshot: fileSnapshotBefore, // Store filesystem state from before this write
+        },
+      });
+
       // Return useful information about the written file
       return {
         path: args.path,
@@ -9004,6 +9118,15 @@ async function createJJ(options) {
     async moveChange(args) {
       await graph.load();
 
+      // Capture disk state right before this rebase mutates anything, so
+      // undo()/redo()/operations.restore() can rewind past it — see issue
+      // #43(1): rebase()/moveChange() previously recorded no "files
+      // before" snapshot at all, so restoring to a point right before a
+      // rebase ran had no on-disk state to fall back to and would instead
+      // pick up whatever a LATER operation happened to record (the wrong
+      // point in time).
+      const fileSnapshotBefore = await snapshotFilesystem();
+
       // Support multiple parameter names for flexibility
       const changeId = args.changeId || args.from || args.source;
       const newParent = args.newParent || args.to || args.destination;
@@ -9116,6 +9239,32 @@ async function createJJ(options) {
         await conflicts.addConflict(conflict);
       }
 
+      // Materialize real conflict-marker text into the moved change's file
+      // content — issue #43(3): rebase()/moveChange() used to record the
+      // conflict correctly as DATA (via conflicts.addConflict() above) but
+      // left the file's content exactly as it was pre-rebase ("ours"),
+      // never writing marker text into change.fileSnapshot or, when this
+      // change is the checked-out working copy, onto disk. Reuses
+      // conflicts.markers()'s own marker-formatting logic (the same format
+      // jj.conflicts.markers() already returns) instead of re-deriving
+      // marker text a second way.
+      if (detectedConflicts.length > 0) {
+        change.fileSnapshot = { ...(change.fileSnapshot || {}) };
+        const isCheckedOut = changeId === workingCopy.getCurrentChangeId();
+        for (const conflict of detectedConflicts) {
+          const markerText = await jj.conflicts.markers({ conflictId: conflict.conflictId });
+          change.fileSnapshot[conflict.path] = markerText;
+          if (isCheckedOut) {
+            const fullPath = join(dir, conflict.path);
+            const pathParts = conflict.path.split('/');
+            if (pathParts.length > 1) {
+              await mkdirp(fs, join(dir, pathParts.slice(0, -1).join('/')));
+            }
+            await fs.promises.writeFile(fullPath, markerText, 'utf8');
+          }
+        }
+      }
+
       // Update parent
       change.parents = [newParent];
       await graph.updateChange(change);
@@ -9131,8 +9280,9 @@ async function createJJ(options) {
         view: {
           bookmarks: {},
           remoteBookmarks: {},
-          heads: [],
+          heads: await computeCurrentHeads(),
           workingCopy: workingCopy.getCurrentChangeId(),
+          fileSnapshot: fileSnapshotBefore,
         },
       });
 
@@ -9587,6 +9737,16 @@ async function createJJ(options) {
         description: args.message || '(no description)',
         timestamp: new Date().toISOString(),
         fileSnapshot: initialSnapshot, // Initialize with parent's snapshot
+        // Issue #43(2): marks this as an internal, synthetic artifact
+        // rather than something the user actually created, so the revset
+        // engine's orphan-visibility filter (_computeHiddenOrphans) can
+        // still hide it after it's un-referenced by a later undo()/
+        // operations.restore(), even if some out-of-band mutation (e.g.
+        // write()+snapshot() before the undo unwinds this far) has since
+        // made it look "non-empty" relative to its parent. A real
+        // description (args.message, or a later describe()) still makes
+        // it visible regardless, via the UNDESCRIBED check.
+        autoCreated: true,
       };
 
       // Dispatch change:creating event (preventable)
@@ -9707,17 +9867,63 @@ async function createJJ(options) {
       await graph.load();
       await workingCopy.load();
       const result = await workingCopy.snapshot();
+
+      // Disk content itself is not mutated by this call (it's a read,
+      // not a write) — the same value is therefore valid both as the
+      // refreshed change.fileSnapshot AND as the recorded operation's
+      // `view.fileSnapshot` "before" value (nothing on disk changes
+      // between the two).
+      const wcId = workingCopy.getCurrentChangeId();
+      const currentDiskSnapshot = await snapshotFilesystem();
+
       // Refresh the working-copy change's content snapshot from disk.
+      /** @type {Record<string, any>} */
+      const changeSnapshot = {};
       try {
-        const wcId = workingCopy.getCurrentChangeId();
         const change = await graph.getChange(wcId);
         if (change) {
-          change.fileSnapshot = await snapshotFilesystem();
+          // Snapshot BEFORE mutating so undo()/redo()/operations.restore()
+          // can reverse this content refresh — see issue #43(1):
+          // snapshot() previously mutated `change.fileSnapshot` in place
+          // with no "before" capture and recorded no operation at all, so
+          // computeGraphReversal() had nothing to find for this changeId
+          // if a restore()/undo() landed between an out-of-band edit and
+          // the next real command.
+          changeSnapshot[wcId] = structuredClone(change);
+          change.fileSnapshot = currentDiskSnapshot;
           await graph.updateChange(change);
+
+          // Issue #45: if the working-copy change isn't a leaf (e.g. we
+          // edit()'d into an older change earlier in the session), its
+          // descendants' fileSnapshot still reflects the OLD content and
+          // needs to be rebased onto the content just committed above —
+          // matching real jj's automatic rebase-on-edit. edit() itself is a
+          // pure checkout and never mutates content, so this is the actual
+          // moment content changes and the right place to propagate.
+          const descendants = await this._findDescendants(wcId, null);
+          if (descendants.length > 0) {
+            await this._rebuildDescendants(wcId, null, changeSnapshot[wcId].fileSnapshot);
+          }
         }
       } catch {
-        // Best-effort content refresh.
+        // Best-effort content refresh (including descendant propagation).
       }
+
+      await oplog.recordOperation({
+        timestamp: new Date().toISOString(),
+        user: await getUserOplogInfo(),
+        description: 'snapshot working copy',
+        parents: [],
+        changeSnapshot,
+        view: {
+          bookmarks: {},
+          remoteBookmarks: {},
+          heads: await computeCurrentHeads(),
+          workingCopy: wcId,
+          fileSnapshot: currentDiskSnapshot,
+        },
+      });
+
       return result;
     },
 
@@ -10051,6 +10257,22 @@ async function createJJ(options) {
             changeSnapshot[previousChangeId] = structuredClone(previousChange);
             previousChange.fileSnapshot = currentSnapshot;
             await graph.updateChange(previousChange);
+
+            // Issue #45: this is the OTHER place a checked-out change's
+            // content gets committed to the graph — not through snapshot()/
+            // autoSnapshotWorkingCopy() at all, but here, inline, when
+            // edit() leaves a change it was checked out on. If that change
+            // isn't a leaf (we'd edit()'d into an ancestor), its descendants
+            // still have the OLD content and need the same rebase-on-edit
+            // treatment applied at the other two commit sites.
+            const descendants = await this._findDescendants(previousChangeId, null);
+            if (descendants.length > 0) {
+              await this._rebuildDescendants(
+                previousChangeId,
+                null,
+                changeSnapshot[previousChangeId].fileSnapshot
+              );
+            }
           }
         }
       }
@@ -10181,8 +10403,20 @@ async function createJJ(options) {
         const current = await graph.getChange(changeId);
         if (current) redoChangeSnapshot[changeId] = current;
       }
+      // Capture disk state right before this undo() runs. Used both as
+      // `redoFileSnapshot` (for a later redo() — only meaningful when this
+      // reversal actually touches files) AND, unconditionally, as THIS
+      // undo operation's own `view.fileSnapshot` "before" value below —
+      // see issue #43(1): undo()/redo()/operations.restore() used to
+      // record `view: landingView` verbatim, i.e. reusing the LANDING
+      // operation's own recorded fileSnapshot (disk state before THAT op
+      // ran) instead of disk state before THIS undo ran. A later
+      // restore()/undo() scanning forward past this one would then pick
+      // up that stale, wrong snapshot instead of what was actually on disk
+      // right before this undo executed.
+      const diskSnapshotBeforeThisOp = await snapshotFilesystem();
       const redoFileSnapshot =
-        reversal.fileSnapshot !== undefined ? await snapshotFilesystem() : undefined;
+        reversal.fileSnapshot !== undefined ? diskSnapshotBeforeThisOp : undefined;
       let redoConflictsSnapshot;
       if (reversal.conflictsSnapshot !== undefined) {
         await conflicts.load();
@@ -10223,7 +10457,7 @@ async function createJJ(options) {
         redoFileSnapshot,
         redoConflictsSnapshot,
         parents: [],
-        view: landingView,
+        view: { ...landingView, fileSnapshot: diskSnapshotBeforeThisOp },
       });
 
       const restoredFileCount =
@@ -10317,6 +10551,15 @@ async function createJJ(options) {
           await baseGraph.updateChange(snapshot);
         }
       }
+
+      // Capture disk state right before THIS redo() mutates it — see issue
+      // #43(1)/the matching fix in undo(): `view: redoneView` below reuses
+      // the ORIGINAL (re-applied) operation's own recorded pointers, but
+      // its `fileSnapshot` sub-field must reflect disk state before THIS
+      // redo ran, not before that original operation ran, or a later
+      // restore()/undo() scanning forward past this redo would pick up a
+      // stale, wrong snapshot.
+      const diskSnapshotBeforeThisOp = await snapshotFilesystem();
       if (undoOp.redoFileSnapshot !== undefined) {
         await syncWorkingCopyFiles(undoOp.redoFileSnapshot);
       }
@@ -10337,7 +10580,7 @@ async function createJJ(options) {
         redoOf: undoOp.id,
         changeSnapshot: undoChangeSnapshot,
         parents: [],
-        view: redoneView,
+        view: { ...redoneView, fileSnapshot: diskSnapshotBeforeThisOp },
       });
 
       const restoredFileCount =
@@ -10643,6 +10886,17 @@ async function createJJ(options) {
           if (current) changeSnapshot[changeId] = current;
         }
 
+        // Capture disk state right before THIS restore() mutates it — see
+        // issue #43(1)/the matching fix in undo()/redo(): recording
+        // `view: targetOp.view` verbatim reused targetOp's OWN recorded
+        // `fileSnapshot` (disk state before targetOp ran), not disk state
+        // before THIS restore ran. A later restore()/undo() scanning
+        // forward past this one would then pick up that stale, wrong
+        // snapshot instead of what was actually on disk right before this
+        // restore executed — this is exactly the "forward restore to
+        // 'edit tip' lost style.css" repro.
+        const diskSnapshotBeforeThisOp = await snapshotFilesystem();
+
         await applyGraphReversal(reversal);
 
         // Record this restoration as a new operation
@@ -10652,7 +10906,7 @@ async function createJJ(options) {
           description: `restore to operation ${args.operation}`,
           parents: [],
           changeSnapshot,
-          view: targetOp.view,
+          view: { ...targetOp.view, fileSnapshot: diskSnapshotBeforeThisOp },
         });
 
         return {
@@ -10888,6 +11142,15 @@ async function createJJ(options) {
       await workingCopy.load();
       await userConfig.load();
 
+      // Capture disk state right before this squash mutates anything, so
+      // undo()/redo()/operations.restore() can rewind past it — see issue
+      // #43(1): squash() previously recorded no "files before" snapshot at
+      // all, so restoring to a point right before a squash ran had no
+      // recorded on-disk state and would fall through to whatever a LATER
+      // operation happened to record instead (the repro: a forward
+      // restore to "edit tip" lost `style.css`).
+      const fileSnapshotBefore = await snapshotFilesystem();
+
       // Support 'into' as alias for 'dest' (matches JJ CLI)
       const dest = args.into || args.dest;
 
@@ -11019,6 +11282,18 @@ async function createJJ(options) {
           // every on-disk file as untracked/new until something re-wrote
           // it and triggered a fresh auto-snapshot.
           fileSnapshot: { ...destChange.fileSnapshot },
+          // Marks this as an internal, synthetic artifact rather than
+          // something the user actually created — issue #43(2): if this
+          // squash is later undone, this change becomes unreferenced, and
+          // by then `destChange` may have been reverted to pre-squash
+          // content, making this change look "non-empty" relative to its
+          // (now-reverted) parent even though it never held any real user
+          // content of its own. The revset engine's orphan-visibility
+          // filter (_computeHiddenOrphans) treats `autoCreated` as
+          // sufficient on its own (given it's also unreferenced and
+          // undescribed) rather than re-diffing against a parent that may
+          // no longer resemble what this change was actually created from.
+          autoCreated: true,
         };
 
         await graph.addChange(newChange); // Middleware will sync to Git
@@ -11041,8 +11316,18 @@ async function createJJ(options) {
         view: {
           bookmarks: {},
           remoteBookmarks: {},
-          heads: [destChangeId],
+          // issue #43(1): this used to hard-code `[destChangeId]` — wrong
+          // whenever squash() created a fresh working-copy change on top
+          // of dest (the real new tip was `newWorkingCopyId`, not
+          // `destChangeId` itself), and incomplete whenever a sibling head
+          // elsewhere in the graph existed and wasn't touched by this
+          // squash at all ("two sibling changes report only one head
+          // between them"). computeCurrentHeads() reflects the WHOLE
+          // repo's actual head set after this squash, not just the
+          // changeId(s) this call happened to touch.
+          heads: await computeCurrentHeads(),
           workingCopy: newWorkingCopyId,
+          fileSnapshot: fileSnapshotBefore,
         },
       });
 
@@ -11114,6 +11399,12 @@ async function createJJ(options) {
       // abandoning any OTHER change must leave @ exactly where it was.
       const wasWorkingCopy = changeId === workingCopy.getCurrentChangeId();
 
+      // Capture disk state right before this abandon mutates anything, so
+      // undo()/redo()/operations.restore() can rewind past it — see issue
+      // #43(1): abandon() previously recorded no "files before" snapshot
+      // at all.
+      const fileSnapshotBefore = await snapshotFilesystem();
+
       // Dispatch change:abandoning event (preventable)
       await dispatchEventAsync(jj, 'change:abandoning', {
         operation: 'abandon',
@@ -11148,8 +11439,16 @@ async function createJJ(options) {
         view: {
           bookmarks: {},
           remoteBookmarks: {},
-          heads: [],
+          // issue #43(1): this used to hard-code `[]`, dropping every live
+          // head from the recorded operation (including any untouched
+          // sibling branch — "two sibling changes report only one head
+          // between them"). computeCurrentHeads() reflects the actual
+          // repo-wide head set right after this abandon (and its
+          // reparenting) ran, before the compensating jj.new() below (if
+          // any) records its own separate operation.
+          heads: await computeCurrentHeads(),
           workingCopy: workingCopy.getCurrentChangeId(),
+          fileSnapshot: fileSnapshotBefore,
         },
       });
 
@@ -12212,9 +12511,27 @@ async function createJJ(options) {
      * @private
      * @param {string} ancestorId - The ancestor change that was updated
      * @param {string} stopAtChangeId - Don't rebuild this change (usually working copy)
-     * @deprecated Use _rebuildDescendantsWithStates instead
+     * @param {Record<string, string>} [originalAncestorSnapshot] - The
+     *   ancestor's fileSnapshot as it was BEFORE the caller's own
+     *   `graph.updateChange()` for `ancestorId` ran. Callers must invoke this
+     *   function AFTER committing the ancestor's new content (that's the
+     *   natural order — the ancestor's content must exist before its
+     *   descendants can be rebased onto it), but that means a live
+     *   `graph.getChange(ancestorId).fileSnapshot` read inside this function
+     *   would already see the NEW content. For the ancestor's DIRECT
+     *   children, this function compares each descendant's stale content
+     *   against "the original parent state" to figure out which lines are
+     *   the descendant's own edits; if that "original" state were actually
+     *   the already-new ancestor content, every line of the stale
+     *   descendant would look like a deliberate edit (stale != new) and get
+     *   preserved verbatim — silently reproducing the staleness instead of
+     *   fixing it. Passing the pre-mutation snapshot here lets the ancestor's
+     *   direct children be diffed against the correct baseline. Deeper
+     *   descendants are unaffected (their own immediate parent hasn't been
+     *   mutated yet when this function reads it, so the live read is
+     *   correct for them). Optional for backward compatibility.
      */
-    async _rebuildDescendants(ancestorId, stopAtChangeId) {
+    async _rebuildDescendants(ancestorId, stopAtChangeId, originalAncestorSnapshot) {
       // Find all descendants of ancestorId
       const allChanges = graph.getAll();
 
@@ -12222,11 +12539,16 @@ async function createJJ(options) {
       const originalParentStates = new Map();
       for (const change of allChanges) {
         if (change.parents && change.parents.length > 0) {
-          const parent = await graph.getChange(change.parents[0]);
+          const parentId = change.parents[0];
+          const parent = await graph.getChange(parentId);
           if (parent) {
+            const parentSnapshot =
+              parentId === ancestorId && originalAncestorSnapshot !== undefined
+                ? JSON.parse(JSON.stringify(originalAncestorSnapshot))
+                : JSON.parse(JSON.stringify(parent.fileSnapshot || {}));
             originalParentStates.set(change.changeId, {
-              parentId: change.parents[0],
-              parentSnapshot: JSON.parse(JSON.stringify(parent.fileSnapshot || {})),
+              parentId,
+              parentSnapshot,
             });
           }
         }
@@ -12296,30 +12618,78 @@ async function createJJ(options) {
         const allFiles = new Set([
           ...Object.keys(descendant.fileSnapshot || {}),
           ...Object.keys(parent.fileSnapshot || {}),
+          ...Object.keys(originalParentSnapshot || {}),
         ]);
 
         for (const filePath of allFiles) {
+          const descendantExists = Object.prototype.hasOwnProperty.call(
+            descendant.fileSnapshot || {},
+            filePath
+          );
+          const originalParentExists = Object.prototype.hasOwnProperty.call(
+            originalParentSnapshot || {},
+            filePath
+          );
+          const updatedParentExists = Object.prototype.hasOwnProperty.call(
+            parent.fileSnapshot || {},
+            filePath
+          );
+
+          // A file's EXISTENCE is a separate question from its content —
+          // coercing "doesn't exist" to '' before diffing (the previous
+          // version of this loop did) means a descendant that deliberately
+          // deleted a file the old parent had gets that file resurrected as
+          // an empty string once rebuilt, instead of staying deleted. This
+          // was a real, latent bug: nothing called this function at all
+          // until issue #45 gave it a real caller, so it was never
+          // exercised against a deletion before.
+          if (
+            descendantExists === originalParentExists &&
+            (!descendantExists ||
+              descendant.fileSnapshot[filePath] === originalParentSnapshot[filePath])
+          ) {
+            // Descendant never touched this file relative to its old
+            // parent (same existence + content as before) -- just follow
+            // whatever the updated parent did with it (added, removed, or
+            // changed since the descendant branched off).
+            if (updatedParentExists) newSnapshot[filePath] = parent.fileSnapshot[filePath];
+            continue; // else: stays deleted -- don't add it to newSnapshot
+          }
+
+          if (originalParentExists && !descendantExists) {
+            // Descendant deliberately deleted a file the old parent had —
+            // preserve that deletion rather than resurrecting it.
+            continue;
+          }
+
+          if (!originalParentExists && descendantExists && !updatedParentExists) {
+            // Descendant added a file that didn't exist on either side of
+            // the parent at all -- keep the descendant's own addition.
+            newSnapshot[filePath] = descendant.fileSnapshot[filePath];
+            continue;
+          }
+
+          // Both the descendant and the parent have real content for this
+          // file (whether or not it existed originally) -- do the actual
+          // line-level replay: find which lines the descendant changed
+          // from the OLD parent, then reapply just those lines onto the
+          // NEW parent's content.
           const descendantContent = descendant.fileSnapshot[filePath] || '';
           const originalParentContent = originalParentSnapshot[filePath] || '';
           const updatedParentContent = parent.fileSnapshot[filePath] || '';
 
-          // Find which lines descendant modified from original parent
           const descendantLines = descendantContent.split('\n');
           const originalParentLines = originalParentContent.split('\n');
           const updatedParentLines = updatedParentContent.split('\n');
 
-          // Rebuild file: start with updated parent, apply descendant's modifications
           const resultLines = [...updatedParentLines];
 
-          // Find lines that descendant modified
           for (let i = 0; i < Math.max(descendantLines.length, originalParentLines.length); i++) {
             const descendantLine = i < descendantLines.length ? descendantLines[i] : undefined;
             const originalParentLine =
               i < originalParentLines.length ? originalParentLines[i] : undefined;
 
-            // If descendant modified this line from original parent, apply that modification
             if (descendantLine !== originalParentLine) {
-              // Extend resultLines if needed
               while (resultLines.length <= i) {
                 resultLines.push('');
               }
@@ -13411,6 +13781,32 @@ async function createJJ(options) {
           throw new JJError('CONFLICT_NOT_FOUND', `Conflict ${args.conflictId} not found`);
         }
 
+        // Snapshot BEFORE mutating so undo()/redo()/operations.restore()
+        // can reverse this resolution — issue #43(4): conflicts.resolve()
+        // previously recorded no operation at all, so resolving a conflict
+        // could never be undone: no changeSnapshot of the working-copy
+        // change's content, no conflictsSnapshot of the pre-resolve
+        // conflict state, and no fileSnapshot of the on-disk content
+        // before the resolved content was written.
+        await graph.load();
+        await workingCopy.load();
+        // structuredClone matters here (unlike the read-only conflictsSnapshot
+        // capture in moveChange()/merge()): resolveConflict() below mutates
+        // the SAME conflict object in place (`conflict.resolved = true`),
+        // and Object.fromEntries() on the live Map would otherwise leave
+        // this "before" snapshot holding a reference to that very object —
+        // corrupting it into already showing `resolved: true` by the time
+        // it's recorded.
+        const conflictsSnapshotBefore = structuredClone({
+          conflicts: Object.fromEntries(conflicts.conflicts),
+          fileConflicts: Object.fromEntries(conflicts.fileConflicts),
+        });
+        const fileSnapshotBefore = await snapshotFilesystem();
+        const wcId = workingCopy.getCurrentChangeId();
+        const wcChange = await graph.getChange(wcId);
+        /** @type {Record<string, any>} */
+        const changeSnapshot = wcChange ? { [wcId]: structuredClone(wcChange) } : {};
+
         let resolvedContent;
 
         // v0.5: Support different resolution methods
@@ -13454,6 +13850,36 @@ async function createJJ(options) {
         await conflicts.resolveConflict(args.conflictId, 'manual');
         await conflicts.save();
 
+        // Refresh the working-copy change's own fileSnapshot to match the
+        // resolved on-disk content (conflicted files always live under
+        // the checked-out working copy — see the writeFile above), so
+        // undo()/restore() has an accurate "after" state to compare
+        // against, and log()/read() see the resolution immediately rather
+        // than waiting for the next auto-snapshot.
+        if (wcChange) {
+          wcChange.fileSnapshot = {
+            ...(wcChange.fileSnapshot || {}),
+            [conflict.path]: resolvedContent,
+          };
+          await graph.updateChange(wcChange);
+        }
+
+        await oplog.recordOperation({
+          timestamp: new Date().toISOString(),
+          user: await getUserOplogInfo(),
+          description: `resolve conflict ${args.conflictId} (${conflict.path})`,
+          parents: [],
+          changeSnapshot,
+          conflictsSnapshot: conflictsSnapshotBefore,
+          view: {
+            bookmarks: {},
+            remoteBookmarks: {},
+            heads: await computeCurrentHeads(),
+            workingCopy: wcId,
+            fileSnapshot: fileSnapshotBefore,
+          },
+        });
+
         return { resolved: true };
       },