isomorphic-jj 1.9.0 → 1.10.0

package/dist/index.cjs

@@ -991,6 +991,44 @@ class ChangeGraph {
  */
 
 
+/**
+ * Normalize an mtime value to a millisecond epoch number so two stat()
+ * results (or a stat() result and a stored value) can be compared by VALUE
+ * instead of by object identity (see issue #41).
+ *
+ * `fs.promises.stat()` returns a fresh `Date` instance on every call, so two
+ * separate stats of the same unchanged file are never `===`/`!==`-equal even
+ * when the underlying timestamp is identical. Additionally, once a tracked
+ * mtime has been through a `JSON.stringify`/`JSON.parse` round-trip (Storage
+ * persists working-copy state as JSON), a `Date` becomes an ISO string, not a
+ * `Date` — so the stored side of the comparison may be a `Date`, a plain
+ * epoch-ms number (this module now stores numbers going forward), or an ISO
+ * string (older/reloaded-from-disk state). This normalizes all three to a
+ * comparable number.
+ *
+ * Deliberately duck-types the Date case (`typeof value.getTime ===
+ * 'function'`) instead of `value instanceof Date`: Node's built-in `fs`
+ * module constructs `Stats.mtime` using its own realm's `Date`, which is not
+ * always the same `Date` constructor as this module's under test runners
+ * that sandbox each test file in its own VM context (observed under Jest
+ * with `--experimental-vm-modules`) — there, a real `Date` instance from
+ * `fs.promises.stat()` fails `instanceof Date` here even though it's a
+ * genuine Date. Duck-typing survives that realm mismatch.
+ *
+ * @param {Date|number|string|undefined} value
+ * @returns {number}
+ */
+function mtimeMs(value) {
+  if (value === null || value === undefined) return NaN;
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') return new Date(value).getTime();
+  // Per the type contract above, anything left is Date-like -- duck-typed
+  // (see the comment above) rather than `instanceof Date`, so no runtime
+  // check is needed here either; a value outside this contract is a caller
+  // bug, not something to silently coerce.
+  return /** @type {any} */ (value).getTime();
+}
+
 class WorkingCopy {
   /**
    * @param {Storage} storage - Storage manager instance
@@ -1162,8 +1200,10 @@ class WorkingCopy {
       try {
         const stats = await this.fs.promises.stat(fullPath);
 
-        // Fast path: check mtime and size
-        if (stats.mtime !== tracked.mtime || stats.size !== tracked.size) {
+        // Fast path: check mtime and size. Compare by VALUE (see mtimeMs
+        // above) — comparing the raw stat()/stored values with !== is
+        // always "different" even when nothing changed (issue #41).
+        if (mtimeMs(stats.mtime) !== mtimeMs(tracked.mtime) || stats.size !== tracked.size) {
           modified.push(path);
         }
       } catch (error) {
@@ -1274,12 +1314,19 @@ class WorkingCopy {
       }
 
       const prev = this.state.fileStates[rel];
-      const next = { mtime: stats.mtime, size: stats.size, mode: stats.mode };
+      // Store mtime as a plain epoch-ms number (not the raw stat() value):
+      // numbers round-trip through JSON exactly, so state reloaded from disk
+      // later compares identically to state still cached in-memory. Goes
+      // through mtimeMs() rather than assuming `.getTime()` exists directly —
+      // some fs implementations (e.g. the in-memory mock used in tests)
+      // return mtime as a plain epoch-ms number already, not a Date (see
+      // mtimeMs above and issue #41).
+      const next = { mtime: mtimeMs(stats.mtime), size: stats.size, mode: stats.mode };
 
       if (!prev) {
         this.state.fileStates[rel] = next;
         added.push(rel);
-      } else if (prev.mtime !== stats.mtime || prev.size !== stats.size) {
+      } else if (mtimeMs(stats.mtime) !== mtimeMs(prev.mtime) || prev.size !== stats.size) {
         this.state.fileStates[rel] = next;
         modified.push(rel);
       }
@@ -2668,9 +2715,12 @@ class RevsetEngine {
     const unquote = (/** @type {string} */ s) => s.trim().replace(/^['"]|['"]$/g, '');
 
     switch (name) {
-      case 'all':
+      case 'all': {
         await this.graph.load();
-        return this.graph.getAll().map((c) => c.changeId);
+        const allChanges = this.graph.getAll();
+        const hidden = await this._computeHiddenOrphans(allChanges);
+        return allChanges.filter((c) => !hidden.has(c.changeId)).map((c) => c.changeId);
+      }
 
       // `builtin_log()` (jj v0.44) is the revset the built-in `jj log` uses
       // when no user override is configured. isomorphic-jj's `log()` already
@@ -2678,9 +2728,12 @@ class RevsetEngine {
       // `builtin_log()` is a pure alias for that same default — this lets
       // callers compose it (e.g. `builtin_log() & mine()`) instead of
       // duplicating `all()`.
-      case 'builtin_log':
+      case 'builtin_log': {
         await this.graph.load();
-        return this.graph.getAll().map((c) => c.changeId);
+        const allChanges = this.graph.getAll();
+        const hidden = await this._computeHiddenOrphans(allChanges);
+        return allChanges.filter((c) => !hidden.has(c.changeId)).map((c) => c.changeId);
+      }
 
       case 'none':
         return [];
@@ -3141,6 +3194,136 @@ class RevsetEngine {
     return ancestors;
   }
 
+  /**
+   * Change IDs that `all()`/`builtin_log()` (and therefore the default
+   * `jj.log()`) should exclude — issue #37(b).
+   *
+   * undo()/redo()/operations.restore() deliberately don't delete a change
+   * record for a `new()`/`squash()` that gets reverted — they only un-ref
+   * it (restore the working-copy pointer/heads that made it reachable),
+   * matching real jj where an unreachable change stays resolvable by its
+   * change id (hidden, not gone) until explicitly gc'd — see
+   * computeGraphReversal's doc comment in repository.js. But that means
+   * the orphaned change record lingers in the graph, and before this fix
+   * `all()` (a flat `graph.getAll()`) surfaced it in `log()` right
+   * alongside everything still actually reachable.
+   *
+   * Real jj hides a commit from the default log when it is BOTH:
+   *   - unreachable from any visible head (not itself a head, and not an
+   *     ancestor of one), AND
+   *   - "discardable": empty (no file diff versus its own parent) and
+   *     undescribed.
+   * Merge commits (2+ parents) are conservatively never treated as
+   * "empty" here — real jj's diff-emptiness rule for merges is more
+   * involved and isn't needed by anything this package creates today.
+   *
+   * "Visible head" here deliberately does NOT mean "any change with no
+   * children" (that's what the `visible_heads()` revset function computes,
+   * structurally, from the raw graph) — an orphan `new()`/`squash()`
+   * change that undo() un-referenced has no children EITHER, so it would
+   * trivially count as its own head under that definition and never be
+   * excludable. Real jj instead tracks an explicit, maintained set of
+   * heads in its View (updated as operations run — abandoning/squashing a
+   * change removes it, rebasing children onto a new parent removes the
+   * old parent, etc.). This package doesn't thread the operation log's
+   * `view.heads` through to the revset engine, but the working-copy
+   * pointer plus every bookmark/tag target is the closest available
+   * proxy for "what's actually still in play" — anything only reachable
+   * from those, not from every dangling graph leaf.
+   *
+   * @param {any[]} allChanges - `graph.getAll()`
+   * @returns {Promise<Set<string>>} change IDs to exclude
+   */
+  async _computeHiddenOrphans(allChanges) {
+    const trackedHeads = new Set();
+    try {
+      const wcId = this.workingCopy && this.workingCopy.getCurrentChangeId();
+      if (wcId) trackedHeads.add(wcId);
+    } catch {
+      // working copy not loaded/available — fine, just no wc-based root.
+    }
+    if (this.bookmarkStore) {
+      await this.bookmarkStore.load();
+      for (const bookmark of await this.bookmarkStore.list()) {
+        if (bookmark && bookmark.changeId) trackedHeads.add(bookmark.changeId);
+      }
+    }
+    if (this.tagStore) {
+      for (const tag of await this.tagStore.list()) {
+        if (tag && tag.changeId) trackedHeads.add(tag.changeId);
+      }
+    }
+
+    const reachable = new Set();
+    for (const headId of trackedHeads) {
+      for (const id of await this.getAncestors(headId)) {
+        reachable.add(id);
+      }
+    }
+
+    // Sentinel "no message given" descriptions this package itself writes
+    // (new()'s '(no description)', squash()'s post-squash working-copy
+    // change '(no description set)') are, for visibility purposes, just
+    // as undescribed as a genuinely empty/missing description field.
+    const UNDESCRIBED = new Set([undefined, null, '', '(no description)', '(no description set)']);
+
+    const byId = new Map(allChanges.map((c) => [c.changeId, c]));
+    const isEmpty = (/** @type {any} */ change) => {
+      const parents = change.parents || [];
+      if (parents.length === 0) {
+        return !change.fileSnapshot || Object.keys(change.fileSnapshot).length === 0;
+      }
+      if (parents.length > 1) return false; // merges: not handled by this rule
+      const parent = byId.get(parents[0]);
+      const parentSnapshot = (parent && parent.fileSnapshot) || {};
+      const ownSnapshot = change.fileSnapshot || {};
+      const parentKeys = Object.keys(parentSnapshot);
+      const ownKeys = Object.keys(ownSnapshot);
+      if (parentKeys.length !== ownKeys.length) return false;
+      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) || change.autoCreated) &&
+        UNDESCRIBED.has(change.description)
+      ) {
+        hidden.add(change.changeId);
+      }
+    }
+    return hidden;
+  }
+
   /**
    * Resolve a revset argument to a set of change IDs (v1.5).
    *
@@ -7899,7 +8082,16 @@ async function createJJ(options) {
     await graph.load();
     for (const [changeId, snapshot] of Object.entries(reversal.changeSnapshotToApply)) {
       if (await graph.getChange(changeId)) {
-        await graph.updateChange(snapshot);
+        // Bypass the git-sync middleware (baseGraph, not the wrapped
+        // `graph`): undo/restore are pure reverts, and `snapshot` already
+        // carries the change's ORIGINAL commitId from before the reverted
+        // operation(s) ran. Going through graph.updateChange() would fire
+        // onUpdateChange -> syncChangeToGit(), which mints a brand-new
+        // commit (and thus a new commitId) from the CURRENT tree instead
+        // of restoring the one that was actually there — see issue #37(c):
+        // "undo/restore give reverted commits new commit IDs". Writing the
+        // snapshot verbatim via baseGraph puts the original commitId back.
+        await baseGraph.updateChange(snapshot);
       }
     }
 
@@ -7923,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;
@@ -7954,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
@@ -8389,6 +8625,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
@@ -8404,7 +8651,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,
@@ -8412,6 +8658,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,
@@ -8840,6 +9100,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;
@@ -8952,6 +9221,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);
@@ -8967,8 +9262,9 @@ async function createJJ(options) {
         view: {
           bookmarks: {},
           remoteBookmarks: {},
-          heads: [],
+          heads: await computeCurrentHeads(),
           workingCopy: workingCopy.getCurrentChangeId(),
+          fileSnapshot: fileSnapshotBefore,
         },
       });
 
@@ -9423,6 +9719,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)
@@ -9543,17 +9849,51 @@ 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);
         }
       } catch {
         // Best-effort content refresh.
       }
+
+      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;
     },
 
@@ -10017,8 +10357,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();
@@ -10037,6 +10389,16 @@ async function createJJ(options) {
       // which operation it targeted so a following undo() can walk one
       // step further back (resolveUndoTarget) instead of toggling, and
       // carrying exactly what redo() needs to re-apply (captured above).
+      //
+      // Also record `changeSnapshot: redoChangeSnapshot` — the SAME
+      // ground-truth-before-this-op values, but under the field name
+      // computeGraphReversal() actually scans for. Without this, undo()
+      // itself was the one mutating operation in the whole API that never
+      // recorded its own changeSnapshot, so a LATER undo() targeting THIS
+      // undo (to step back past it) had nothing to restore: it would
+      // repoint the working copy and files, but leave whatever this
+      // undo() overwrote (e.g. a change's description) exactly as this
+      // undo() left it. See issue #37(a).
       await oplog.recordOperation({
         timestamp: new Date().toISOString(),
         user: await getUserOplogInfo(),
@@ -10044,11 +10406,12 @@ async function createJJ(options) {
         eventType: 'undo',
         targetOpId: targetOp.id,
         undoneOpId: targetOp.id, // kept for API/type compatibility
+        changeSnapshot: redoChangeSnapshot,
         redoChangeSnapshot,
         redoFileSnapshot,
         redoConflictsSnapshot,
         parents: [],
-        view: landingView,
+        view: { ...landingView, fileSnapshot: diskSnapshotBeforeThisOp },
       });
 
       const restoredFileCount =
@@ -10121,11 +10484,36 @@ async function createJJ(options) {
       // by scanning forward. undo() captured it directly for exactly this
       // reason (see its own comment).
       await graph.load();
+
+      // Capture ground truth right before overwriting, same as undo()
+      // does for its own changeSnapshot (issue #37a) — lets a later
+      // undo() targeting THIS redo op restore what redo() is about to
+      // clobber, instead of finding no changeSnapshot at all.
+      /** @type {Record<string, any>} */
+      const undoChangeSnapshot = {};
+      for (const changeId of Object.keys(undoOp.redoChangeSnapshot || {})) {
+        const current = await graph.getChange(changeId);
+        if (current) undoChangeSnapshot[changeId] = current;
+      }
+
       for (const [changeId, snapshot] of Object.entries(undoOp.redoChangeSnapshot || {})) {
         if (await graph.getChange(changeId)) {
-          await graph.updateChange(snapshot);
-        }
-      }
+          // Bypass the git-sync middleware — see the matching comment in
+          // applyGraphReversal(). `snapshot` already carries the change's
+          // correct commitId from before the undo it's reversing ran
+          // (issue #37c applies to redo() too).
+          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);
       }
