isomorphic-jj 1.8.0 → 1.9.2

package/src/protos/simple_op_store.json.js

@@ -0,0 +1,374 @@
+/**
+ * Precompiled protobuf reflection JSON for simple_op_store.proto
+ *
+ * Generated from src/protos/simple_op_store.proto by scripts/build-protos.mjs. This
+ * is bundled directly (instead of loaded from a filesystem path at runtime)
+ * so that protobuf schema loading works identically in Node and in browser
+ * bundles — protobuf.load() requires filesystem/network access that does
+ * not exist in a browser bundle (see issue #28). Regenerate with:
+ *   node scripts/build-protos.mjs
+ */
+
+export default {
+  nested: {
+    simple_op_store: {
+      nested: {
+        RefConflictLegacy: {
+          fields: {
+            removes: {
+              rule: 'repeated',
+              type: 'bytes',
+              id: 1,
+              options: {
+                deprecated: true,
+              },
+            },
+            adds: {
+              rule: 'repeated',
+              type: 'bytes',
+              id: 2,
+              options: {
+                deprecated: true,
+              },
+            },
+          },
+        },
+        RefConflict: {
+          fields: {
+            removes: {
+              rule: 'repeated',
+              type: 'Term',
+              id: 1,
+            },
+            adds: {
+              rule: 'repeated',
+              type: 'Term',
+              id: 2,
+            },
+          },
+          nested: {
+            Term: {
+              oneofs: {
+                _value: {
+                  oneof: ['value'],
+                },
+              },
+              fields: {
+                value: {
+                  type: 'bytes',
+                  id: 1,
+                  options: {
+                    proto3_optional: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+        RefTarget: {
+          oneofs: {
+            value: {
+              oneof: ['commitId', 'conflictLegacy', 'conflict'],
+            },
+          },
+          fields: {
+            commitId: {
+              type: 'bytes',
+              id: 1,
+              options: {
+                deprecated: true,
+              },
+            },
+            conflictLegacy: {
+              type: 'RefConflictLegacy',
+              id: 2,
+              options: {
+                deprecated: true,
+              },
+            },
+            conflict: {
+              type: 'RefConflict',
+              id: 3,
+            },
+          },
+        },
+        RefTargetTerm: {
+          oneofs: {
+            _value: {
+              oneof: ['value'],
+            },
+          },
+          fields: {
+            value: {
+              type: 'bytes',
+              id: 1,
+              options: {
+                proto3_optional: true,
+              },
+            },
+          },
+        },
+        RemoteRefState: {
+          values: {
+            New: 0,
+            Tracked: 1,
+          },
+        },
+        RemoteBookmark: {
+          oneofs: {
+            _state: {
+              oneof: ['state'],
+            },
+          },
+          fields: {
+            remoteName: {
+              type: 'string',
+              id: 1,
+            },
+            target: {
+              type: 'RefTarget',
+              id: 2,
+            },
+            state: {
+              type: 'RemoteRefState',
+              id: 3,
+              options: {
+                proto3_optional: true,
+              },
+            },
+          },
+        },
+        Bookmark: {
+          fields: {
+            name: {
+              type: 'string',
+              id: 1,
+            },
+            localTarget: {
+              type: 'RefTarget',
+              id: 2,
+            },
+            remoteBookmarks: {
+              rule: 'repeated',
+              type: 'RemoteBookmark',
+              id: 3,
+              options: {
+                deprecated: true,
+              },
+            },
+          },
+        },
+        GitRef: {
+          fields: {
+            name: {
+              type: 'string',
+              id: 1,
+            },
+            commitId: {
+              type: 'bytes',
+              id: 2,
+              options: {
+                deprecated: true,
+              },
+            },
+            target: {
+              type: 'RefTarget',
+              id: 3,
+            },
+          },
+        },
+        RemoteRef: {
+          fields: {
+            name: {
+              type: 'string',
+              id: 1,
+            },
+            targetTerms: {
+              rule: 'repeated',
+              type: 'RefTargetTerm',
+              id: 2,
+            },
+            state: {
+              type: 'RemoteRefState',
+              id: 3,
+            },
+          },
+        },
+        Tag: {
+          fields: {
+            name: {
+              type: 'string',
+              id: 1,
+            },
+            target: {
+              type: 'RefTarget',
+              id: 2,
+            },
+          },
+        },
+        View: {
+          fields: {
+            headIds: {
+              rule: 'repeated',
+              type: 'bytes',
+              id: 1,
+            },
+            wcCommitId: {
+              type: 'bytes',
+              id: 2,
+              options: {
+                deprecated: true,
+              },
+            },
+            wcCommitIds: {
+              keyType: 'string',
+              type: 'bytes',
+              id: 8,
+            },
+            bookmarks: {
+              rule: 'repeated',
+              type: 'Bookmark',
+              id: 5,
+            },
+            localTags: {
+              rule: 'repeated',
+              type: 'Tag',
+              id: 6,
+            },
+            remoteViews: {
+              rule: 'repeated',
+              type: 'RemoteView',
+              id: 11,
+            },
+            gitRefs: {
+              rule: 'repeated',
+              type: 'GitRef',
+              id: 3,
+            },
+            gitHeadLegacy: {
+              type: 'bytes',
+              id: 7,
+              options: {
+                deprecated: true,
+              },
+            },
+            gitHead: {
+              type: 'RefTarget',
+              id: 9,
+            },
+            hasGitRefsMigratedToRemoteTags: {
+              type: 'bool',
+              id: 12,
+            },
+          },
+          reserved: [
+            [4, 4],
+            [10, 10],
+          ],
+        },
+        RemoteView: {
+          fields: {
+            name: {
+              type: 'string',
+              id: 1,
+            },
+            bookmarks: {
+              rule: 'repeated',
+              type: 'RemoteRef',
+              id: 2,
+            },
+            tags: {
+              rule: 'repeated',
+              type: 'RemoteRef',
+              id: 3,
+            },
+          },
+        },
+        Operation: {
+          fields: {
+            viewId: {
+              type: 'bytes',
+              id: 1,
+            },
+            parents: {
+              rule: 'repeated',
+              type: 'bytes',
+              id: 2,
+            },
+            metadata: {
+              type: 'OperationMetadata',
+              id: 3,
+            },
+            commitPredecessors: {
+              rule: 'repeated',
+              type: 'CommitPredecessors',
+              id: 4,
+            },
+            storesCommitPredecessors: {
+              type: 'bool',
+              id: 5,
+            },
+          },
+        },
+        Timestamp: {
+          fields: {
+            millisSinceEpoch: {
+              type: 'int64',
+              id: 1,
+            },
+            tzOffset: {
+              type: 'int32',
+              id: 2,
+            },
+          },
+        },
+        OperationMetadata: {
+          fields: {
+            startTime: {
+              type: 'Timestamp',
+              id: 1,
+            },
+            endTime: {
+              type: 'Timestamp',
+              id: 2,
+            },
+            description: {
+              type: 'string',
+              id: 3,
+            },
+            hostname: {
+              type: 'string',
+              id: 4,
+            },
+            username: {
+              type: 'string',
+              id: 5,
+            },
+            isSnapshot: {
+              type: 'bool',
+              id: 7,
+            },
+            tags: {
+              keyType: 'string',
+              type: 'string',
+              id: 6,
+            },
+          },
+        },
+        CommitPredecessors: {
+          fields: {
+            commitId: {
+              type: 'bytes',
+              id: 1,
+            },
+            predecessorIds: {
+              rule: 'repeated',
+              type: 'bytes',
+              id: 2,
+            },
+          },
+        },
+      },
+    },
+  },
+};

package/src/types.d.ts

@@ -481,6 +481,26 @@ export interface UnabandonArgs {
   changeId: ChangeID;
 }
 
+/**
+ * Converge (auto-resolve divergent copies) arguments
+ */
+export interface ConvergeArgs {
+  changeId: ChangeID;
+}
+
+/**
+ * Converge result
+ */
+export interface ConvergeResult {
+  changeId: ChangeID;
+  /** Whether the divergent copies were successfully merged into one. */
+  resolved: boolean;
+  /** Per-path conflicts found — non-empty only when `resolved` is false. */
+  conflicts: Conflict[];
+  /** The resulting commit id, present only when `resolved` is true. */
+  commitId?: string;
+}
+
 /**
  * Log query options
  */
@@ -1064,6 +1084,19 @@ export interface JJ {
   unabandon(args: UnabandonArgs): Promise<void>;
   absorb(args?: AbsorbArgs): Promise<AbsorbResult>;
 
+  /**
+   * Auto-resolve divergent copies of a change — multiple visible commits
+   * sharing one change id (see the `divergent()` revset) — by three-way
+   * merging them (matches `jj converge`, jj v0.45.0).
+   *
+   * A genuine per-path conflict is reported as data (`resolved: false`),
+   * matching merge()'s own convention, rather than thrown. Throws when
+   * there's nothing to converge, or when more than two visible copies
+   * exist (automatic resolution only attempts a pairwise merge — matches
+   * real jj aborting non-interactive resolution it can't disambiguate).
+   */
+  converge(args: ConvergeArgs | ChangeID): Promise<ConvergeResult>;
+
   /**
    * Create a change that reverses another change (matches `jj revert`, v1.5).
    * Canonical replacement for the deprecated `backout()`.

package/src/utils/atomic-write.js

@@ -12,6 +12,8 @@
  * calling `writeFile()` directly on the canonical path — see issue #16.
  */
 
+import { mkdirp } from './mkdirp.js';
+
 /**
  * @param {any} fs - Filesystem implementation (Node fs, LightningFS, etc.)
  * @param {string} targetPath - Canonical path to write to
@@ -27,7 +29,7 @@ export async function atomicWriteFile(fs, targetPath, content) {
   try {
     const dirPath = targetPath.substring(0, targetPath.lastIndexOf('/'));
     if (dirPath) {
-      await fs.promises.mkdir(dirPath, { recursive: true });
+      await mkdirp(fs, dirPath);
     }
 
     await fs.promises.writeFile(tmpPath, content);

package/src/utils/bytes.js

@@ -0,0 +1,67 @@
+/**
+ * Cross-environment byte/string conversion helpers.
+ *
+ * Why not just Node's `Buffer`: it's a Node global that most browser
+ * bundlers (Vite, esbuild, webpack 5+) do not polyfill by default, so code
+ * that calls `Buffer.from(...)` compiles fine but throws `ReferenceError:
+ * Buffer is not defined` at runtime in a browser bundle (see issue #28).
+ *
+ * `utf8Encode`/`utf8Decode` still prefer the real `Buffer` when it's present
+ * (i.e. under Node) so existing behavior — including `.toString()` producing
+ * the original text back, which a plain `Uint8Array` cannot do — is
+ * unchanged there; `typeof Buffer` is safe to evaluate even where `Buffer`
+ * was never declared (unlike referencing it directly), so this doesn't
+ * reintroduce the crash outside Node. `hexToBytes`/`bytesToHex`/`isBytes`
+ * only ever need `Uint8Array`, so they don't need the same branch.
+ */
+const hasBuffer = typeof Buffer !== 'undefined';
+
+/**
+ * @param {string} hex - Even-length hex string
+ * @returns {Uint8Array}
+ */
+export function hexToBytes(hex) {
+  const length = hex.length / 2;
+  const bytes = new Uint8Array(length);
+  for (let i = 0; i < length; i++) {
+    bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {string} Lowercase hex string
+ */
+export function bytesToHex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+}
+
+/**
+ * @param {string} str
+ * @returns {Uint8Array} UTF-8 encoded bytes (a real `Buffer` under Node)
+ */
+export function utf8Encode(str) {
+  return hasBuffer ? Buffer.from(str, 'utf-8') : new TextEncoder().encode(str);
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {string} UTF-8 decoded string
+ */
+export function utf8Decode(bytes) {
+  return hasBuffer ? Buffer.from(bytes).toString('utf-8') : new TextDecoder('utf-8').decode(bytes);
+}
+
+/**
+ * True for anything that walks/quacks like binary content — a real Node
+ * `Buffer` (which is itself a `Uint8Array` subclass) or a plain
+ * `Uint8Array`/typed array, as produced by protobufjs in environments
+ * without `Buffer` (e.g. a browser bundle).
+ *
+ * @param {any} value
+ * @returns {boolean}
+ */
+export function isBytes(value) {
+  return value instanceof Uint8Array;
+}

package/src/utils/id-generation.js

@@ -4,6 +4,22 @@
  * Generates stable change IDs and operation IDs using cryptographically secure random values.
  */
 
+/**
+ * Generate `byteLength` cryptographically random bytes as a lowercase hex string.
+ *
+ * Uses the standard Web Crypto API (`crypto.getRandomValues`), available as
+ * a global in both Node.js (18.14+) and every browser — unlike Node's
+ * `crypto.randomBytes`, which requires `import 'crypto'` and does not exist
+ * in a browser bundle (see issue #28).
+ *
+ * @param {number} byteLength - Number of random bytes to generate
+ * @returns {string} `byteLength * 2`-character lowercase hex string
+ */
+export function randomHex(byteLength) {
+  const bytes = crypto.getRandomValues(new Uint8Array(byteLength));
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+}
+
 /**
  * Generate a stable change ID
  *
@@ -13,8 +29,7 @@
  * @returns {string} 32-character lowercase hex string
  */
 export function generateChangeId() {
-  const bytes = crypto.getRandomValues(new Uint8Array(16));
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+  return randomHex(16);
 }
 
 /**
@@ -48,7 +63,6 @@ export async function generateOperationId(operation) {
  * @returns {string} ID string
  */
 export function generateId(prefix = '') {
-  const bytes = crypto.getRandomValues(new Uint8Array(16));
-  const id = Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+  const id = randomHex(16);
   return prefix ? `${prefix}-${id}` : id;
 }

package/src/utils/mkdirp.js

@@ -0,0 +1,41 @@
+/**
+ * Recursive directory creation that works across filesystem backends.
+ *
+ * Why not `fs.promises.mkdir(path, { recursive: true })`: that's a Node
+ * `fs` feature. `@isomorphic-git/lightning-fs` (the filesystem this library
+ * documents for browser use — see issue #28) implements `mkdir()` but
+ * silently ignores the `recursive` option and throws `ENOENT` if any
+ * intermediate directory is missing, so code that assumed Node's recursive
+ * mkdir semantics would work identically against LightningFS actually
+ * broke the very first real repo init in a browser. This walks the path
+ * one segment at a time and creates each directory that doesn't exist yet,
+ * which is correct against both Node's `fs` and LightningFS (and is a
+ * harmless no-op-per-segment against Node's `fs` too).
+ *
+ * @param {any} fs - Filesystem implementation (isomorphic-git compatible;
+ *   needs `fs.promises.mkdir(path)`)
+ * @param {string} dirPath - Absolute, POSIX-style directory path to create
+ * @returns {Promise<void>}
+ */
+export async function mkdirp(fs, dirPath) {
+  const isAbsolute = dirPath.charCodeAt(0) === 47; // '/'
+  const prefix = isAbsolute ? '/' : '';
+  const segments = dirPath.split('/').filter(Boolean);
+
+  // Compare against `current === ''` (not a truthiness check) below: the
+  // first accumulated segment of an absolute path is itself just `/x`,
+  // which parses fine, but a naive `current ? ... : ...` truthiness check
+  // would treat the *string* `''` the same as "unset" forever and never
+  // prepend the leading `/`.
+  let current = '';
+  for (const segment of segments) {
+    current = current === '' ? prefix + segment : `${current}/${segment}`;
+    try {
+      await fs.promises.mkdir(current);
+    } catch (err) {
+      // Already exists — fine, that's exactly what "recursive" means.
+      if (err && (err.code === 'EEXIST' || err.code === 'EISDIR')) continue;
+      throw err;
+    }
+  }
+}

package/src/utils/posix-path.js

@@ -0,0 +1,117 @@
+/**
+ * Minimal POSIX-only path utilities (join / dirname / resolve).
+ *
+ * Why not Node's `path` module: this library is isomorphic — it also needs
+ * to run in browser bundles (see issue #28), where bare `import path from
+ * 'path'` fails unless a bundler-specific polyfill is configured. Git/jj
+ * repository paths are always POSIX-style (forward slashes), regardless of
+ * host OS, so depending on Node's `path` module was also subtly wrong on
+ * Windows: `path.join()` there uses `path.win32` semantics and would
+ * produce backslash-joined paths for repository-relative paths, which is
+ * not what git/jj object storage or working-copy paths want.
+ *
+ * These implement the same normalization rules as Node's `path.posix` for
+ * the operations this codebase actually uses.
+ */
+
+/**
+ * @param {string} path
+ * @returns {string} `path` with any run of `/` collapsed to a single `/`,
+ *   and `.`/`..` segments resolved. Preserves a leading `/` (absolute) and
+ *   a trailing `/` when present in the input.
+ */
+function normalize(path) {
+  if (path === '') return '.';
+
+  const isAbsolute = path.charCodeAt(0) === 47; // '/'
+  const trailingSlash = path.charCodeAt(path.length - 1) === 47;
+
+  const segments = path.split('/');
+  /** @type {string[]} */
+  const out = [];
+  for (const segment of segments) {
+    if (segment === '' || segment === '.') continue;
+    if (segment === '..') {
+      if (out.length && out[out.length - 1] !== '..') {
+        out.pop();
+      } else if (!isAbsolute) {
+        out.push('..');
+      }
+      continue;
+    }
+    out.push(segment);
+  }
+
+  let result = out.join('/');
+  if (!result && !isAbsolute) result = '.';
+  if (isAbsolute) result = '/' + result;
+  if (trailingSlash && result.charCodeAt(result.length - 1) !== 47) result += '/';
+  return result;
+}
+
+/**
+ * @param {...string} parts
+ * @returns {string} All `parts` joined with `/` and normalized.
+ */
+export function join(...parts) {
+  if (parts.length === 0) return '.';
+  const joined = parts.filter((p) => p !== '').join('/');
+  return joined === '' ? '.' : normalize(joined);
+}
+
+/**
+ * @param {string} path
+ * @returns {string} The directory portion of `path` (Node `path.dirname` semantics).
+ */
+export function dirname(path) {
+  if (path.length === 0) return '.';
+  const isAbsolute = path.charCodeAt(0) === 47;
+  let end = -1;
+  let matchedSlash = true;
+  for (let i = path.length - 1; i >= 1; i--) {
+    if (path.charCodeAt(i) === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else {
+      matchedSlash = false;
+    }
+  }
+
+  if (end === -1) return isAbsolute ? '/' : '.';
+  if (isAbsolute && end === 0) return '/';
+  return path.slice(0, end);
+}
+
+/**
+ * Resolves a sequence of path segments into an absolute path.
+ *
+ * Unlike Node's `path.resolve`, this never consults the real process cwd —
+ * segments are resolved right-to-left, and if no absolute segment is found
+ * the result is left relative to a virtual `/` root (this library always
+ * deals in absolute repository-relative paths, so callers are expected to
+ * supply an absolute base).
+ *
+ * @param {...string} parts
+ * @returns {string}
+ */
+export function resolve(...parts) {
+  let resolved = '';
+  let isAbsolute = false;
+
+  for (let i = parts.length - 1; i >= -1 && !isAbsolute; i--) {
+    const path = i >= 0 ? parts[i] : '/';
+    if (path.length === 0) continue;
+    resolved = path + '/' + resolved;
+    isAbsolute = path.charCodeAt(0) === 47;
+  }
+
+  resolved = normalize(resolved);
+  // normalize() preserves a trailing slash; path.resolve() never returns one
+  // (except for the root itself).
+  if (resolved.length > 1 && resolved.endsWith('/')) {
+    resolved = resolved.slice(0, -1);
+  }
+  return isAbsolute ? resolved : '/' + resolved;
+}