isomorphic-jj 1.13.0 → 1.14.0

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 1.14.0 — 2026-10-09 — describe()/metaedit() honor changeId; operations.restore() restores the view
+
+Fixes [#55](https://github.com/johnhenry/isomorphic-jj/issues/55) and
+[#56](https://github.com/johnhenry/isomorphic-jj/issues/56). Both change
+observable behavior, hence a minor bump.
+
+### Fixed
+
+- **`describe()` and `metaedit()` ignored `changeId`.** Both only read the
+  older `revision` option (`metaedit` also `change`), so
+  `describe({ changeId, message })` silently rewrote the working-copy change
+  instead of the named one -- the documented option (API.md) did nothing and
+  `DescribeArgs` in `types.d.ts` didn't list it. Both now accept `changeId`
+  (alongside `revision`), rewrite exactly that change, leave the working
+  copy's description alone, and keep change IDs stable. `DescribeArgs` gains
+  `changeId` and `revision`. Regression tests:
+  `tests/integration/describe-change-id.test.js`.
+- **`operations.restore()` left changes created after the target operation
+  visible.** The restore operation recorded the right view (heads, working
+  copy), but the revset layer only hid orphaned changes that were empty and
+  undescribed, so a described change stayed in `log()`, `heads(all())` and
+  `visible_heads()`. As in jj, restoring now restores the *view*: every
+  change created after the target operation and unreachable from the
+  restored working copy, bookmarks and tags is hidden (not deleted -- it
+  stays in the graph and resolvable by change ID). The hidden set is stored
+  in the operation's `view.hiddenChanges`, so it persists across later
+  operations, `undo()`/`redo()` of the restore bring the changes back, and
+  they reappear if the working copy/bookmarks make them reachable again
+  (e.g. `edit({ changeId })`). **Behavior change:** `log()` after a restore
+  no longer lists such changes. Regression tests:
+  `tests/integration/op-restore-view.test.js`.
+
 ## 1.13.0 — 2026-10-05 — Write-path fixes: converge on a fresh instance, new files lost on edit(), rebase content
 
 Fixed in [PR #52](https://github.com/johnhenry/isomorphic-jj/pull/52).

package/README.md

@@ -1020,7 +1020,7 @@ repo/
 
 ## Project Status
 
-**Current Version**: 1.13.0 (`@johnhenry/isomorphic-jj`; same library/API lineage as the old `isomorphic-jj`, which reached v1.8.0 before the rename — see the provenance note at the top of this file, and the CHANGELOG's `1.9.0` entry for how the scoped/unscoped version lineages were merged back together)
+**Current Version**: 1.14.0 (`@johnhenry/isomorphic-jj`; same library/API lineage as the old `isomorphic-jj`, which reached v1.8.0 before the rename — see the provenance note at the top of this file, and the CHANGELOG's `1.9.0` entry for how the scoped/unscoped version lineages were merged back together)
 **Test Coverage**: 1882 tests passing, ~97% statements / 90% branches
 **JJ CLI parity**: tracks Jujutsu through v0.45.1
 **Status**: Actively developed; broad JJ CLI semantic parity, used in the examples/apps in this repo and in [JJHub](#family). Not yet 1.0 in the API-stability sense (the version number is past 1.0 only because merging the scoped/unscoped lineages forced it above the unscoped side's prior ceiling, not because the API is frozen) — API surface can still shift; pin a version and read the CHANGELOG before upgrading.
@@ -1038,6 +1038,7 @@ repo/
 - ✅ 0.3.0: Parity refresh tracking jj through **v0.45.1** — a working `/browser` entry (async `createBrowserFS()`, bundle-safe protobuf schema loading, no stray Node-only imports), `undo()`/`operations.restore()` reverting graph rewrites with real progressive undo/redo, `squash()`/`abandon()`/`edit()`/`new()` fully syncing content instead of only metadata, `rebase()` performing a real three-way merge and recording conflicts, and the new `converge()` command (jj v0.45.0) to auto-resolve divergent commits. See [CHANGELOG.md](./CHANGELOG.md).
 - ✅ 0.4.0: `converge()` generalized from pairwise to N-way — any number of divergent copies of one change id resolve in a single call, matching how jj's own underlying engine already treats divergence internally (issue #32). See [CHANGELOG.md](./CHANGELOG.md).
 - ✅ 1.9.0: Scoped (`@johnhenry/isomorphic-jj`) and unscoped (`isomorphic-jj`) version lineages merged into one shared version going forward, with both names dual-published on every release.
+- ✅ 1.14.0: `describe()`/`metaedit()` honor `changeId`; `operations.restore()` restores the view (changes created after the target op are hidden from `log()`). See [CHANGELOG.md](./CHANGELOG.md).
 - ✅ 1.13.0: Write-path fixes — `converge()` works on a fresh instance, `edit()` no longer deletes new files `write()` created in the change it leaves, and `moveChange()`/`rebase()` derives the rebased change's content (new parent + the change's own edits) instead of keeping its tree verbatim. Not done: a rebase re-derives only the moved change's content, not its descendants', and conflicts are detected per whole file, not per line. See [CHANGELOG.md](./CHANGELOG.md).
 - ✅ 1.9.1 – 1.12.0: Operation-log reliability pass — `undo()`/`operations.restore()` correctness across write/snapshot/squash/rebase/abandon/edit, `log()` visibility fixes, and recording gaps in descendant rebases and conflict-resolution ops (issues #37–#39, #41, #43, #45, #48). See [CHANGELOG.md](./CHANGELOG.md) for the full per-fix breakdown.
 

package/dist/index.cjs

@@ -1517,6 +1517,24 @@ class OperationLog {
       operation.parents = operation.parents || [];
     }
 
+    // `view.hiddenChanges` (written by operations.restore()) is part of the
+    // view, so it persists across later operations. undo()/redo()/restore()
+    // set it explicitly (their view is a snapshot of another operation);
+    // every other operation carries the current head's value forward.
+    if (
+      this.headOperationId &&
+      operation.view &&
+      !('hiddenChanges' in operation.view) &&
+      operation.eventType !== 'undo' &&
+      operation.eventType !== 'redo'
+    ) {
+      const headOp = this.operations.find((op) => op.id === this.headOperationId);
+      const inherited = headOp.view && headOp.view.hiddenChanges;
+      if (inherited && inherited.length > 0) {
+        operation.view = { ...operation.view, hiddenChanges: inherited };
+      }
+    }
+
     // Generate operation ID
     const id = await generateOperationId(operation);
     const fullOperation = {
@@ -2763,16 +2781,18 @@ class RevsetEngine {
       case 'visible_heads': {
         await this.graph.load();
         const allChanges = this.graph.getAll();
-        const changeIdSet = new Set(allChanges.map((c) => c.changeId));
+        const restoreHidden = await this._computeRestoreHidden();
+        const visibleChanges = allChanges.filter((c) => !restoreHidden.has(c.changeId));
+        const changeIdSet = new Set(visibleChanges.map((c) => c.changeId));
         const hasChildren = new Set();
-        for (const change of allChanges) {
+        for (const change of visibleChanges) {
           if (change.parents) {
             for (const parent of change.parents) {
               if (changeIdSet.has(parent)) hasChildren.add(parent);
             }
           }
         }
-        return allChanges.filter((c) => !hasChildren.has(c.changeId)).map((c) => c.changeId);
+        return visibleChanges.filter((c) => !hasChildren.has(c.changeId)).map((c) => c.changeId);
       }
 
       // `git_refs()` and `git_head()` are deprecated compatibility shims.
@@ -3258,6 +3278,49 @@ class RevsetEngine {
    * @returns {Promise<Set<string>>} change IDs to exclude
    */
   async _computeHiddenOrphans(allChanges) {
+    const restoreHidden = await this._computeRestoreHidden();
+    const hidden = await this._computeUnreferencedOrphans(allChanges);
+    for (const id of restoreHidden) hidden.add(id);
+    return hidden;
+  }
+
+  /**
+   * Changes hidden by `operations.restore()` (issue #56): the head
+   * operation's `view.hiddenChanges`, minus any that the current working
+   * copy / bookmarks / tags make reachable again. Deliberately does NOT use
+   * the operation log's recorded heads for reachability -- later operations
+   * record structural heads, which would include the hidden leaf itself.
+   *
+   * @returns {Promise<Set<string>>}
+   */
+  async _computeRestoreHidden() {
+    const hidden = new Set();
+    if (!this.oplog) return hidden;
+    const headOp = await this.oplog.getHeadOperation();
+    const listed = (headOp && headOp.view && headOp.view.hiddenChanges) || [];
+    if (listed.length === 0) return hidden;
+
+    const roots = new Set([this.workingCopy.getCurrentChangeId()]);
+    await this.bookmarkStore.load();
+    for (const bookmark of await this.bookmarkStore.list()) roots.add(bookmark.changeId);
+    for (const tag of await this.tagStore.list()) roots.add(tag.changeId);
+    const reachable = new Set();
+    for (const rootId of roots) {
+      for (const id of await this.getAncestors(rootId)) reachable.add(id);
+    }
+    for (const id of listed) {
+      if (!reachable.has(id)) hidden.add(id);
+    }
+    return hidden;
+  }
+
+  /**
+   * The #37(b)/#43(2)/#48 rule: unreachable, undescribed orphans.
+   *
+   * @param {any[]} allChanges
+   * @returns {Promise<Set<string>>}
+   */
+  async _computeUnreferencedOrphans(allChanges) {
     const trackedHeads = new Set();
     try {
       const wcId = this.workingCopy && this.workingCopy.getCurrentChangeId();
@@ -8203,6 +8266,61 @@ async function createJJ(options) {
     return heads;
   };
 
+  /**
+   * Changes that `operations.restore(targetOp)` must hide (issue #56): every
+   * change created after `targetOp` (i.e. not among the heads / working copy /
+   * touched changes recorded up to targetOp, nor their ancestors) that is not
+   * reachable from the restored working copy, bookmarks or tags. Hidden, not
+   * deleted -- they reappear if a later operation makes them reachable again.
+   * Previously hidden changes that targetOp's own view already hid stay hidden.
+   *
+   * @param {any[]} ops - Full operation list (chronological)
+   * @param {any} targetOp
+   * @returns {Promise<string[]>}
+   */
+  const computeRestoreHiddenChanges = async (ops, targetOp) => {
+    await graph.load();
+    const ancestorsOf = (/** @type {Iterable<string>} */ seeds) => {
+      const seen = new Set();
+      const stack = [...seeds];
+      while (stack.length > 0) {
+        const id = /** @type {string} */ (stack.pop());
+        if (seen.has(id)) continue;
+        seen.add(id);
+        for (const parent of graph.getParents(id)) stack.push(parent);
+      }
+      return seen;
+    };
+
+    const targetIndex = ops.findIndex((o) => o.id === targetOp.id);
+    const knownSeeds = new Set();
+    for (const op of ops.slice(0, targetIndex + 1)) {
+      const view = op.view || {};
+      for (const id of view.heads || []) knownSeeds.add(id);
+      if (view.workingCopy) knownSeeds.add(view.workingCopy);
+      for (const id of Object.keys(op.changeSnapshot || {})) knownSeeds.add(id);
+    }
+    const known = ancestorsOf(knownSeeds);
+
+    const roots = new Set([workingCopy.getCurrentChangeId()]);
+    await bookmarks.load();
+    for (const bookmark of await bookmarks.list()) roots.add(bookmark.changeId);
+    for (const tag of await tags.list()) roots.add(tag.changeId);
+    const reachable = ancestorsOf(roots);
+
+    const hidden = new Set(
+      ((targetOp.view && targetOp.view.hiddenChanges) || []).filter(
+        (/** @type {string} */ id) => !reachable.has(id)
+      )
+    );
+    for (const change of graph.getAll()) {
+      if (!known.has(change.changeId) && !reachable.has(change.changeId)) {
+        hidden.add(change.changeId);
+      }
+    }
+    return [...hidden];
+  };
+
   /**
    * Re-parent every child of `changeId` onto `newParents` instead — used
    * when a change is being elided from the graph (abandon(), issue #30;
@@ -9537,6 +9655,11 @@ async function createJJ(options) {
      * @param {Record<string, any>} [args]
      */
     async describe(args = {}) {
+      // Documented option is `changeId`; `revision` is the older spelling.
+      if (args.changeId && !args.revision) {
+        args = { ...args, revision: args.changeId };
+      }
+
       await graph.load();
       await workingCopy.load();
       await userConfig.load();
@@ -9686,10 +9809,13 @@ async function createJJ(options) {
      * @returns {Promise<Object>} Updated change object
      */
     async metaedit(args = {}) {
-      // Normalize: accept 'change' as alias for 'revision'
+      // Normalize: accept 'change' / 'changeId' as aliases for 'revision'
       if (args.change && !args.revision) {
         args = { ...args, revision: args.change };
       }
+      if (args.changeId && !args.revision) {
+        args = { ...args, revision: args.changeId };
+      }
 
       // Normalize: accept 'message' as alias for 'description'
       if (args.message && !args.description) {
@@ -10617,7 +10743,11 @@ async function createJJ(options) {
         redoFileSnapshot,
         redoConflictsSnapshot,
         parents: [],
-        view: { ...landingView, fileSnapshot: diskSnapshotBeforeThisOp },
+        view: {
+          ...landingView,
+          fileSnapshot: diskSnapshotBeforeThisOp,
+          hiddenChanges: landingView.hiddenChanges || [],
+        },
       });
 
       const restoredFileCount =
@@ -10740,7 +10870,11 @@ async function createJJ(options) {
         redoOf: undoOp.id,
         changeSnapshot: undoChangeSnapshot,
         parents: [],
-        view: { ...redoneView, fileSnapshot: diskSnapshotBeforeThisOp },
+        view: {
+          ...redoneView,
+          fileSnapshot: diskSnapshotBeforeThisOp,
+          hiddenChanges: redoneView.hiddenChanges || [],
+        },
       });
 
       const restoredFileCount =
@@ -11072,6 +11206,13 @@ async function createJJ(options) {
 
         await applyGraphReversal(reversal);
 
+        // Restoring the view hides (not deletes) every change that was
+        // created after targetOp and is not reachable from the restored
+        // working copy / bookmarks / tags -- see issue #56. The list is
+        // recorded in the view so it survives later operations, and so
+        // undo()/redo() of the restore bring the changes back.
+        const hiddenChanges = await computeRestoreHiddenChanges(ops, targetOp);
+
         // Record this restoration as a new operation
         await oplog.recordOperation({
           timestamp: new Date().toISOString(),
@@ -11079,7 +11220,7 @@ async function createJJ(options) {
           description: `restore to operation ${args.operation}`,
           parents: [],
           changeSnapshot,
-          view: { ...targetOp.view, fileSnapshot: diskSnapshotBeforeThisOp },
+          view: { ...targetOp.view, fileSnapshot: diskSnapshotBeforeThisOp, hiddenChanges },
         });
 
         return {