@@ -10144,8 +10532,9 @@ async function createJJ(options) {
         description: 'redo operation',
         eventType: 'redo',
         redoOf: undoOp.id,
+        changeSnapshot: undoChangeSnapshot,
         parents: [],
-        view: redoneView,
+        view: { ...redoneView, fileSnapshot: diskSnapshotBeforeThisOp },
       });
 
       const restoredFileCount =
@@ -10434,6 +10823,34 @@ async function createJJ(options) {
         // Revert the change graph, working-copy files, and conflict state
         // to exactly what they were right after targetOp ran.
         const reversal = computeGraphReversal(ops, targetOp);
+
+        // Capture ground truth for every changeId this restore is about to
+        // overwrite, BEFORE applying the reversal — exactly like undo()
+        // does for its own changeSnapshot. Without this, restore()'s own
+        // oplog entry carried no changeSnapshot at all, so undoing the
+        // restore itself had nothing to put back: a later undo() would
+        // repoint the working copy and files, but leave whatever the
+        // restore had just overwritten (e.g. a change's description)
+        // exactly as the restore left it. See issue #37(a).
+        await graph.load();
+        /** @type {Record<string, any>} */
+        const changeSnapshot = {};
+        for (const changeId of Object.keys(reversal.changeSnapshotToApply)) {
+          const current = await graph.getChange(changeId);
+          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
@@ -10442,7 +10859,8 @@ async function createJJ(options) {
           user: await getUserOplogInfo(),
           description: `restore to operation ${args.operation}`,
           parents: [],
-          view: targetOp.view,
+          changeSnapshot,
+          view: { ...targetOp.view, fileSnapshot: diskSnapshotBeforeThisOp },
         });
 
         return {
@@ -10678,6 +11096,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;
 
@@ -10801,10 +11228,34 @@ async function createJJ(options) {
           },
           description: '(no description set)',
           timestamp: new Date().toISOString(),
-          fileSnapshot: {},
+          // Start from the DESTINATION's tree (which now includes source's
+          // folded-in changes, set above), not an empty object — matches
+          // real `jj squash`, where the new working-copy change looks
+          // identical to its new parent until you touch something. Issue
+          // #39: this used to hard-code `{}`, so status()/snapshot() saw
+          // 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
+        // Sync the working directory to match (issue #30's fix for
+        // new()/edit(); squash()'s own synthetic post-squash change never
+        // did this) — a no-op when source's parent was already dest (the
+        // common case), but necessary whenever source/dest aren't adjacent.
+        await syncWorkingCopyFiles(newChange.fileSnapshot);
         await workingCopy.setCurrentChange(newChangeId);
         newWorkingCopyId = newChangeId;
       }
@@ -10819,8 +11270,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,
         },
       });
 
