isomorphic-jj 1.7.0 → 1.8.0

package/dist/index.cjs

@@ -29,6 +29,70 @@ class JJError extends Error {
   }
 }
 
+/**
+ * Small in-process locking utilities.
+ *
+ * These provide same-process concurrency safety only — they do not protect
+ * against races between separate OS processes sharing the same on-disk
+ * repository. Cross-process locking is a separate concern (e.g. a lockfile
+ * with retry/backoff) and is intentionally out of scope here.
+ */
+
+/**
+ * A simple FIFO async mutex: `run(fn)` queues `fn` to execute only once all
+ * previously-queued work on this mutex has settled, serializing access to
+ * whatever critical section `fn` represents.
+ */
+class Mutex {
+  constructor() {
+    /** @type {Promise<any>} */
+    this._queue = Promise.resolve();
+  }
+
+  /**
+   * @template T
+   * @param {() => Promise<T>} fn
+   * @returns {Promise<T>}
+   */
+  run(fn) {
+    const result = this._queue.then(() => fn());
+    // Keep the queue moving even if `fn` rejects — a failed critical section
+    // must not permanently wedge the lock for subsequent callers.
+    this._queue = result.then(
+      () => undefined,
+      () => undefined
+    );
+    return result;
+  }
+}
+
+/**
+ * A registry of mutexes keyed by an arbitrary string (typically a file path),
+ * so unrelated paths don't contend with each other while operations on the
+ * *same* path are fully serialized.
+ */
+class KeyedMutex {
+  constructor() {
+    /** @type {Map<string, Mutex>} */
+    this._mutexes = new Map();
+  }
+
+  /**
+   * @template T
+   * @param {string} key
+   * @param {() => Promise<T>} fn
+   * @returns {Promise<T>}
+   */
+  run(key, fn) {
+    let mutex = this._mutexes.get(key);
+    if (!mutex) {
+      mutex = new Mutex();
+      this._mutexes.set(key, mutex);
+    }
+    return mutex.run(fn);
+  }
+}
+
 /**
  * Storage Manager for isomorphic-jj
  *
@@ -48,6 +112,13 @@ class Storage {
     this.repoDir = `${dir}/.jj/repo`; // Core repo data
     this.workingCopyDir = `${dir}/.jj/working_copy`; // Default workspace working copy
     this.cache = new Map();
+
+    // Serializes write()/appendLine() critical sections per path so that
+    // concurrent same-process callers (e.g. a user command racing
+    // BackgroundOps's autosnapshot) can't interleave a read-modify-write
+    // cycle and silently lose an update. This only protects callers that
+    // share this Storage instance — cross-process locking is out of scope.
+    this._locks = new KeyedMutex();
   }
 
   /**
@@ -122,8 +193,28 @@ class Storage {
    * @param {Object|string} data - Data to write (object will be stringified)
    */
   async write(path, data) {
+    return this._locks.run(path, () => this._writeLocked(path, data));
+  }
+
+  /**
+   * Unlocked implementation of write(). Only call this from within a
+   * `this._locks.run(path, ...)` critical section (directly from write()
+   * itself, or from appendLine() which holds the same path's lock already).
+   *
+   * @param {string} path - Relative path from .jj directory
+   * @param {Object|string} data - Data to write (object will be stringified)
+   */
+  async _writeLocked(path, data) {
     const fullPath = `${this.jjDir}/${path}`;
-    const tmpPath = `${fullPath}.tmp.${Date.now()}`;
+    // Random suffix (not just a millisecond timestamp) so two concurrent
+    // writes to the same path never collide on the temp filename — a
+    // collision would let one write's error-cleanup unlink() delete the
+    // other's still in-flight temp file.
+    const tmpSuffix =
+      typeof crypto !== 'undefined' && crypto.randomUUID
+        ? crypto.randomUUID()
+        : `${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+    const tmpPath = `${fullPath}.tmp.${Date.now()}.${tmpSuffix}`;
     const jsonData = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
 
     try {
@@ -193,16 +284,25 @@ class Storage {
     const fullPath = `${this.jjDir}/${path}`;
 
     try {
-      // Read existing content
-      let existing = '';
-      try {
-        existing = await this.fs.promises.readFile(fullPath, 'utf8');
-      } catch (error) {
-        if (error.code !== 'ENOENT') throw error;
-      }
+      // Hold the same per-path lock write() uses for the *entire*
+      // read-modify-write cycle (not just the write half). Without this,
+      // two concurrent appendLine() calls on the same path can both read
+      // the pre-append content, and the loser's write silently drops its
+      // line even though both calls report success.
+      await this._locks.run(path, async () => {
+        // Read existing content
+        let existing = '';
+        try {
+          existing = await this.fs.promises.readFile(fullPath, 'utf8');
+        } catch (error) {
+          if (error.code !== 'ENOENT') throw error;
+        }
 
-      // Write atomically
-      await this.write(path, existing + line + '\n');
+        // Write atomically (already inside this path's lock, so use the
+        // unlocked implementation to avoid deadlocking on a non-reentrant
+        // per-key mutex).
+        await this._writeLocked(path, existing + line + '\n');
+      });
     } catch (error) {
       throw new JJError('STORAGE_WRITE_FAILED', `Failed to append to ${path}: ${error.message}`, {
         path: fullPath,
@@ -1713,18 +1813,36 @@ class TagStore {
     this.fs = fs;
     this.jjDir = jjDir;
     this.tagsFile = `${jjDir}/store/tags.json`;
+    /**
+     * Tracking info for local tags mirrored from a remote (jj v0.44 `jj tag
+     * track`/`untrack`). Keyed by local tag name: { remote, remoteName }.
+     * @type {Record<string, any>}
+     */
+    this.tracking = {};
   }
 
   /**
-   * Loads tags from storage
+   * Loads tags (and their remote-tracking info, jj v0.44) from storage
    * @returns {Promise<Record<string, any>>} Map of tag name to changeId
    */
   async load() {
     try {
       const data = await this.fs.promises.readFile(this.tagsFile, 'utf8');
-      return JSON.parse(data);
+      const parsed = JSON.parse(data);
+
+      // v0.44: tags.json may be either the legacy flat `{ name: changeId }`
+      // map, or the newer `{ tags: {...}, tracked: {...} }` shape that also
+      // carries remote-tracking state. Support both for backward compat.
+      if (parsed && typeof parsed === 'object' && 'tags' in parsed) {
+        this.tracking = parsed.tracked || {};
+        return parsed.tags || {};
+      }
+
+      this.tracking = {};
+      return parsed || {};
     } catch (error) {
       if (error.code === 'ENOENT') {
+        this.tracking = {};
         return {};
       }
       throw error;
@@ -1732,7 +1850,7 @@ class TagStore {
   }
 
   /**
-   * Saves tags to storage
+   * Saves tags (and their remote-tracking info, jj v0.44) to storage
    * @param {Object} tags - Map of tag name to changeId
    * @returns {Promise<void>}
    */
@@ -1744,7 +1862,10 @@ class TagStore {
     } catch (err) {
       // Directory might already exist, ignore
     }
-    await this.fs.promises.writeFile(this.tagsFile, JSON.stringify(tags, null, 2));
+    await this.fs.promises.writeFile(
+      this.tagsFile,
+      JSON.stringify({ tags, tracked: this.tracking || {} }, null, 2)
+    );
   }
 
   /**
@@ -1773,9 +1894,11 @@ class TagStore {
   }
 
   /**
-   * Lists all tags, optionally filtered by pattern
+   * Lists all tags, optionally filtered by pattern. Each entry also carries
+   * a `tracking: { remote, ref }` field when the tag is tracking a remote
+   * (jj v0.44 `jj tag track`).
    * @param {string} [pattern] - Optional glob pattern
-   * @returns {Promise<Array<{name: string, changeId: string}>>}
+   * @returns {Promise<Array<Record<string, any>>>}
    */
   async list(pattern) {
     const tags = await this.load();
@@ -1786,10 +1909,17 @@ class TagStore {
       tagNames = tagNames.filter((name) => matchesPattern$1(name, pattern));
     }
 
-    return tagNames.map((name) => ({
-      name,
-      changeId: tags[name],
-    }));
+    return tagNames.map((name) => {
+      /** @type {Record<string, any>} */
+      const tag = { name, changeId: tags[name] };
+      if (this.tracking && this.tracking[name]) {
+        tag.tracking = {
+          remote: this.tracking[name].remote,
+          ref: this.tracking[name].remoteName || name,
+        };
+      }
+      return tag;
+    });
   }
 
   /**
@@ -2143,11 +2273,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 };
         }
       }
 
@@ -2216,7 +2365,7 @@ 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)';
   }
 
   /**
@@ -2273,6 +2422,15 @@ 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:
@@ -2346,6 +2504,16 @@ 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 [];
 
@@ -2376,6 +2544,13 @@ 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();
@@ -5330,6 +5505,51 @@ class JJCheckout {
   }
 }
 
+/**
+ * Shared atomic-write helper for filesystem writes.
+ *
+ * Writes content to a uniquely-named temp file, then renames it over the
+ * canonical path. A crash/error between those two steps leaves the
+ * canonical file untouched (never a truncated/partial write) — the temp
+ * file is best-effort cleaned up on failure.
+ *
+ * This mirrors the pattern `Storage.write()` (src/core/storage-manager.js)
+ * already uses for JSON stores, factored out so the protobuf-backed stores
+ * (JJOperationStore, JJViewStore, JJTreeState) can use it too instead of
+ * calling `writeFile()` directly on the canonical path — see issue #16.
+ */
+
+/**
+ * @param {any} fs - Filesystem implementation (Node fs, LightningFS, etc.)
+ * @param {string} targetPath - Canonical path to write to
+ * @param {string|Uint8Array} content - Content to write
+ */
+async function atomicWriteFile(fs, targetPath, content) {
+  const tmpSuffix =
+    typeof crypto !== 'undefined' && crypto.randomUUID
+      ? crypto.randomUUID()
+      : `${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+  const tmpPath = `${targetPath}.tmp.${Date.now()}.${tmpSuffix}`;
+
+  try {
+    const dirPath = targetPath.substring(0, targetPath.lastIndexOf('/'));
+    if (dirPath) {
+      await fs.promises.mkdir(dirPath, { recursive: true });
+    }
+
+    await fs.promises.writeFile(tmpPath, content);
+    await fs.promises.rename(tmpPath, targetPath);
+  } catch (error) {
+    try {
+      await fs.promises.unlink(tmpPath);
+    } catch {
+      // Best-effort cleanup; ignore if the temp file was never created (or
+      // is already gone).
+    }
+    throw error;
+  }
+}
+
 /**
  * JJ TreeState File Manager
  *
@@ -5401,9 +5621,9 @@ 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);
   }
 
   /**
@@ -5512,9 +5732,11 @@ 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);
   }
 
   /**
@@ -5631,9 +5853,9 @@ 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);
   }
 
   /**
@@ -6210,7 +6432,11 @@ 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) {
@@ -6246,8 +6472,13 @@ 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 });
         }
       }
 
@@ -6279,6 +6510,53 @@ 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
@@ -7544,6 +7822,11 @@ 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',
@@ -7624,6 +7907,10 @@ 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: {},
@@ -8136,11 +8423,28 @@ 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).
         }
       }
 
@@ -8383,6 +8687,21 @@ 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) {
@@ -8867,6 +9186,7 @@ async function createJJ(options) {
         // Compute the inverse changes
         const inversChanges = /** @type {Record<string, any>} */ ({
           bookmarks: {},
+          tags: {},
           heads: [],
         });
 
@@ -8906,6 +9226,46 @@ 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();
@@ -8920,6 +9280,7 @@ async function createJJ(options) {
           parents: [],
           view: {
             bookmarks: prevBookmarks,
+            tags: prevTags,
             remoteBookmarks: previousOp.view?.remoteBookmarks || {},
             heads: previousOp.view?.heads || [],
             workingCopy: previousOp.view?.workingCopy,
@@ -11357,11 +11718,18 @@ 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`;
       },
 
       /**
@@ -11448,10 +11816,17 @@ 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) {
@@ -11502,6 +11877,10 @@ async function createJJ(options) {
             }
           });
         }
+
+        if (args.nameOnly) {
+          return Array.from(new Set(results.map((r) => r.path)));
+        }
         return results;
       },
 
@@ -12583,6 +12962,10 @@ 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(),
           },
@@ -12628,6 +13011,7 @@ async function createJJ(options) {
           view: {
             bookmarks: {},
             remoteBookmarks: {},
+            tags: { [args.name]: changeId },
             heads: [],
             workingCopy: workingCopy.getCurrentChangeId(),
           },
@@ -12637,10 +13021,11 @@ 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;
@@ -12672,6 +13057,7 @@ async function createJJ(options) {
           view: {
             bookmarks: {},
             remoteBookmarks: {},
+            tags: {},
             heads: [],
             workingCopy: workingCopy.getCurrentChangeId(),
           },
@@ -12679,6 +13065,94 @@ 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 };
+      },
     },
 
     /**