isomorphic-jj 1.8.0 → 1.9.2

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

@@ -11,7 +11,8 @@ import { JJCheckout } from '../core/jj-checkout.js';
 import { JJTreeState } from '../core/jj-tree-state.js';
 import { JJOperationStore } from '../core/jj-operation-store.js';
 import { JJViewStore } from '../core/jj-view-store.js';
-import crypto from 'crypto';
+import { randomHex } from '../utils/id-generation.js';
+import { mkdirp } from '../utils/mkdirp.js';
 
 /**
  * Backend adapter for isomorphic-git
@@ -674,14 +675,14 @@ export class IsomorphicGitBackend {
     const jjRepo = `${jjDir}/repo`;
 
     // Create directory structure
-    await this.fs.promises.mkdir(`${jjRepo}/store`, { recursive: true });
-    await this.fs.promises.mkdir(`${jjRepo}/store/extra/heads`, { recursive: true });
-    await this.fs.promises.mkdir(`${jjRepo}/op_store/operations`, { recursive: true });
-    await this.fs.promises.mkdir(`${jjRepo}/op_store/views`, { recursive: true });
-    await this.fs.promises.mkdir(`${jjRepo}/op_heads/heads`, { recursive: true });
-    await this.fs.promises.mkdir(`${jjRepo}/index`, { recursive: true });
-    await this.fs.promises.mkdir(`${jjRepo}/submodule_store`, { recursive: true });
-    await this.fs.promises.mkdir(`${jjDir}/working_copy`, { recursive: true });
+    await mkdirp(this.fs, `${jjRepo}/store`);
+    await mkdirp(this.fs, `${jjRepo}/store/extra/heads`);
+    await mkdirp(this.fs, `${jjRepo}/op_store/operations`);
+    await mkdirp(this.fs, `${jjRepo}/op_store/views`);
+    await mkdirp(this.fs, `${jjRepo}/op_heads/heads`);
+    await mkdirp(this.fs, `${jjRepo}/index`);
+    await mkdirp(this.fs, `${jjRepo}/submodule_store`);
+    await mkdirp(this.fs, `${jjDir}/working_copy`);
 
     // Write type files
     await this.fs.promises.writeFile(`${jjRepo}/store/type`, 'git');
@@ -708,8 +709,8 @@ export class IsomorphicGitBackend {
    */
   async _createInitialJJState() {
     // Generate unique IDs for initial state
-    const operationId = crypto.randomBytes(64).toString('hex'); // 512-bit = 128 hex chars
-    const viewId = crypto.randomBytes(64).toString('hex');
+    const operationId = randomHex(64); // 512-bit = 128 hex chars
+    const viewId = randomHex(64);
     const emptyTreeId = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'; // Git's empty tree hash
 
     // Get the initial commit from Git
@@ -721,7 +722,7 @@ export class IsomorphicGitBackend {
         ref: 'HEAD',
       });
       if (headOid) {
-        initialCommitId = crypto.randomBytes(64).toString('hex');
+        initialCommitId = randomHex(64);
       }
     } catch (error) {
       // No initial commit yet

package/src/browser/helpers.js

@@ -5,15 +5,21 @@
  */
 
 /**
- * Create a browser-compatible filesystem using LightningFS
+ * Create a browser-compatible filesystem, defaulting to LightningFS.
  *
- * Requires: @isomorphic-git/lightning-fs
+ * Requires (unless `opts.fs` is supplied): @isomorphic-git/lightning-fs
  *
- * @param {Object} opts - Options
+ * @param {Object} [opts] - Options
  * @param {string} [opts.backend='idb'] - Storage backend ('idb' or 'memory')
  * @param {string} [opts.name='jj'] - Database name for IndexedDB
  * @param {boolean} [opts.wipe=false] - Wipe existing data
- * @returns {Object} LightningFS instance
+ * @param {any} [opts.fs] - Bring your own filesystem instead of the default
+ *   LightningFS auto-import. Pass either an already-constructed
+ *   isomorphic-git-compatible fs (e.g. a `memfs` volume, or your own
+ *   LightningFS instance) — returned as-is — or a constructor with the
+ *   LightningFS signature (`new Ctor(name, { wipe })`), which is
+ *   instantiated the same way the default LightningFS would be.
+ * @returns {Promise<Object>} Filesystem instance compatible with isomorphic-git
  *
  * @example
  * ```javascript
@@ -22,7 +28,7 @@
  * import git from 'isomorphic-git';
  * import http from 'isomorphic-git/http/web';
  *
- * const fs = createBrowserFS({ backend: 'idb', name: 'my-repo' });
+ * const fs = await createBrowserFS({ backend: 'idb', name: 'my-repo' });
  * const jj = await createJJ({
  *   fs,
  *   dir: '/repo',
@@ -30,24 +36,36 @@
  *   http
  * });
  * ```
+ *
+ * @example Bring your own fs (e.g. memfs)
+ * ```javascript
+ * import { fs as memfs } from 'memfs';
+ * const fs = await createBrowserFS({ fs: memfs });
+ * ```
  */
-export function createBrowserFS(opts = {}) {
+export async function createBrowserFS(opts = {}) {
   // Check if we're in a browser environment
   if (typeof window === 'undefined') {
     throw new Error('createBrowserFS() should only be used in browser environments');
   }
 
-  // Dynamic import to avoid issues in Node.js
-  // Users must install @isomorphic-git/lightning-fs separately
-  try {
-    // This will be resolved by the bundler
-    const LightningFS = require('@isomorphic-git/lightning-fs');
-
-    const fs = new LightningFS(opts.name || 'jj', {
-      wipe: opts.wipe || false,
-    });
+  // Caller supplied their own filesystem — use it directly instead of
+  // pulling in LightningFS at all.
+  if (opts.fs) {
+    if (typeof opts.fs === 'function') {
+      return new opts.fs(opts.name || 'jj', { wipe: opts.wipe || false });
+    }
+    return opts.fs;
+  }
 
-    return fs;
+  // Dynamic `import()` (not `require`) so this resolves in an ESM browser
+  // bundle — `require` does not exist there (see issue #28). Users must
+  // install @isomorphic-git/lightning-fs separately; it's an optional
+  // peer/dev dependency of this package.
+  let LightningFS;
+  try {
+    const mod = await import('@isomorphic-git/lightning-fs');
+    LightningFS = mod.default ?? mod;
   } catch (error) {
     throw new Error(
       'LightningFS not found. Install it with: npm install @isomorphic-git/lightning-fs\n' +
@@ -55,6 +73,10 @@ export function createBrowserFS(opts = {}) {
         error.message
     );
   }
+
+  return new LightningFS(opts.name || 'jj', {
+    wipe: opts.wipe || false,
+  });
 }
 
 /**

package/src/browser/index.d.ts

@@ -14,6 +14,13 @@ export interface BrowserFSOptions {
   name?: string;
   /** Wipe existing data on initialization */
   wipe?: boolean;
+  /**
+   * Bring your own filesystem instead of the default LightningFS
+   * auto-import. Pass either an already-constructed isomorphic-git
+   * compatible fs (returned as-is) or a LightningFS-shaped constructor
+   * (`new Ctor(name, { wipe })`).
+   */
+  fs?: any;
 }
 
 /**
@@ -99,11 +106,11 @@ export interface ServiceWorkerUtils {
  * import git from 'isomorphic-git';
  * import http from 'isomorphic-git/http/web';
  *
- * const fs = createBrowserFS({ backend: 'idb', name: 'my-repo' });
+ * const fs = await createBrowserFS({ backend: 'idb', name: 'my-repo' });
  * const jj = await createJJ({ fs, dir: '/repo', git, http });
  * ```
  */
-export function createBrowserFS(opts?: BrowserFSOptions): any;
+export function createBrowserFS(opts?: BrowserFSOptions): Promise<any>;
 
 /**
  * Get storage quota information (browser only)

package/src/core/change-graph.js

@@ -6,6 +6,7 @@
 
 import { JJError } from '../utils/errors.js';
 import { validateChangeId } from '../utils/validation.js';
+import { randomHex } from '../utils/id-generation.js';
 
 export class ChangeGraph {
   /**
@@ -95,6 +96,68 @@ export class ChangeGraph {
     await this.save();
   }
 
+  /**
+   * Add a DIVERGENT copy of an existing change: another commit that also
+   * claims `change.changeId` (see issue #32 / the `divergent()` revset —
+   * "multiple visible commits sharing one change id"). `addChange()`
+   * can't represent this: `nodes` is a `Map<changeId, change>`, one entry
+   * per key, by design — every other API (getChange, getParents,
+   * getChildren, ...) keys on plain changeId and would be ambiguous if
+   * that stopped being unique.
+   *
+   * Divergent copies are therefore stored under a synthetic internal key
+   * (`${changeId}\0${commitId}`) so the `nodes` Map stays a true map, but
+   * each copy's *own* `changeId` field is unchanged — so `getAll()` (and
+   * therefore the existing `divergent()` revset filter, which counts
+   * occurrences of `c.changeId` across `getAll()`) sees both/all of them
+   * and correctly reports the change as divergent. `getChange(changeId)`
+   * deliberately keeps resolving to just the primary copy (the one
+   * actually stored under the plain `changeId` key) — for anything that
+   * needs every copy, see getDivergentSiblings().
+   *
+   * @param {Record<string, any>} change - The divergent copy (must have
+   *   the same `changeId` as an existing change, and its own `commitId`)
+   */
+  async addDivergentCopy(change) {
+    validateChangeId(change.changeId);
+
+    if (!this.nodes.has(change.changeId)) {
+      throw new JJError(
+        'CHANGE_NOT_FOUND',
+        `Cannot add a divergent copy of ${change.changeId}: no existing change with that id`,
+        { changeId: change.changeId, suggestion: 'Use addChange() to create the first copy' }
+      );
+    }
+
+    const key = `${change.changeId}\0${change.commitId}`;
+    if (this.nodes.has(key)) {
+      throw new JJError(
+        'CHANGE_EXISTS',
+        `Change ${change.changeId} already has a divergent copy with commit ${change.commitId}`,
+        { changeId: change.changeId, commitId: change.commitId }
+      );
+    }
+
+    change.divergent = true;
+    this.nodes.set(key, change);
+    this.commitIndex.set(change.commitId, change.changeId);
+
+    await this.save();
+  }
+
+  /**
+   * Get every visible copy of a (possibly divergent) change id — just the
+   * one copy in the common case, or the primary plus every divergent copy
+   * added via addDivergentCopy().
+   *
+   * @param {string} changeId - Change ID
+   * @returns {Array<any>} All copies sharing this changeId, primary first
+   */
+  getDivergentSiblings(changeId) {
+    validateChangeId(changeId);
+    return this.getAll().filter((change) => change.changeId === changeId);
+  }
+
   /**
    * Get a change by ID
    *
@@ -206,6 +269,65 @@ export class ChangeGraph {
     await this.save();
   }
 
+  /**
+   * Remove one divergent copy added via addDivergentCopy() — e.g. after
+   * converge() (issue #32) resolves a divergence and only needs to drop
+   * the now-superseded copy. The *primary* copy (stored under the plain
+   * `changeId` key) is never touched by this — use deleteChange() (or
+   * updateChange() to overwrite it with a resolved result) for that.
+   *
+   * @param {string} changeId
+   * @param {string} commitId - The divergent copy's own commit id
+   * @returns {Promise<boolean>} Whether a copy was actually removed
+   */
+  async deleteDivergentCopy(changeId, commitId) {
+    validateChangeId(changeId);
+
+    const key = `${changeId}\0${commitId}`;
+    const change = this.nodes.get(key);
+    if (!change) {
+      return false;
+    }
+
+    this.nodes.delete(key);
+    if (this.commitIndex.get(commitId) === changeId) {
+      this.commitIndex.delete(commitId);
+    }
+
+    await this.save();
+    return true;
+  }
+
+  /**
+   * Remove a change from the graph outright.
+   *
+   * Used to reverse an addChange() — e.g. undoing an operation that created
+   * a change (new(), or squash()'s synthetic empty working-copy change) —
+   * where restoring a "before" snapshot doesn't apply because there was no
+   * "before": the change simply didn't exist yet. A soft-delete (setting
+   * `abandoned: true` via updateChange()) is NOT the same thing and is used
+   * separately for abandon() itself.
+   *
+   * @param {string} changeId - Change ID to remove
+   * @returns {Promise<boolean>} Whether a change was actually removed
+   */
+  async deleteChange(changeId) {
+    validateChangeId(changeId);
+
+    const change = this.nodes.get(changeId);
+    if (!change) {
+      return false;
+    }
+
+    this.nodes.delete(changeId);
+    if (this.commitIndex.get(change.commitId) === changeId) {
+      this.commitIndex.delete(change.commitId);
+    }
+
+    await this.save();
+    return true;
+  }
+
   /**
    * Get all ancestors of a change (recursive parent traversal)
    *
@@ -243,10 +365,9 @@ export class ChangeGraph {
    * @returns {Promise<Record<string, any>>} Created change object
    */
   async createChange(params = {}) {
-    const crypto = await import('crypto');
-    const changeId = params.changeId || crypto.randomBytes(16).toString('hex');
-    const commitId = params.commitId || crypto.randomBytes(20).toString('hex');
-    const tree = params.tree || crypto.randomBytes(20).toString('hex');
+    const changeId = params.changeId || randomHex(16);
+    const commitId = params.commitId || randomHex(20);
+    const tree = params.tree || randomHex(20);
     const timestamp = params.timestamp || new Date().toISOString();
 
     /** @type {Record<string, any>} */

package/src/core/conflict-model.js

@@ -10,9 +10,11 @@
  * This matches JJ's philosophy: conflicts never block you.
  */
 
-import path from 'path';
+import * as path from '../utils/posix-path.js';
 import { JJError } from '../utils/errors.js';
+import { isBytes } from '../utils/bytes.js';
 import { generateId } from '../utils/id-generation.js';
+import { mkdirp } from '../utils/mkdirp.js';
 
 /**
  * Conflict types supported by JJ
@@ -174,6 +176,15 @@ export class ConflictModel {
       const conflict = this._detectPathConflict(path, baseContent, leftContent, rightContent);
       if (conflict) {
         conflicts.push(conflict);
+      } else if (workingCopyDir) {
+        // No conflict, but "no conflict" doesn't mean "nothing to do": of
+        // _detectPathConflict's null-returning cases, every one *except*
+        // "right side changed, left didn't" already matches what's on disk,
+        // because `leftContent` **is** what's on disk (read straight from
+        // the working copy above) -- so only that one case needs a write.
+        if (baseContent === leftContent && baseContent !== rightContent) {
+          await this._applyCleanResolution(workingCopyDir, path, rightContent);
+        }
       }
     }
 
@@ -261,6 +272,30 @@ export class ConflictModel {
     return null;
   }
 
+  /**
+   * Create a content conflict with more than two disagreeing versions —
+   * every other conflict in this module has exactly two sides (`left`/
+   * `right`, or `left`/`right` on an add-add), because every OTHER caller
+   * (merge, rebase) only ever three-way-merges two changes at a time.
+   * converge() (issue #32) can face more than two divergent copies of one
+   * change in a single call, so `sides` here is `{ base, versions }`
+   * instead: `versions` is every distinct value found across all copies
+   * that differs from `base`, each paired with (one of) the commitId(s)
+   * that has it.
+   *
+   * @param {string} path
+   * @param {any} base
+   * @param {Array<{commitId: string, content: any}>} versions
+   */
+  createNWayConflict(path, base, versions) {
+    return this._createConflict({
+      type: ConflictType.CONTENT,
+      path,
+      sides: { base, versions },
+      message: `${versions.length} divergent copies disagree on this file's content`,
+    });
+  }
+
   /**
    * Create a conflict object
    *
@@ -504,6 +539,36 @@ export class ConflictModel {
     return result;
   }
 
+  /**
+   * Apply a clean (non-conflicting) three-way resolution to the working
+   * copy, for the default (no merge driver) path in detectConflicts(): the
+   * "right side wins" case, where the resolved content differs from what's
+   * currently on disk (see the call site for why this is the only clean
+   * case that needs one).
+   *
+   * @param {string} workingCopyDir - Working copy directory
+   * @param {string} filePath - File path
+   * @param {any} content - The winning (right) side's content, or
+   *   `undefined` to mean the file was deleted on that side
+   */
+  async _applyCleanResolution(workingCopyDir, filePath, content) {
+    const fullPath = path.join(workingCopyDir, filePath);
+
+    if (content === undefined) {
+      await this.fs.promises.unlink(fullPath).catch(() => {});
+      return;
+    }
+
+    const dir = path.dirname(fullPath);
+    await mkdirp(this.fs, dir);
+
+    if (isBytes(content)) {
+      await this.fs.promises.writeFile(fullPath, content);
+    } else {
+      await this.fs.promises.writeFile(fullPath, content, 'utf8');
+    }
+  }
+
   /**
    * Write merge driver result to working copy (v0.5)
    *
@@ -516,14 +581,14 @@ export class ConflictModel {
 
     // Ensure directory exists
     const dir = path.dirname(fullPath);
-    await this.fs.promises.mkdir(dir, { recursive: true });
+    await mkdirp(this.fs, dir);
 
     // Write main file
     if (result.content !== null && result.content !== undefined) {
-      if (Buffer.isBuffer(result.content)) {
+      if (isBytes(result.content)) {
         await this.fs.promises.writeFile(fullPath, result.content);
       } else {
-        await this.fs.promises.writeFile(fullPath, result.content, 'utf-8');
+        await this.fs.promises.writeFile(fullPath, result.content, 'utf8');
       }
     }
 
@@ -532,12 +597,12 @@ export class ConflictModel {
       for (const [additionalPath, additionalContent] of Object.entries(result.additionalFiles)) {
         const additionalFullPath = path.join(workingCopyDir, additionalPath);
         const additionalDir = path.dirname(additionalFullPath);
-        await this.fs.promises.mkdir(additionalDir, { recursive: true });
+        await mkdirp(this.fs, additionalDir);
 
-        if (Buffer.isBuffer(additionalContent)) {
+        if (isBytes(additionalContent)) {
           await this.fs.promises.writeFile(additionalFullPath, additionalContent);
         } else {
-          await this.fs.promises.writeFile(additionalFullPath, additionalContent, 'utf-8');
+          await this.fs.promises.writeFile(additionalFullPath, additionalContent, 'utf8');
         }
       }
     }

package/src/core/jj-checkout.js

@@ -5,18 +5,8 @@
  * This file tracks which operation the working copy is at.
  */
 
-import protobuf from 'protobufjs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Determine proto path based on whether we're running from dist or src
-const inDist = __dirname.includes('/dist') || __dirname.includes('\\dist');
-const protoDir = inDist
-  ? path.join(__dirname, '..', 'src', 'protos')
-  : path.join(__dirname, '..', 'protos');
+import { getLocalWorkingCopyRoot } from '../protos/schema.js';
+import { hexToBytes } from '../utils/bytes.js';
 
 export class JJCheckout {
   /**
@@ -26,7 +16,6 @@ export class JJCheckout {
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
-    this.protoPath = path.join(protoDir, 'local_working_copy.proto');
   }
 
   /**
@@ -37,11 +26,11 @@ export class JJCheckout {
    */
   async writeCheckout(operationId, workspaceName = 'default') {
     // Load protobuf schema
-    const root = await protobuf.load(this.protoPath);
+    const root = getLocalWorkingCopyRoot();
     const Checkout = root.lookupType('local_working_copy.Checkout');
 
     // Convert hex operation ID to bytes
-    const opIdBuffer = Buffer.from(operationId, 'hex');
+    const opIdBuffer = hexToBytes(operationId);
 
     // Create message (use camelCase for protobufjs)
     const message = Checkout.create({
@@ -73,7 +62,7 @@ export class JJCheckout {
     const buffer = await this.fs.promises.readFile(checkoutPath);
 
     // Load protobuf schema
-    const root = await protobuf.load(this.protoPath);
+    const root = getLocalWorkingCopyRoot();
     const Checkout = root.lookupType('local_working_copy.Checkout');
 
     // Decode

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

@@ -5,19 +5,9 @@
  * Operations track the history of changes to the repository.
  */
 
-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);
-
-// Determine proto path based on whether we're running from dist or src
-const inDist = __dirname.includes('/dist') || __dirname.includes('\\dist');
-const protoDir = inDist
-  ? path.join(__dirname, '..', 'src', 'protos')
-  : path.join(__dirname, '..', 'protos');
+import { getSimpleOpStoreRoot } from '../protos/schema.js';
+import { hexToBytes } from '../utils/bytes.js';
 
 export class JJOperationStore {
   /**
@@ -27,7 +17,6 @@ export class JJOperationStore {
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
-    this.protoPath = path.join(protoDir, 'simple_op_store.proto');
   }
 
   /**
@@ -40,12 +29,12 @@ export class JJOperationStore {
    */
   async writeOperation(operationId, viewId, parentIds, metadata) {
     // Load protobuf schema
-    const root = await protobuf.load(this.protoPath);
+    const root = getSimpleOpStoreRoot();
     const Operation = root.lookupType('simple_op_store.Operation');
 
     // Convert hex IDs to bytes
-    const viewIdBuffer = Buffer.from(viewId, 'hex');
-    const parentBuffers = parentIds.map((id) => Buffer.from(id, 'hex'));
+    const viewIdBuffer = hexToBytes(viewId);
+    const parentBuffers = parentIds.map((id) => hexToBytes(id));
 
     // Create metadata message (use camelCase for protobufjs)
     const metadataMsg = {
@@ -101,7 +90,7 @@ export class JJOperationStore {
     const buffer = await this.fs.promises.readFile(opPath);
 
     // Load protobuf schema
-    const root = await protobuf.load(this.protoPath);
+    const root = getSimpleOpStoreRoot();
     const Operation = root.lookupType('simple_op_store.Operation');
 
     // Decode

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

@@ -5,19 +5,9 @@
  * This file tracks the working copy tree and file states.
  */
 
-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);
-
-// Determine proto path based on whether we're running from dist or src
-const inDist = __dirname.includes('/dist') || __dirname.includes('\\dist');
-const protoDir = inDist
-  ? path.join(__dirname, '..', 'src', 'protos')
-  : path.join(__dirname, '..', 'protos');
+import { getLocalWorkingCopyRoot } from '../protos/schema.js';
+import { hexToBytes } from '../utils/bytes.js';
 
 export class JJTreeState {
   /**
@@ -27,7 +17,6 @@ export class JJTreeState {
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
-    this.protoPath = path.join(protoDir, 'local_working_copy.proto');
   }
 
   /**
@@ -38,11 +27,11 @@ export class JJTreeState {
    */
   async writeTreeState(treeId, fileStates = []) {
     // Load protobuf schema
-    const root = await protobuf.load(this.protoPath);
+    const root = getLocalWorkingCopyRoot();
     const TreeState = root.lookupType('local_working_copy.TreeState');
 
     // Convert hex tree ID to bytes
-    const treeIdBuffer = Buffer.from(treeId, 'hex');
+    const treeIdBuffer = hexToBytes(treeId);
 
     // Convert file states to protobuf format
     const fileStateEntries = fileStates.map((fs) => ({
@@ -88,7 +77,7 @@ export class JJTreeState {
     const buffer = await this.fs.promises.readFile(treeStatePath);
 
     // Load protobuf schema
-    const root = await protobuf.load(this.protoPath);
+    const root = getLocalWorkingCopyRoot();
     const TreeState = root.lookupType('local_working_copy.TreeState');
 
     // Decode

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

@@ -5,19 +5,9 @@
  * Views represent the state of the repository at a given operation.
  */
 
-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);
-
-// Determine proto path based on whether we're running from dist or src
-const inDist = __dirname.includes('/dist') || __dirname.includes('\\dist');
-const protoDir = inDist
-  ? path.join(__dirname, '..', 'src', 'protos')
-  : path.join(__dirname, '..', 'protos');
+import { getSimpleOpStoreRoot } from '../protos/schema.js';
+import { hexToBytes } from '../utils/bytes.js';
 
 export class JJViewStore {
   /**
@@ -27,7 +17,6 @@ export class JJViewStore {
   constructor(fs, dir) {
     this.fs = fs;
     this.dir = dir;
-    this.protoPath = path.join(protoDir, 'simple_op_store.proto');
   }
 
   /**
@@ -39,17 +28,17 @@ export class JJViewStore {
    */
   async writeView(viewId, headIds, wcCommitIds = {}) {
     // Load protobuf schema
-    const root = await protobuf.load(this.protoPath);
+    const root = getSimpleOpStoreRoot();
     const View = root.lookupType('simple_op_store.View');
 
     // Convert hex IDs to bytes
-    const headBuffers = headIds.map((id) => Buffer.from(id, 'hex'));
+    const headBuffers = headIds.map((id) => hexToBytes(id));
 
     // Convert wcCommitIds object to map
     /** @type {Record<string, any>} */
     const wcCommitIdsMap = {};
     for (const [workspace, commitId] of Object.entries(wcCommitIds)) {
-      wcCommitIdsMap[workspace] = Buffer.from(commitId, 'hex');
+      wcCommitIdsMap[workspace] = hexToBytes(commitId);
     }
 
     // Create view message (use camelCase for protobufjs)
@@ -90,7 +79,7 @@ export class JJViewStore {
     const buffer = await this.fs.promises.readFile(viewPath);
 
     // Load protobuf schema
-    const root = await protobuf.load(this.protoPath);
+    const root = getSimpleOpStoreRoot();
     const View = root.lookupType('simple_op_store.View');
 
     // Decode