isomorphic-jj 1.7.0 → 1.8.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "isomorphic-jj",
-  "version": "1.7.0",
-  "description": "A pure-JavaScript library that brings Jujutsu (jj) version control semantics to Node.js and browsers",
+  "version": "1.8.0",
+  "description": "Jujutsu (jj) version control semantics in pure JavaScript — stable change IDs, fearless undo, no staging area — for Node.js and browsers",
   "type": "module",
   "bin": {
     "isojj": "./bin/isojj.js"
@@ -30,6 +30,19 @@
   ],
   "scripts": {
     "demo": "node demo.mjs",
+    "examples": "for f in examples/*.mjs; do echo \"=== $f\"; node \"$f\" || exit 1; done",
+    "example:01": "node examples/01-init-commit-log.mjs",
+    "example:02": "node examples/02-stacked-changes.mjs",
+    "example:03": "node examples/03-history-editing.mjs",
+    "example:04": "node examples/04-branching-and-merging.mjs",
+    "example:05": "node examples/05-conflicts.mjs",
+    "example:06": "node examples/06-revsets.mjs",
+    "example:07": "node examples/07-bookmarks-and-tags.mjs",
+    "example:08": "node examples/08-git-interop.mjs",
+    "example:09": "node examples/09-config.mjs",
+    "example:10": "node examples/10-undo-and-oplog.mjs",
+    "example:11": "node examples/11-file-operations.mjs",
+    "example:12": "node examples/12-browser.mjs",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch",
     "test:coverage": "node --experimental-vm-modules node_modules/jest/bin/jest.js --coverage",
@@ -58,12 +71,12 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/johnhenry/isomorphic-jj.git"
+    "url": "git+https://github.com/johnhenry/isomorphic-jj.git"
   },
   "bugs": {
     "url": "https://github.com/johnhenry/isomorphic-jj/issues"
   },
-  "homepage": "https://github.com/johnhenry/isomorphic-jj#readme",
+  "homepage": "https://opensource.johnhenry.me/isomorphic-jj/",
   "peerDependencies": {
     "isomorphic-git": "^1.24.0"
   },

package/src/api/repository.js