@@ -10886,6 +11347,18 @@ async function createJJ(options) {
         throw new JJError('CHANGE_NOT_FOUND', `Change ${changeId} not found`);
       }
 
+      // Captured BEFORE anything mutates — see issue #38: abandoning the
+      // change @ currently points at must move @ off it (real jj checks
+      // out a fresh empty change on the abandoned change's own parent(s));
+      // 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',
@@ -10920,8 +11393,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,
         },
       });
 
@@ -10938,6 +11419,17 @@ async function createJJ(options) {
         { cancelable: false }
       );
 
+      // If @ was pointing at the change we just abandoned, it can't stay
+      // there — real jj moves @ to a new empty change on the abandoned
+      // change's own parent(s) (issue #38). Reuse new()'s own "create an
+      // empty change with given parents" logic rather than duplicating it
+      // — this is exactly the workaround callers had to reach for
+      // themselves (`new({ parents: [parentOfAt] })` before abandoning).
+      if (wasWorkingCopy) {
+        const newWorkingCopyChange = await jj.new({ parents: change.parents || [] });
+        return { ...change, newWorkingCopyChangeId: newWorkingCopyChange.changeId };
+      }
+
       return change;
     },
 
@@ -13172,6 +13664,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
@@ -13215,6 +13733,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 };
       },