@@ -1155,6 +1155,11 @@ export async function createJJ(options) {
       const isWorkingCopy = targetChangeId === workingCopy.getCurrentChangeId();
       const fileSnapshotBefore = isWorkingCopy ? await snapshotFilesystem() : null;
 
+      // Snapshot the change record itself from BEFORE this operation mutates
+      // it in place, so undo() can restore ChangeGraph content (not just
+      // on-disk files/working-copy pointer) — mirrors fileSnapshotBefore above.
+      const changeSnapshotBefore = structuredClone(change);
+
       // Dispatch change:updating event (preventable)
       await dispatchEventAsync(jj, 'change:updating', {
         operation: 'describe',
@@ -1235,6 +1240,10 @@ export async function createJJ(options) {
         },
         description: `describe change ${targetChangeId.slice(0, 8)}`,
         parents: [],
+        // Snapshot of the affected ChangeGraph node from BEFORE this
+        // operation ran, so undo() can restore in-place content mutations
+        // (e.g. the description change below) — not just files/pointers.
+        changeSnapshot: { [targetChangeId]: changeSnapshotBefore },
         view: {
           bookmarks: {},
           remoteBookmarks: {},
@@ -1747,11 +1756,28 @@ export async function createJJ(options) {
         // Try to resolve as revset
         try {
           const changes = await revset.evaluate(args.change);
+          if (changes.length > 1) {
+            // An id-prefix (or other) revset that matches more than one
+            // change must not silently pick a "winner" — see issue #13.
+            throw new JJError(
+              'AMBIGUOUS_ID',
+              `"${args.change}" is ambiguous: it resolves to ${changes.length} changes (${changes.join(', ')})`,
+              {
+                expression: args.change,
+                matches: changes,
+                suggestion: 'Use a longer prefix or an exact change ID to disambiguate',
+              }
+            );
+          }
           if (changes.length > 0) {
             changeId = changes[0];
           }
-        } catch {
-          // Use as-is
+        } catch (error) {
+          if (error instanceof JJError && error.code === 'AMBIGUOUS_ID') {
+            throw error;
+          }
+          // Not a valid revset expression - use args.change as-is (e.g. a
+          // literal change ID that revset parsing rejected).
         }
       }
 
@@ -1994,6 +2020,21 @@ export async function createJJ(options) {
       // Restore state from previous view
       await workingCopy.setCurrentChange(previousView.workingCopy);
 
+      // Restore ChangeGraph content mutated in place by the operation being
+      // undone (e.g. describe() editing change.description) — see issue #12.
+      // currentOp.changeSnapshot holds the affected change record(s) as they
+      // were BEFORE currentOp ran, captured the same way fileSnapshot is.
+      await graph.load();
+      if (currentOp && currentOp.changeSnapshot) {
+        for (const snapshot of Object.values(
+          /** @type {Record<string, any>} */ (currentOp.changeSnapshot)
+        )) {
+          if (snapshot && (await graph.getChange(snapshot.changeId))) {
+            await graph.updateChange(snapshot);
+          }
+        }
+      }
+
       // Restore filesystem from previous operation's snapshot (taken BEFORE that operation)
       // This is how JJ snapshots the working copy before every command
       if (previousView.fileSnapshot) {
@@ -2478,6 +2519,7 @@ export async function createJJ(options) {
         // Compute the inverse changes
         const inversChanges = /** @type {Record<string, any>} */ ({
           bookmarks: {},
+          tags: {},
           heads: [],
         });
 
@@ -2517,6 +2559,46 @@ export async function createJJ(options) {
 
         await bookmarks.save();
 
+        // Revert tag changes (mirrors the bookmark diff above — issue #12).
+        // Unlike bookmarks, TagStore has no "move" primitive (tags are meant
+        // to be immutable once created), so a moved tag is reverted via
+        // delete+recreate, matching how tag.set() itself updates a tag.
+        const prevTags = previousOp.view?.tags || {};
+        const targetTags = targetOp.view?.tags || {};
+
+        for (const name of Object.keys(targetTags)) {
+          if (!prevTags[name]) {
+            // Tag was added - delete it
+            if (await tags.exists(name)) {
+              await tags.delete(name);
+            }
+            inversChanges.tags[name] = { action: 'deleted' };
+          } else if (prevTags[name] !== targetTags[name]) {
+            // Tag was moved - restore old target
+            if (await tags.exists(name)) {
+              await tags.delete(name);
+            }
+            await tags.create(name, prevTags[name]);
+            inversChanges.tags[name] = {
+              action: 'moved',
+              from: targetTags[name],
+              to: prevTags[name],
+            };
+          }
+        }
+
+        // Check for deleted tags (existed before, don't exist after)
+        for (const name of Object.keys(prevTags)) {
+          if (!targetTags[name] && !(await tags.exists(name))) {
+            // Tag was deleted - restore it
+            await tags.create(name, prevTags[name]);
+            inversChanges.tags[name] = {
+              action: 'restored',
+              to: prevTags[name],
+            };
+          }
+        }
+
         // Revert working copy change if it changed
         if (previousOp.view?.workingCopy !== targetOp.view?.workingCopy) {
           await workingCopy.load();
@@ -2531,6 +2613,7 @@ export async function createJJ(options) {
           parents: [],
           view: {
             bookmarks: prevBookmarks,
+            tags: prevTags,
             remoteBookmarks: previousOp.view?.remoteBookmarks || {},
             heads: previousOp.view?.heads || [],
             workingCopy: previousOp.view?.workingCopy,
@@ -4968,11 +5051,18 @@ export async function createJJ(options) {
           throw new JJError('CONFLICT_NOT_FOUND', `Conflict ${args.conflictId} not found`);
         }
 
-        // Generate standard conflict markers
+        // Generate standard conflict markers. Force a newline before each
+        // boundary marker whenever there's non-empty content that doesn't
+        // already end in one — otherwise the content fuses onto the
+        // `=======`/`>>>>>>> theirs` marker, producing a corrupted/unparseable
+        // line (see issue #15). Empty sides (e.g. a modify-delete conflict)
+        // intentionally get no extra blank line before the marker.
         const ours = conflict.sides.left || '';
         const theirs = conflict.sides.right || '';
+        const oursSep = ours && !ours.endsWith('\n') ? '\n' : '';
+        const theirsSep = theirs && !theirs.endsWith('\n') ? '\n' : '';
 
-        return `<<<<<<< ours\n${ours}=======\n${theirs}>>>>>>> theirs`;
+        return `<<<<<<< ours\n${ours}${oursSep}=======\n${theirs}${theirsSep}>>>>>>> theirs`;
       },
 
       /**
@@ -5059,10 +5149,17 @@ export async function createJJ(options) {
        * Searches the tracked files of a change (defaults to the working copy)
        * for lines matching a pattern. Following jj v0.41, the pattern is treated
        * as a regular expression by default; pass `{ kind: 'substring' }` for a
-       * literal search.
+       * literal search. isomorphic-jj has always returned the matched line
+       * (and its 1-based `lineNumber`) alongside the path, which is what jj
+       * v0.44 made the CLI's new default (`jj file search` used to print only
+       * file paths). Pass `{ nameOnly: true }` for the pre-v0.44 CLI
+       * behavior — a deduplicated list of matching file paths, matching the
+       * new `--name-only` flag.
        *
-       * @param {Record<string, any>} args - Arguments
-       * @returns {Promise<Array<{path: string, lineNumber: number, line: string}>>}
+       * @param {Record<string, any>} args - Arguments. Pass `nameOnly: true`
+       *   to return only unique matching file paths instead of per-line
+       *   matches (jj v0.44 `--name-only`)
+       * @returns {Promise<Array<{path: string, lineNumber: number, line: string}>|Array<string>>}
        */
       async search(args) {
         if (!args || !args.pattern) {
@@ -5113,6 +5210,10 @@ export async function createJJ(options) {
             }
           });
         }
+
+        if (args.nameOnly) {
+          return Array.from(new Set(results.map((r) => r.path)));
+        }
         return results;
       },
 
@@ -6194,6 +6295,10 @@ export async function createJJ(options) {
           view: {
             bookmarks: {},
             remoteBookmarks: {},
+            // Tag delta for this operation (mirrors how `bookmarks` records
+            // its delta above), so operations.revert() can diff it — see
+            // issue #12.
+            tags: { [args.name]: changeId },
             heads: [],
             workingCopy: workingCopy.getCurrentChangeId(),
           },
@@ -6239,6 +6344,7 @@ export async function createJJ(options) {
           view: {
             bookmarks: {},
             remoteBookmarks: {},
+            tags: { [args.name]: changeId },
             heads: [],
             workingCopy: workingCopy.getCurrentChangeId(),
           },
@@ -6248,10 +6354,11 @@ export async function createJJ(options) {
       },
 
       /**
-       * List all tags
+       * List all tags. Each entry also carries a `tracking: { remote, ref }`
+       * field when the tag is tracking a remote (jj v0.44 `jj tag track`).
        *
        * @param {Record<string, any>} [args] - Optional filter arguments
-       * @returns {Promise<Array<{name: string, changeId: string}>>} List of tags
+       * @returns {Promise<Array<Record<string, any>>>} List of tags
        */
       async list(args) {
         const pattern = args?.pattern;
@@ -6283,6 +6390,7 @@ export async function createJJ(options) {
           view: {
             bookmarks: {},
             remoteBookmarks: {},
+            tags: {},
             heads: [],
             workingCopy: workingCopy.getCurrentChangeId(),
           },
@@ -6290,6 +6398,94 @@ export async function createJJ(options) {
 
         return { deleted: args.name };
       },
+
+      /**
+       * Associate a local tag with a remote tag so it is updated on fetch
+       * (matches `jj tag track`, new in jj v0.44).
+       *
+       * jj v0.44 made tags remote-trackable just like bookmarks: fetched
+       * tags are tracked by default, and `jj tag track`/`untrack` let you
+       * opt individual tags in or out by hand. isomorphic-jj doesn't (yet)
+       * auto-import remote tags during `git.fetch()` — see CHANGELOG — so
+       * this records tracking intent/state the same way `bookmark.track()`
+       * does, without changing fetch's own behavior.
+       *
+       * @param {Record<string, any>} args - Tag arguments: `{ name, remote }`
+       *   (`name` is the local tag name to track; `remote` defaults to `'origin'`)
+       * @returns {Promise<{name: string, remote: string, tracking: boolean}>}
+       */
+      async track(args) {
+        if (!args || !args.name) {
+          throw new JJError('INVALID_ARGUMENT', 'Missing tag name', {
+            suggestion: 'Provide tag name: { name: "v1.0.0", remote: "origin" }',
+          });
+        }
+
+        const remote = args.remote || 'origin';
+        const remoteTagName = `${remote}/${args.name}`;
+
+        const tagMap = await tags.load();
+        /** @type {Record<string, any>} */
+        const tracking = tags.tracking || {};
+        tracking[args.name] = { remote, remoteName: args.name };
+        tags.tracking = tracking;
+        await tags.save(tagMap);
+
+        // Record operation
+        await oplog.recordOperation({
+          timestamp: new Date().toISOString(),
+          user: await getUserOplogInfo(),
+          description: `tag track ${args.name} from ${remote}`,
+          parents: [],
+          view: {
+            bookmarks: {},
+            remoteBookmarks: { [remoteTagName]: true },
+            heads: [],
+            workingCopy: workingCopy.getCurrentChangeId(),
+          },
+        });
+
+        return { name: args.name, remote, tracking: true };
+      },
+
+      /**
+       * Stop tracking a remote tag (matches `jj tag untrack`, new in jj v0.44).
+       *
+       * @param {Record<string, any>} args - Tag arguments: `{ name }`, the
+       *   local tag name to stop tracking
+       * @returns {Promise<{name: string, tracking: boolean, wasTracking: boolean}>}
+       */
+      async untrack(args) {
+        if (!args || !args.name) {
+          throw new JJError('INVALID_ARGUMENT', 'Missing tag name', {
+            suggestion: 'Provide tag name: { name: "v1.0.0" }',
+          });
+        }
+
+        const tagMap = await tags.load();
+        /** @type {Record<string, any>} */
+        const tracking = tags.tracking || {};
+        const wasTracking = tracking[args.name];
+        delete tracking[args.name];
+        tags.tracking = tracking;
+        await tags.save(tagMap);
+
+        // Record operation
+        await oplog.recordOperation({
+          timestamp: new Date().toISOString(),
+          user: await getUserOplogInfo(),
+          description: `tag untrack ${args.name}`,
+          parents: [],
+          view: {
+            bookmarks: {},
+            remoteBookmarks: {},
+            heads: [],
+            workingCopy: workingCopy.getCurrentChangeId(),
+          },
+        });
+
+        return { name: args.name, tracking: false, wasTracking: !!wasTracking };
+      },
     },
 
     /**

package/src/backend/isomorphic-git-backend.js

@@ -540,7 +540,11 @@ export class IsomorphicGitBackend {
    * @param {boolean} [opts.force] - Allow non-fast-forward
    * @param {any} [opts.onProgress] - Progress callback
    * @param {any} [opts.onAuth] - Authentication callback
-   * @returns {Promise<{pushedRefs: Array<any>, rejectedRefs: Array<any>}>} Push result
+   * @returns {Promise<{pushedRefs: Array<{name: string, oid: string}>, rejectedRefs: Array<{name: string, code: string, reason: string, message: string}>}>} Push result.
+   *   Each rejected ref carries a `code` (one of `AUTH_FAILED`,
+   *   `NETWORK_ERROR`, `NON_FAST_FORWARD`, `OTHER`) and a human-readable
+   *   `reason`, so callers can tell an auth failure apart from a
+   *   non-fast-forward rejection instead of guessing (see issue #14).
    */
   async push(opts) {
     if (!this.http) {
@@ -576,8 +580,13 @@ export class IsomorphicGitBackend {
             pushedRefs.push({ name: ref, oid });
           }
         } catch (pushError) {
-          // Track rejected refs
-          rejectedRefs.push(ref);
+          // Track rejected refs with the categorized reason so callers can
+          // distinguish an auth failure from a non-fast-forward rejection
+          // (or a network blip) instead of guessing — see issue #14. A
+          // caller that blindly retries with force:true on every rejection
+          // risks doing so on what was actually an auth/network problem.
+          const { code, reason } = this._categorizePushError(pushError);
+          rejectedRefs.push({ name: ref, code, reason, message: pushError.message });
         }
       }
 
@@ -609,6 +618,53 @@ export class IsomorphicGitBackend {
     }
   }
 
+  /**
+   * Categorize a per-ref push failure into a stable code/reason pair so
+   * callers can distinguish auth failures, network errors, and
+   * non-fast-forward rejections from each other and from other/unknown
+   * failures — see issue #14. isomorphic-git doesn't throw a single
+   * "AuthError" class; auth failures generally surface as an HttpError with
+   * a 401/403 status code (or a UserCanceledError if onAuth cancels).
+   *
+   * @private
+   * @param {any} error - Error thrown by git.push() for a single ref
+   * @returns {{code: string, reason: string}}
+   */
+  _categorizePushError(error) {
+    const errCode = error && error.code;
+
+    if (errCode === 'PushRejectedError') {
+      const reason = error.data && error.data.reason;
+      return {
+        code: 'NON_FAST_FORWARD',
+        reason: reason === 'tag-exists' ? 'tag already exists on remote' : 'non-fast-forward',
+      };
+    }
+
+    if (errCode === 'HttpError') {
+      const status = error.data && error.data.statusCode;
+      if (status === 401 || status === 403) {
+        return { code: 'AUTH_FAILED', reason: `HTTP ${status}` };
+      }
+      return { code: 'NETWORK_ERROR', reason: status ? `HTTP ${status}` : 'HTTP error' };
+    }
+
+    if (
+      errCode === 'AuthError' ||
+      errCode === 'UserCanceledError' ||
+      errCode === 'MissingUsernameError' ||
+      errCode === 'MissingPasswordTokenError'
+    ) {
+      return { code: 'AUTH_FAILED', reason: errCode };
+    }
+
+    if (errCode === 'NetworkError' || errCode === 'UnknownTransportError') {
+      return { code: 'NETWORK_ERROR', reason: errCode };
+    }
+
+    return { code: 'OTHER', reason: (error && error.message) || String(error) };
+  }
+
   /**
    * Create minimal .jj/repo structure for jj CLI compatibility
    * @private

package/src/browser/helpers.js

@@ -17,8 +17,8 @@
  *
  * @example
  * ```javascript
- * import { createBrowserFS } from 'isomorphic-jj/browser';
- * import { createJJ } from 'isomorphic-jj';
+ * import { createBrowserFS } from '@johnhenry/isomorphic-jj/browser';
+ * import { createJJ } from '@johnhenry/isomorphic-jj';
  * import git from 'isomorphic-git';
  * import http from 'isomorphic-git/http/web';
  *

package/src/core/jj-operation-store.js

@@ -8,6 +8,7 @@
 import protobuf from 'protobufjs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { atomicWriteFile } from '../utils/atomic-write.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -81,9 +82,11 @@ export class JJOperationStore {
     // Encode to binary
     const buffer = Operation.encode(message).finish();
 
-    // Write to .jj/repo/op_store/operations/OPERATIONID
+    // Write to .jj/repo/op_store/operations/OPERATIONID (atomically — a
+    // crash mid-write must never leave a truncated/undecodable file, see
+    // issue #16).
     const opPath = `${this.dir}/.jj/repo/op_store/operations/${operationId}`;
-    await this.fs.promises.writeFile(opPath, buffer);
+    await atomicWriteFile(this.fs, opPath, buffer);
   }
 
   /**

package/src/core/jj-tree-state.js

@@ -8,6 +8,7 @@
 import protobuf from 'protobufjs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { atomicWriteFile } from '../utils/atomic-write.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -72,9 +73,9 @@ export class JJTreeState {
     // Encode to binary
     const buffer = TreeState.encode(message).finish();
 
-    // Write to .jj/working_copy/tree_state
+    // Write to .jj/working_copy/tree_state (atomically — see issue #16).
     const treeStatePath = `${this.dir}/.jj/working_copy/tree_state`;
-    await this.fs.promises.writeFile(treeStatePath, buffer);
+    await atomicWriteFile(this.fs, treeStatePath, buffer);
   }
 
   /**

package/src/core/jj-view-store.js

@@ -8,6 +8,7 @@
 import protobuf from 'protobufjs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { atomicWriteFile } from '../utils/atomic-write.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -72,9 +73,9 @@ export class JJViewStore {
     // Encode to binary
     const buffer = View.encode(message).finish();
 
-    // Write to .jj/repo/op_store/views/VIEWID
+    // Write to .jj/repo/op_store/views/VIEWID (atomically — see issue #16).
     const viewPath = `${this.dir}/.jj/repo/op_store/views/${viewId}`;
-    await this.fs.promises.writeFile(viewPath, buffer);
+    await atomicWriteFile(this.fs, viewPath, buffer);
   }
 
   /**

package/src/core/revset-engine.js

@@ -312,11 +312,30 @@ class RevsetParser {
       this.next();
       const value = /** @type {string} */ (tok.value);
 
-      // A bare "base..tip" range, e.g. `abcd1234..ef567890`.
+      // `::` (bare, no operands) means "all visible changes", matching jj's
+      // `::` alias for all().
+      if (value === '::') {
+        return { type: 'rangeAll' };
+      }
+
+      // A bare "base..tip" range, e.g. `abcd1234..ef567890` — and the
+      // open-ended forms `..tip` (ancestors(tip)) and `base..` (everything
+      // not an ancestor of base, approximated here as descendants(base)).
       if (value.includes('..')) {
         const parts = value.split('..');
         if (parts.length === 2) {
-          return { type: 'range', base: parts[0].trim(), tip: parts[1].trim() };
+          const base = parts[0].trim();
+          const tip = parts[1].trim();
+          if (base === '' && tip === '') {
+            return { type: 'rangeAll' };
+          }
+          if (base === '') {
+            return { type: 'rangeAncestors', tip };
+          }
+          if (tip === '') {
+            return { type: 'rangeDescendants', base };
+          }
+          return { type: 'range', base, tip };
         }
       }
 
@@ -385,7 +404,7 @@ export class RevsetEngine {
    * @returns {string}
    */
   _suggestion() {
-    return 'Use @, @-, @+, bookmark(name), all(), none(), root(), visible_heads(), git_refs(), git_head(), ancestors(revset[, depth]), author(name), author_name(x), author_email(x), committer(x), committer_name(x), committer_email(x), subject(pattern), description(text), change_id(prefix), commit_id(prefix), empty(), mine(), merge(), merges(), forks(), signed(), divergent(), file(pattern), roots(revset), heads(revset), parents(revset), children(revset), first_parent(revset), first_ancestors(revset), fork_point(revset), merge_point(revset), exactly(revset, n), present(revset), coalesce(a, b, ...), latest(revset, [count]), tags([pattern]), remote_tags([pattern]), bookmarks([pattern]), last(N[dh]), since(date), between(start, end), descendants(rev[, depth]), common_ancestor(rev1, rev2), range(base..tip), diverge_point(rev1, rev2), connected(rev1, rev2), operators (x-, x+), set operations (& | ~), or a direct change ID';
+    return 'Use @, @-, @+, bookmark(name), all(), builtin_log(), none(), root(), visible_heads(), ancestors(revset[, depth]), author(name), author_name(x), author_email(x), committer(x), committer_name(x), committer_email(x), subject(pattern), description(text), change_id(prefix), commit_id(prefix), empty(), mine(), merge(), merges(), forks(), signed(), divergent(), file(pattern), roots(revset), heads(revset), parents(revset), children(revset), first_parent(revset), first_ancestors(revset), fork_point(revset), merge_point(revset), exactly(revset, n), present(revset), coalesce(a, b, ...), latest(revset, [count]), tags([pattern]), remote_tags([pattern]), bookmarks([pattern]), last(N[dh]), since(date), between(start, end), descendants(rev[, depth]), common_ancestor(rev1, rev2), range(base..tip), diverge_point(rev1, rev2), connected(rev1, rev2), operators (x-, x+), set operations (& | ~), or a direct change ID (git_refs()/git_head() still work but are deprecated — jj removed them in v0.43; use bookmarks()/tags()/@ instead)';
   }
 
   /**
@@ -442,6 +461,15 @@ export class RevsetEngine {
       }
       case 'range':
         return await this.evalRange(node.base, node.tip);
+      // Open-ended ranges (issue #18): `..tip` / `base..` / `::` delegate to
+      // the equivalent ancestors()/descendants()/all() functions rather than
+      // failing with a misleading "invalid IDs" error.
+      case 'rangeAll':
+        return await this.evaluateFunctionCall('all', '');
+      case 'rangeAncestors':
+        return await this.evaluateFunctionCall('ancestors', node.tip);
+      case 'rangeDescendants':
+        return await this.evaluateFunctionCall('descendants', node.base);
       case 'call':
         return await this.evaluateFunctionCall(node.name, node.argsRaw);
       default:
@@ -515,6 +543,16 @@ export class RevsetEngine {
         await this.graph.load();
         return this.graph.getAll().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
+      // defaults to `all()` when no revset is given (see `jj.log()`), so
+      // `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':
+        await this.graph.load();
+        return this.graph.getAll().map((c) => c.changeId);
+
       case 'none':
         return [];
 
@@ -545,6 +583,13 @@ export class RevsetEngine {
         return allChanges.filter((c) => !hasChildren.has(c.changeId)).map((c) => c.changeId);
       }
 
+      // `git_refs()` and `git_head()` are deprecated compatibility shims.
+      // Upstream jj deprecated both in favor of `bookmarks()`/`tags()` and
+      // `@`, then removed them outright in jj v0.43 (revset/template calls
+      // to either now error in real jj). isomorphic-jj keeps them working
+      // rather than hard-breaking existing callers, but they are no longer
+      // advertised in `_suggestion()` — prefer `bookmarks([pattern])` /
+      // `tags([pattern])` / `@` instead.
       case 'git_refs': {
         if (!this.bookmarkStore) return [];
         await this.bookmarkStore.load();