@rljson/fs-agent 0.0.11 → 0.0.14

package/dist/fs-agent.d.ts

@@ -44,6 +44,14 @@ export interface FsAgentOptions {
      * auto-generates its own identity.
      */
     clientIdentity?: ClientId;
+    /**
+     * Enable Nextcloud-style conflict resolution. When true, {@link syncFromDb}
+     * registers a DAG-branch conflict observer that resolves forks into a single
+     * merge revision (winner keeps the path, loser is renamed). This is a
+     * **client-only** behaviour — hubs are dumb relays and must leave it off
+     * (the default). See `doc/conflict-resolution-design.md`.
+     */
+    resolveConflicts?: boolean;
 }
 /** Restore options */
 export interface RestoreOptions {
@@ -85,6 +93,17 @@ export interface TimeoutConfig {
      * Each retry waits `attempt * processRefRetryDelayMs` (i.e. 5s, 10s, 15s).
      */
     processRefRetryDelayMs?: number;
+    /**
+     * Number of **recovery re-queues** for a ref whose per-cycle retries were
+     * all exhausted (e.g. `db.get` kept timing out because the transport was
+     * disconnected/contended during a hub crash, reconnect or restart). Instead
+     * of permanently dropping the ref — which loses the file written in that
+     * window — it is re-queued up to this many times so it is eventually applied
+     * once the transport recovers. A newer incoming ref supersedes a pending
+     * recovery; `tearDown()` stops it. Default: 10. Set 0 to restore the old
+     * drop-on-exhaustion behaviour.
+     */
+    recoveryRetries?: number;
 }
 /** Filename for sync error log written to the sync folder */
 export declare const SYNC_ERROR_FILE = ".sync-errors.log";
@@ -104,6 +123,15 @@ export declare class FsAgent {
     /** Content fingerprint of the last tree we broadcasted (paths+blobIds) */
     private _lastSentContentKey?;
     private _timeouts;
+    /** Client-only: resolve DAG-branch conflicts into merge revisions. */
+    private _resolveConflicts;
+    /**
+     * Ancestry head: the content ref of the revision currently representing the
+     * filesystem state. New local revisions descend from it; received revisions
+     * advance it. Only tracked when `resolveConflicts` is enabled, so the
+     * InsertHistory predecessor DAG forms only where conflict resolution is on.
+     */
+    private _currentRef?;
     constructor(rootPath: string, bs?: Bs, options?: FsAgentOptions);
     /**
      * Gets the root path
@@ -132,6 +160,13 @@ export declare class FsAgent {
      * @param err - The error value caught
      */
     _writeSyncError(context: string, err: unknown): void;
+    /**
+     * Extracts a human-readable message from a thrown value. The non-`Error`
+     * branch is defensive (the DB/transport always throw `Error`s).
+     * @param err - The caught value.
+     * @returns A message string.
+     */
+    private static _errMessage;
     /**
      * Wraps a promise with a timeout.
      * Rejects with a descriptive error if the promise does not settle
@@ -147,6 +182,9 @@ export declare class FsAgent {
      * otherwise falls back to fire-and-forget `send()`.
      * @param connector - The Connector to send through
      * @param ref - The ref to broadcast
+     * @param predecessorRefs - Causal predecessor content refs to attach (for
+     *   conflict ancestry); set explicitly here because the FsAgent broadcasts
+     *   via an explicit send, which pre-empts the Connector's db-observer path.
      */
     private _sendRef;
     /**
@@ -262,6 +300,44 @@ export declare class FsAgent {
      * @returns Function to stop watching
      */
     syncToDb(db: Db, connector: Connector, treeKey: string, options?: StoreFsTreeOptions): Promise<() => void>;
+    /**
+     * Resolves the `previous` (InsertHistory predecessor timeIds) for a new
+     * revision from the parent's shared content refs. timeIds are per-db, so we
+     * map each shared parent ref to *this* db's local timeId(s). Returns undefined
+     * when ancestry tracking is off (default) or no parent is known — in which
+     * case the store behaves exactly as before.
+     * @param db - Database instance
+     * @param treeKey - Tree table key
+     * @param parentRefs - Parent content refs (local head, or received predecessors)
+     */
+    private _ancestryPrevious;
+    /**
+     * Classifies an incoming revision relative to our current head using the
+     * local InsertHistory DAG (keyed on shared content refs):
+     *  - `behind`   → incoming descends from our head → fast-forward (restore).
+     *  - `ahead`    → our head descends from incoming (e.g. a reconnect bootstrap
+     *                 re-sending an older ancestor) → ignore; we are newer.
+     *  - `diverged` → siblings produced by concurrent edits → resolve the fork.
+     * @param db - Database instance
+     * @param treeKey - Tree table key
+     * @param currentRef - Our current head's content ref
+     * @param incomingRef - The incoming revision's content ref
+     * @param incomingPredecessorRefs - The incoming revision's predecessor refs
+     */
+    private _ancestryRelation;
+    /**
+     * Resolves a divergent incoming revision inline (called from `processRef`
+     * with the watcher paused, so resolution cannot race the sync loop). Records
+     * the incoming revision as a fork tip without clobbering local content, then
+     * merges our head and the incoming tip into a single merge revision D that is
+     * materialised to disk and broadcast.
+     * @param db - Database instance
+     * @param treeKey - Tree table key
+     * @param incomingRef - The incoming revision's content ref
+     * @param incomingTree - The fetched incoming tree
+     * @param predecessorRefs - The incoming revision's predecessor content refs
+     */
+    private _resolveConflictInline;
     /**
      * Builds a map of relativePath → blobId for all files in a tree.
      * Used to compare trees by content rather than by hash (which includes mtime).
@@ -289,6 +365,17 @@ export declare class FsAgent {
      * @param b - Second tree to compare
      */
     private _treesHaveEquivalentContent;
+    /**
+     * Builds the dependency surface a {@link FsConflictResolver} needs, wiring it
+     * to this agent's db, blob store, scanner, and working directory.
+     *
+     * The merge store records the merged ref/content key as the last-sent state,
+     * so the watcher-driven re-scan that follows the on-disk materialisation
+     * settles to a no-op instead of re-broadcasting.
+     * @param db - Database instance
+     * @param treeKey - Tree table key
+     */
+    private _buildConflictResolverDeps;
     /**
      * Watches database for tree changes and syncs to filesystem
      * Uses Connector for socket-based notifications

package/dist/fs-agent.js

@@ -2,7 +2,7 @@ import { BsMem } from "@rljson/bs";
 import { Route, createTreesTableCfg } from "@rljson/rljson";
 import { watch, appendFileSync } from "fs";
 import { stat, readFile, mkdir, writeFile, readdir, utimes, rm } from "fs/promises";
-import { dirname, join, sep } from "path";
+import { dirname, join } from "path";
 import { hip } from "@rljson/hash";
 import { Db } from "@rljson/db";
 import { IoMem, createSocketPair } from "@rljson/io";
@@ -112,6 +112,248 @@ class FsBlobAdapter {
     return new FsBlobAdapter();
   }
 }
+const DIR_MARKER = "<dir>";
+function fsTreeToContentMap(tree) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [, node] of tree.trees) {
+    const meta = node.meta;
+    if (meta?.type === "file") {
+      map.set(
+        meta.relativePath,
+        meta.blobId ?? ""
+      );
+    } else if (meta?.type === "directory" && meta.relativePath !== ".") {
+      map.set(meta.relativePath, DIR_MARKER);
+    }
+  }
+  return map;
+}
+function compareTips(a, b) {
+  if (a.timestamp !== b.timestamp) {
+    return a.timestamp - b.timestamp;
+  }
+  if (a.clientId !== b.clientId) {
+    return a.clientId > b.clientId ? 1 : -1;
+  }
+  if (a.ref !== b.ref) {
+    return a.ref > b.ref ? 1 : -1;
+  }
+  return 0;
+}
+function decideWinner(a, b) {
+  return compareTips(a, b) >= 0 ? { winner: a, loser: b } : { winner: b, loser: a };
+}
+function findCommonAncestor(rows, tipA, tipB) {
+  const prevOf = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    prevOf.set(row.timeId, row.previous ?? []);
+  }
+  const ancestorsOfA = /* @__PURE__ */ new Set();
+  const stack = [tipA];
+  while (stack.length > 0) {
+    const id = stack.pop();
+    if (ancestorsOfA.has(id)) {
+      continue;
+    }
+    ancestorsOfA.add(id);
+    for (const p of prevOf.get(id) ?? []) {
+      stack.push(p);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  let frontier = [tipB];
+  while (frontier.length > 0) {
+    const next = [];
+    for (const id of frontier) {
+      if (ancestorsOfA.has(id)) {
+        return id;
+      }
+      if (visited.has(id)) {
+        continue;
+      }
+      visited.add(id);
+      for (const p of prevOf.get(id) ?? []) {
+        next.push(p);
+      }
+    }
+    frontier = next;
+  }
+  return null;
+}
+function formatConflictTimestamp(ms) {
+  const d = new Date(ms);
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  const date = `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())}`;
+  const time = `${p(d.getUTCHours())}${p(d.getUTCMinutes())}${p(d.getUTCSeconds())}`;
+  return `${date} ${time}`;
+}
+function conflictCopyName(relativePath, clientId, timestamp, taken) {
+  const slash = relativePath.lastIndexOf("/");
+  const dir = slash >= 0 ? relativePath.slice(0, slash + 1) : "";
+  const base = slash >= 0 ? relativePath.slice(slash + 1) : relativePath;
+  const dot = base.lastIndexOf(".");
+  const stem = dot > 0 ? base.slice(0, dot) : base;
+  const ext = dot > 0 ? base.slice(dot) : "";
+  const ts = formatConflictTimestamp(timestamp);
+  const marker = `(conflicted copy ${clientId} ${ts})`;
+  let candidate = `${dir}${stem} ${marker}${ext}`;
+  let n = 1;
+  while (taken.has(candidate)) {
+    candidate = `${dir}${stem} ${marker} (${n})${ext}`;
+    n++;
+  }
+  taken.add(candidate);
+  return candidate;
+}
+function threeWayMerge(o, ours, theirs, winnerSide, loserClientId, loserTimestamp) {
+  const merged = /* @__PURE__ */ new Map();
+  const copies = [];
+  const conflictPaths = [];
+  const taken = /* @__PURE__ */ new Set([...o.keys(), ...ours.keys(), ...theirs.keys()]);
+  const allPaths = new Set(taken);
+  for (const path of [...allPaths].sort()) {
+    const a = o.get(path);
+    const b = ours.get(path);
+    const c = theirs.get(path);
+    if (b === c) {
+      if (b !== void 0) {
+        merged.set(path, b);
+      }
+      continue;
+    }
+    if (b === a) {
+      if (c !== void 0) {
+        merged.set(path, c);
+      }
+      continue;
+    }
+    if (c === a) {
+      if (b !== void 0) {
+        merged.set(path, b);
+      }
+      continue;
+    }
+    conflictPaths.push(path);
+    const winnerVal = winnerSide === "ours" ? b : c;
+    const loserVal = winnerSide === "ours" ? c : b;
+    if (winnerVal !== void 0) {
+      merged.set(path, winnerVal);
+    }
+    if (loserVal !== void 0 && loserVal !== DIR_MARKER) {
+      const copyPath = conflictCopyName(
+        path,
+        loserClientId,
+        loserTimestamp,
+        taken
+      );
+      copies.push({ path: copyPath, blobId: loserVal });
+    }
+  }
+  return { merged, copies, conflictPaths };
+}
+class FsConflictResolver {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  _log(level, msg) {
+    this.deps.log?.(level, `[FsConflictResolver] ${msg}`);
+  }
+  /**
+   * Resolves the conflict, returning the stored merge ref, or null when the
+   * conflict is not ours / not actionable.
+   * @param conflict - The detected DAG-branch conflict
+   * @returns The stored merge revision's root ref, or null
+   */
+  async resolve(conflict) {
+    const { treeKey } = this.deps;
+    if (conflict.table !== treeKey) {
+      return null;
+    }
+    const tips = conflict.branches ?? [];
+    if (tips.length < 2) {
+      return null;
+    }
+    const rows = await this.deps.getInsertHistory(treeKey);
+    const rowByTimeId = new Map(
+      rows.map((r) => [r.timeId, r])
+    );
+    const branchTips = [];
+    for (const timeId of tips) {
+      const row = rowByTimeId.get(timeId);
+      const ref2 = await this.deps.getRefOfTimeId(treeKey, timeId);
+      branchTips.push({
+        timeId,
+        ref: ref2 ?? "",
+        clientId: row?.origin ?? "",
+        timestamp: row?.clientTimestamp ?? 0
+      });
+    }
+    const ordered = [...branchTips].sort((x, y) => compareTips(x, y));
+    const loserTip = ordered[0];
+    const winnerTip = ordered[1];
+    if (!loserTip.ref || !winnerTip.ref) {
+      this._log(
+        "warn",
+        `missing tree ref for a tip (loser=${loserTip.ref}, winner=${winnerTip.ref})`
+      );
+      return null;
+    }
+    const loserTipId = loserTip.timeId;
+    const winnerTipId = winnerTip.timeId;
+    const loserTree = await this.deps.fetchTree(loserTip.ref);
+    const winnerTree = await this.deps.fetchTree(winnerTip.ref);
+    const loserMap = fsTreeToContentMap(loserTree);
+    const winnerMap = fsTreeToContentMap(winnerTree);
+    const ancestorTimeId = findCommonAncestor(rows, loserTipId, winnerTipId);
+    let ancestorMap = /* @__PURE__ */ new Map();
+    if (ancestorTimeId) {
+      const ancRef = await this.deps.getRefOfTimeId(treeKey, ancestorTimeId);
+      if (ancRef) {
+        ancestorMap = fsTreeToContentMap(await this.deps.fetchTree(ancRef));
+      }
+    }
+    const plan = threeWayMerge(
+      ancestorMap,
+      loserMap,
+      winnerMap,
+      "theirs",
+      loserTip.clientId,
+      loserTip.timestamp
+    );
+    await this.deps.restoreTree(winnerTree);
+    for (const [path, blobId] of plan.merged) {
+      if (blobId === DIR_MARKER) {
+        continue;
+      }
+      if (winnerMap.get(path) === blobId) {
+        continue;
+      }
+      await this.deps.writeFileAt(path, await this.deps.getBlobContent(blobId));
+    }
+    for (const [path, blobId] of winnerMap) {
+      if (blobId === DIR_MARKER) {
+        continue;
+      }
+      if (!plan.merged.has(path)) {
+        await this.deps.deleteFileAt(path);
+      }
+    }
+    for (const copy of plan.copies) {
+      await this.deps.writeFileAt(
+        copy.path,
+        await this.deps.getBlobContent(copy.blobId)
+      );
+    }
+    const mergedTree = await this.deps.scan();
+    const ref = await this.deps.storeMerge(mergedTree, [loserTipId, winnerTipId]);
+    this.deps.onMergeStored?.(ref);
+    this._log(
+      "info",
+      `resolved fork ${loserTipId.slice(0, 6)}…/${winnerTipId.slice(0, 6)}… → ${ref.slice(0, 8)}… (${plan.conflictPaths.length} conflict(s), ${plan.copies.length} copy/ies)`
+    );
+    return ref;
+  }
+}
 class FsDbAdapter {
   constructor(db, treeKey) {
     this.db = db;
@@ -153,7 +395,8 @@ class FsDbAdapter {
     );
     trees.push(rootTree);
     const results = await this.db.insertTrees(this.treeKey, trees, {
-      skipNotification: options.skipNotification
+      skipNotification: options.skipNotification,
+      previous: options.previous
     });
     return results[0][`${this.treeKey}Ref`];
   }
@@ -240,7 +483,6 @@ class FsScanner {
     return this._tree;
   }
   async _scanDirectory(absolutePath, relativePath, depth, trees) {
-    const stats = await stat(absolutePath);
     const entries = await readdir(absolutePath, { withFileTypes: true });
     const childRefs = [];
     for (const entry of entries) {
@@ -292,9 +534,12 @@ class FsScanner {
         const fileMeta = {
           name: entry.name,
           type: "file",
-          path: childPath,
           relativePath: childRelPath,
           size: childStats.size,
+          // mtime is kept for files (restore preserves it, so it round-trips to
+          // the same ref on every client) but NOT for directories (a folder's
+          // mtime is per-machine and does not round-trip). The absolute `path`
+          // is excluded everywhere — it is folder-specific.
           mtime: childStats.mtime.getTime(),
           blobId: blobProps.blobId
           // Link to content in Bs
@@ -311,19 +556,14 @@ class FsScanner {
         childRefs.push(fileTreeHashStr);
       }
     }
-    const dirName = relativePath === "." ? (
-      /* v8 ignore next -- @preserve */
-      this._rootPath.split(sep).pop() || ""
-    ) : (
+    const dirName = relativePath === "." ? "." : (
       /* v8 ignore next -- @preserve */
       relativePath.split("/").pop() || ""
     );
     const dirMeta = {
       name: dirName,
       type: "directory",
-      path: absolutePath,
-      relativePath,
-      mtime: stats.mtime.getTime()
+      relativePath
     };
     const dirTree = {
       id: dirName,
@@ -510,7 +750,8 @@ const DEFAULT_TIMEOUTS = {
   syncCallback: 25e3,
   debounceMs: 300,
   processRefRetries: 3,
-  processRefRetryDelayMs: 5e3
+  processRefRetryDelayMs: 5e3,
+  recoveryRetries: 10
 };
 const SYNC_ERROR_FILE = ".sync-errors.log";
 class FsAgent {
@@ -526,12 +767,22 @@ class FsAgent {
   /** Content fingerprint of the last tree we broadcasted (paths+blobIds) */
   _lastSentContentKey;
   _timeouts;
+  /** Client-only: resolve DAG-branch conflicts into merge revisions. */
+  _resolveConflicts;
+  /**
+   * Ancestry head: the content ref of the revision currently representing the
+   * filesystem state. New local revisions descend from it; received revisions
+   * advance it. Only tracked when `resolveConflicts` is enabled, so the
+   * InsertHistory predecessor DAG forms only where conflict resolution is on.
+   */
+  _currentRef;
   constructor(rootPath, bs, options = {}) {
     this._rootPath = rootPath;
     this._bs = bs || new BsMem();
     this._db = options.db;
     this._treeKey = options.treeKey;
     this._timeouts = { ...DEFAULT_TIMEOUTS, ...options.timeouts };
+    this._resolveConflicts = options.resolveConflicts ?? false;
     this._scanner = new FsScanner(rootPath, {
       ...options,
       ignore: [...options.ignore || [], SYNC_ERROR_FILE],
@@ -592,6 +843,15 @@ ${err.stack}` : String(err);
     } catch {
     }
   }
+  /**
+   * Extracts a human-readable message from a thrown value. The non-`Error`
+   * branch is defensive (the DB/transport always throw `Error`s).
+   * @param err - The caught value.
+   * @returns A message string.
+   */
+  static _errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+  }
   /**
    * Wraps a promise with a timeout.
    * Rejects with a descriptive error if the promise does not settle
@@ -623,8 +883,14 @@ ${err.stack}` : String(err);
    * otherwise falls back to fire-and-forget `send()`.
    * @param connector - The Connector to send through
    * @param ref - The ref to broadcast
+   * @param predecessorRefs - Causal predecessor content refs to attach (for
+   *   conflict ancestry); set explicitly here because the FsAgent broadcasts
+   *   via an explicit send, which pre-empts the Connector's db-observer path.
    */
-  async _sendRef(connector, ref) {
+  async _sendRef(connector, ref, predecessorRefs) {
+    if (this._resolveConflicts) {
+      connector.setPredecessors(predecessorRefs ?? []);
+    }
     if (connector.syncConfig?.requireAck) {
       await connector.sendWithAck(ref);
     } else {
@@ -955,18 +1221,31 @@ ${err.stack}` : String(err);
    * @returns Function to stop watching
    */
   async syncToDb(db, connector, treeKey, options) {
+    const initialParentRef = this._currentRef;
+    const initialTree = await FsAgent._withTimeout(
+      this.extract(),
+      this._timeouts.extract,
+      `syncToDb → initial extract(${treeKey})`
+    );
+    const initialIsNew = initialParentRef !== void 0 && initialTree.rootHash !== initialParentRef;
+    const initialPrevious = initialIsNew ? await this._ancestryPrevious(db, treeKey, [initialParentRef]) : void 0;
     const initialRef = await FsAgent._withTimeout(
-      this.storeInDb(db, treeKey, options),
+      new FsDbAdapter(db, treeKey).storeFsTree(initialTree, {
+        ...options,
+        previous: initialPrevious
+      }),
       this._timeouts.fetchTree,
-      `syncToDb → initial storeInDb(${treeKey})`
+      `syncToDb → initial storeFsTree(${treeKey})`
     );
     if (initialRef) {
       this._lastSentRef = initialRef;
-      const currentTree = this._scanner.tree;
-      if (currentTree) {
-        this._lastSentContentKey = this._contentKeyFromTree(currentTree);
-      }
-      await this._sendRef(connector, initialRef);
+      this._currentRef = initialRef;
+      this._lastSentContentKey = this._contentKeyFromTree(initialTree);
+      await this._sendRef(
+        connector,
+        initialRef,
+        initialIsNew ? [initialParentRef] : void 0
+      );
     }
     let debounceTimer = null;
     const debouncedSync = () => {
@@ -981,18 +1260,29 @@ ${err.stack}` : String(err);
               return;
             }
             const dbAdapter = new FsDbAdapter(db, treeKey);
+            const parentRef = this._currentRef;
+            const previous = await this._ancestryPrevious(
+              db,
+              treeKey,
+              parentRef ? [parentRef] : void 0
+            );
             const ref = await FsAgent._withTimeout(
-              dbAdapter.storeFsTree(tree, options),
+              dbAdapter.storeFsTree(tree, { ...options, previous }),
               this._timeouts.fetchTree,
               `syncToDb → storeFsTree(${treeKey})`
             );
+            this._currentRef = ref;
             if (ref === this._lastSentRef) {
               return;
             }
             this._lastSentRef = ref;
             this._lastSentContentKey = contentKey;
             if (ref) {
-              await this._sendRef(connector, ref);
+              await this._sendRef(
+                connector,
+                ref,
+                parentRef ? [parentRef] : void 0
+              );
             }
           } catch (err) {
             console.error("[FsAgent] syncToDb failed:", err);
@@ -1009,6 +1299,110 @@ ${err.stack}` : String(err);
       this._scanner.stopWatch();
     };
   }
+  /**
+   * Resolves the `previous` (InsertHistory predecessor timeIds) for a new
+   * revision from the parent's shared content refs. timeIds are per-db, so we
+   * map each shared parent ref to *this* db's local timeId(s). Returns undefined
+   * when ancestry tracking is off (default) or no parent is known — in which
+   * case the store behaves exactly as before.
+   * @param db - Database instance
+   * @param treeKey - Tree table key
+   * @param parentRefs - Parent content refs (local head, or received predecessors)
+   */
+  async _ancestryPrevious(db, treeKey, parentRefs) {
+    if (!this._resolveConflicts || !parentRefs || parentRefs.length === 0) {
+      return void 0;
+    }
+    const timeIds = [];
+    for (const ref of parentRefs) {
+      timeIds.push(...await db.getTimeIdsForRef(treeKey, ref));
+    }
+    return timeIds.length > 0 ? timeIds : void 0;
+  }
+  /**
+   * Classifies an incoming revision relative to our current head using the
+   * local InsertHistory DAG (keyed on shared content refs):
+   *  - `behind`   → incoming descends from our head → fast-forward (restore).
+   *  - `ahead`    → our head descends from incoming (e.g. a reconnect bootstrap
+   *                 re-sending an older ancestor) → ignore; we are newer.
+   *  - `diverged` → siblings produced by concurrent edits → resolve the fork.
+   * @param db - Database instance
+   * @param treeKey - Tree table key
+   * @param currentRef - Our current head's content ref
+   * @param incomingRef - The incoming revision's content ref
+   * @param incomingPredecessorRefs - The incoming revision's predecessor refs
+   */
+  async _ancestryRelation(db, treeKey, currentRef, incomingRef, incomingPredecessorRefs) {
+    const dump = await db.getInsertHistory(treeKey);
+    const rows = dump[`${treeKey}InsertHistory`]?._data ?? [];
+    const refKey = `${treeKey}Ref`;
+    const refOfTimeId = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      refOfTimeId.set(r.timeId, r[refKey]);
+    }
+    const prevRefsOf = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      const prev = (r.previous ?? []).map((t) => refOfTimeId.get(t)).filter((x) => x !== void 0);
+      prevRefsOf.set(r[refKey], prev);
+    }
+    const ancestorsOf = (startRefs) => {
+      const seen = /* @__PURE__ */ new Set();
+      const stack = [...startRefs];
+      while (stack.length > 0) {
+        const ref = stack.pop();
+        if (seen.has(ref)) {
+          continue;
+        }
+        seen.add(ref);
+        for (const p of prevRefsOf.get(ref) ?? []) {
+          stack.push(p);
+        }
+      }
+      return seen;
+    };
+    if (ancestorsOf(incomingPredecessorRefs).has(currentRef)) {
+      return "behind";
+    }
+    if (ancestorsOf([currentRef]).has(incomingRef)) {
+      return "ahead";
+    }
+    return "diverged";
+  }
+  /**
+   * Resolves a divergent incoming revision inline (called from `processRef`
+   * with the watcher paused, so resolution cannot race the sync loop). Records
+   * the incoming revision as a fork tip without clobbering local content, then
+   * merges our head and the incoming tip into a single merge revision D that is
+   * materialised to disk and broadcast.
+   * @param db - Database instance
+   * @param treeKey - Tree table key
+   * @param incomingRef - The incoming revision's content ref
+   * @param incomingTree - The fetched incoming tree
+   * @param predecessorRefs - The incoming revision's predecessor content refs
+   */
+  async _resolveConflictInline(db, treeKey, incomingRef, incomingTree, predecessorRefs) {
+    const dbAdapter = new FsDbAdapter(db, treeKey);
+    const incomingPrevious = await this._ancestryPrevious(
+      db,
+      treeKey,
+      predecessorRefs
+    );
+    await dbAdapter.storeFsTree(incomingTree, {
+      skipNotification: true,
+      previous: incomingPrevious
+    });
+    const headTimeIds = await db.getTimeIdsForRef(treeKey, this._currentRef);
+    const incomingTimeIds = await db.getTimeIdsForRef(treeKey, incomingRef);
+    const resolver = new FsConflictResolver(
+      this._buildConflictResolverDeps(db, treeKey)
+    );
+    await resolver.resolve({
+      table: treeKey,
+      type: "dagBranch",
+      detectedAt: Date.now(),
+      branches: [...headTimeIds, ...incomingTimeIds]
+    });
+  }
   /**
    * Builds a map of relativePath → blobId for all files in a tree.
    * Used to compare trees by content rather than by hash (which includes mtime).
@@ -1062,6 +1456,51 @@ ${err.stack}` : String(err);
     }
     return true;
   }
+  /**
+   * Builds the dependency surface a {@link FsConflictResolver} needs, wiring it
+   * to this agent's db, blob store, scanner, and working directory.
+   *
+   * The merge store records the merged ref/content key as the last-sent state,
+   * so the watcher-driven re-scan that follows the on-disk materialisation
+   * settles to a no-op instead of re-broadcasting.
+   * @param db - Database instance
+   * @param treeKey - Tree table key
+   */
+  _buildConflictResolverDeps(db, treeKey) {
+    return {
+      treeKey,
+      getInsertHistory: async (table) => {
+        const dump = await db.getInsertHistory(table);
+        const rows = dump[`${table}InsertHistory`]?._data ?? [];
+        return rows;
+      },
+      getRefOfTimeId: (table, timeId) => db.getRefOfTimeId(table, timeId),
+      fetchTree: (rootRef) => this._fetchTreeFromDb(db, treeKey, rootRef),
+      getBlobContent: (blobId) => this._adapter.getFileContent(blobId),
+      restoreTree: (tree) => this.restore(tree, void 0, { cleanTarget: true }),
+      writeFileAt: async (relativePath, content) => {
+        const filePath = join(this._rootPath, relativePath);
+        await mkdir(dirname(filePath), { recursive: true });
+        await writeFile(filePath, content);
+      },
+      deleteFileAt: async (relativePath) => {
+        await rm(join(this._rootPath, relativePath), {
+          force: true,
+          recursive: true
+        });
+      },
+      scan: () => this._scanner.scan(),
+      storeMerge: async (tree, previous) => {
+        const dbAdapter = new FsDbAdapter(db, treeKey);
+        const ref = await dbAdapter.storeFsTree(tree, { previous });
+        this._lastSentRef = ref;
+        this._lastSentContentKey = this._contentKeyFromTree(tree);
+        this._currentRef = ref;
+        return ref;
+      }
+      // Resolution failures are surfaced by `_onConflict`; success is silent.
+    };
+  }
   /**
    * Watches database for tree changes and syncs to filesystem
    * Uses Connector for socket-based notifications
@@ -1077,7 +1516,9 @@ ${err.stack}` : String(err);
     }
     let pendingRef = null;
     let fromDbTimer = null;
-    const processRef = async (treeRef) => {
+    let pendingRecoveryAttempt = 0;
+    let pendingPredecessorRefs;
+    const processRef = async (treeRef, recoveryAttempt = 0, predecessorRefs) => {
       const maxAttempts = this._timeouts.processRefRetries + 1;
       for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         this._scanner.pauseWatch();
@@ -1104,6 +1545,28 @@ ${err.stack}` : String(err);
             );
             return;
           }
+          if (this._resolveConflicts && this._currentRef && predecessorRefs && predecessorRefs.length > 0) {
+            const relation = await this._ancestryRelation(
+              db,
+              treeKey,
+              this._currentRef,
+              treeRef,
+              predecessorRefs
+            );
+            if (relation === "ahead") {
+              return;
+            }
+            if (relation === "diverged") {
+              await this._resolveConflictInline(
+                db,
+                treeKey,
+                treeRef,
+                incomingTree,
+                predecessorRefs
+              );
+              return;
+            }
+          }
           await FsAgent._withTimeout(
             this.restore(incomingTree, void 0, restoreOptions),
             this._timeouts.restore,
@@ -1111,23 +1574,44 @@ ${err.stack}` : String(err);
           );
           const postRestoreTree = await this._scanner.scan();
           const dbAdapter = new FsDbAdapter(db, treeKey);
+          const previous = await this._ancestryPrevious(
+            db,
+            treeKey,
+            predecessorRefs
+          );
           const postRestoreRef = await dbAdapter.storeFsTree(postRestoreTree, {
-            skipNotification: true
+            skipNotification: true,
+            previous
           });
           this._lastSentRef = postRestoreRef;
           this._lastSentContentKey = this._contentKeyFromTree(postRestoreTree);
+          this._currentRef = postRestoreRef;
           return;
         } catch (err) {
           if (attempt === maxAttempts) {
-            console.error(
-              `[FsAgent] syncFromDb processRef failed after ${maxAttempts} attempts:`,
-              err
-            );
-            this._writeSyncError("syncFromDb/processRef", err);
+            if (recoveryAttempt >= this._timeouts.recoveryRetries) {
+              console.error(
+                `[FsAgent] syncFromDb processRef failed after ${maxAttempts} attempts and ${recoveryAttempt} recoveries:`,
+                err
+              );
+              this._writeSyncError("syncFromDb/processRef", err);
+            } else {
+              if (pendingRef === null) {
+                console.warn(
+                  `[FsAgent] syncFromDb: ref=${treeRef.slice(0, 8)}… not yet fetchable after ${maxAttempts} attempts, re-queueing (recovery ${recoveryAttempt + 1}/${this._timeouts.recoveryRetries}): ${FsAgent._errMessage(err)}`
+                );
+                scheduleProcess(
+                  treeRef,
+                  this._timeouts.processRefRetryDelayMs * maxAttempts,
+                  recoveryAttempt + 1,
+                  predecessorRefs
+                );
+              }
+            }
           } else {
             const delaySec = attempt * this._timeouts.processRefRetryDelayMs / 1e3;
             console.warn(
-              `[FsAgent] syncFromDb: attempt ${attempt}/${maxAttempts} failed for ref=${treeRef.slice(0, 8)}…, retrying in ${delaySec}s: ${err instanceof Error ? err.message : String(err)}`
+              `[FsAgent] syncFromDb: attempt ${attempt}/${maxAttempts} failed for ref=${treeRef.slice(0, 8)}…, retrying in ${delaySec}s: ${FsAgent._errMessage(err)}`
             );
           }
         } finally {
@@ -1138,20 +1622,28 @@ ${err.stack}` : String(err);
         );
       }
     };
-    const syncCallback = async (treeRef) => {
-      if (!treeRef || typeof treeRef !== "string") {
-        return;
-      }
-      pendingRef = treeRef;
+    const scheduleProcess = (ref, delayMs, recoveryAttempt, predecessorRefs) => {
+      pendingRef = ref;
+      pendingRecoveryAttempt = recoveryAttempt;
+      pendingPredecessorRefs = predecessorRefs;
       if (fromDbTimer) clearTimeout(fromDbTimer);
       fromDbTimer = setTimeout(async () => {
         fromDbTimer = null;
-        const ref = pendingRef;
+        const r = pendingRef;
+        const ra = pendingRecoveryAttempt;
+        const pr = pendingPredecessorRefs;
         pendingRef = null;
-        if (ref) {
-          await processRef(ref);
+        if (r) {
+          await processRef(r, ra, pr);
         }
-      }, this._timeouts.debounceMs);
+      }, delayMs);
+    };
+    const syncCallback = (treeRef, predecessorRefs) => {
+      if (!treeRef || typeof treeRef !== "string") {
+        return Promise.resolve();
+      }
+      scheduleProcess(treeRef, this._timeouts.debounceMs, 0, predecessorRefs);
+      return Promise.resolve();
     };
     connector.listen(syncCallback);
     return () => {
@@ -1283,10 +1775,19 @@ async function runClientServerSetup(opts = {}) {
   return { baseDir, folderA, folderB, contentB, cleanup };
 }
 export {
+  DIR_MARKER,
   FsAgent,
   FsBlobAdapter,
+  FsConflictResolver,
   FsDbAdapter,
   FsScanner,
   SYNC_ERROR_FILE,
-  runClientServerSetup
+  compareTips,
+  conflictCopyName,
+  decideWinner,
+  findCommonAncestor,
+  formatConflictTimestamp,
+  fsTreeToContentMap,
+  runClientServerSetup,
+  threeWayMerge
 };

package/dist/fs-conflict-resolver.d.ts

@@ -0,0 +1,181 @@
+import { Conflict } from '@rljson/db';
+import { InsertHistoryRow } from '@rljson/rljson';
+import { FsTree } from './fs-scanner.js';
+/**
+ * Nextcloud-style conflict resolution for forked FS-tree DAGs.
+ *
+ * When two peers edit a shared tree while one is offline, the InsertHistory
+ * DAG forks into two tips (B and C, both descending from a common ancestor A).
+ * `@rljson/db` fires a `dagBranch` conflict. This module resolves it on the
+ * **client** by performing a deterministic three-way file-level merge and
+ * writing a single **merge revision D** whose `InsertHistory.previous`
+ * references *both* tips — collapsing the fork back to one tip.
+ *
+ * The pure functions (merge, naming, ancestor walk, winner selection) are
+ * deterministic: every peer resolving the same fork produces the identical D,
+ * so resolution converges instead of forking again.
+ *
+ * See `doc/conflict-resolution-design.md`.
+ */
+/** relativePath → blobId. Directories are recorded as {@link DIR_MARKER}. */
+export type ContentMap = Map<string, string>;
+/** Sentinel blobId used for directory entries in a {@link ContentMap}. */
+export declare const DIR_MARKER = "<dir>";
+/**
+ * Builds a {@link ContentMap} (relativePath → blobId) from an FsTree, ignoring
+ * mtime so two trees with identical content compare equal regardless of when
+ * they were written.
+ * @param tree - The FsTree to flatten
+ * @returns A map of relativePath → blobId (directories use {@link DIR_MARKER})
+ */
+export declare function fsTreeToContentMap(tree: FsTree): ContentMap;
+/** A branch tip's identity, used for deterministic winner selection. */
+export interface BranchTip {
+    /** InsertHistory timeId of the tip (per-db; used only for local lookups). */
+    timeId: string;
+    /** Shared content ref of the tip — the cross-client deterministic tiebreak. */
+    ref: string;
+    /** Originating client id (InsertHistory `origin`). Empty string if unknown. */
+    clientId: string;
+    /** InsertHistory client timestamp (ms). 0 if unknown. */
+    timestamp: number;
+}
+/**
+ * Total, deterministic order over two tips. Returns a positive number when `a`
+ * outranks `b`. Greater timestamp wins; ties broken by greater clientId, then
+ * greater **content ref**. The final tiebreak is the ref (not the timeId)
+ * because timeIds are per-db — using them would make different peers pick
+ * different winners and never converge; the ref is shared, so every peer agrees.
+ * @param a - First tip
+ * @param b - Second tip
+ * @returns Positive if `a` outranks `b`, negative if `b` outranks `a`, else 0
+ */
+export declare function compareTips(a: BranchTip, b: BranchTip): number;
+/**
+ * Picks the path-owning winner of a conflict. Per design decision §11.1 the
+ * revision with the greater InsertHistory timestamp keeps the original path;
+ * the loser's content is preserved under a renamed conflict copy.
+ * @param a - First tip
+ * @param b - Second tip
+ * @returns The winning and losing tips
+ */
+export declare function decideWinner(a: BranchTip, b: BranchTip): {
+    winner: BranchTip;
+    loser: BranchTip;
+};
+/**
+ * Finds the nearest common ancestor timeId of two tips by walking the
+ * InsertHistory `previous` chains. Returns null when the tips share no
+ * ancestor (treat as an empty ancestor — everything is an add/add).
+ * @param rows - All InsertHistory rows for the table
+ * @param tipA - First tip timeId
+ * @param tipB - Second tip timeId
+ * @returns The nearest common ancestor timeId, or null if none
+ */
+export declare function findCommonAncestor(rows: InsertHistoryRow<string>[], tipA: string, tipB: string): string | null;
+/**
+ * Formats a timestamp as a stable UTC `YYYY-MM-DD HHMMSS` string. UTC keeps the
+ * conflict-copy name identical across peers in different timezones.
+ * @param ms - Milliseconds since the epoch
+ * @returns The formatted UTC timestamp
+ */
+export declare function formatConflictTimestamp(ms: number): string;
+/**
+ * Derives a Nextcloud-style conflict-copy path:
+ * `document.txt` → `document (conflicted copy <clientId> <ts>).txt`.
+ *
+ * - The suffix is inserted before the final extension; dotfiles / extensionless
+ *   names get it appended.
+ * - Identity + timestamp come from the *losing* revision, so every peer derives
+ *   the same name (determinism).
+ * - If the candidate name is already taken, a numeric ` (n)` is appended; the
+ *   chosen name is added to `taken`.
+ * @param relativePath - The original conflicting path
+ * @param clientId - The losing revision's client id
+ * @param timestamp - The losing revision's InsertHistory timestamp (ms)
+ * @param taken - Set of already-used paths; the chosen name is added to it
+ * @returns A unique conflict-copy path
+ */
+export declare function conflictCopyName(relativePath: string, clientId: string, timestamp: number, taken: Set<string>): string;
+/** A conflict copy to materialise: the losing content under a renamed path. */
+export interface ConflictCopy {
+    /** The renamed path the losing content is written to. */
+    path: string;
+    /** The losing blobId (content preserved, nothing lost). */
+    blobId: string;
+}
+/** The result of a three-way merge. */
+export interface MergePlan {
+    /** Final tree content (winner-resolved): relativePath → blobId. */
+    merged: ContentMap;
+    /** Extra files to write beside the merged set (the renamed losers). */
+    copies: ConflictCopy[];
+    /** Original paths that genuinely conflicted (both sides changed differently). */
+    conflictPaths: string[];
+}
+/**
+ * Three-way file-level merge of ancestor `o`, branch `ours`, branch `theirs`.
+ * `winnerSide` decides who keeps the path on a real conflict; the loser's
+ * content is preserved under a {@link conflictCopyName}. Pure & deterministic.
+ *
+ * Per relative path (see design §4.4):
+ * - both sides equal → keep it (covers unchanged + add-same + delete-both)
+ * - only theirs changed (`ours === o`) → take theirs
+ * - only ours changed (`theirs === o`) → take ours
+ * - both changed differently → CONFLICT: winner keeps path, loser renamed
+ * @param o - Ancestor content map
+ * @param ours - Our branch content map
+ * @param theirs - Their branch content map
+ * @param winnerSide - Which side keeps the path on a real conflict
+ * @param loserClientId - The losing revision's client id (for copy names)
+ * @param loserTimestamp - The losing revision's timestamp (for copy names)
+ * @returns The merge plan (merged set, conflict copies, conflicting paths)
+ */
+export declare function threeWayMerge(o: ContentMap, ours: ContentMap, theirs: ContentMap, winnerSide: 'ours' | 'theirs', loserClientId: string, loserTimestamp: number): MergePlan;
+/**
+ * The capabilities the resolver needs from its host FsAgent + Db. Injected so
+ * the orchestration is unit-testable with in-memory fakes (no real db/fs).
+ */
+export interface ConflictResolverDeps {
+    /** The tree table key (route is `/${treeKey}`). */
+    treeKey: string;
+    /** All InsertHistory rows for `treeKey`. */
+    getInsertHistory: (table: string) => Promise<InsertHistoryRow<string>[]>;
+    /** Resolve a tip timeId to its tree root ref. */
+    getRefOfTimeId: (table: string, timeId: string) => Promise<string | null>;
+    /** Fetch a full FsTree by its root ref. */
+    fetchTree: (rootRef: string) => Promise<FsTree>;
+    /** Read a blob's bytes by blobId. */
+    getBlobContent: (blobId: string) => Promise<Buffer>;
+    /** Restore an FsTree onto the working dir, pruning extraneous entries. */
+    restoreTree: (tree: FsTree) => Promise<void>;
+    /** Write bytes to a relative path under the working dir (mkdir -p). */
+    writeFileAt: (relativePath: string, content: Buffer) => Promise<void>;
+    /** Remove a relative path under the working dir (best effort). */
+    deleteFileAt: (relativePath: string) => Promise<void>;
+    /** Re-scan the working dir into a fresh, hashed FsTree. */
+    scan: () => Promise<FsTree>;
+    /** Store the merge revision with explicit predecessors; returns its root ref. */
+    storeMerge: (tree: FsTree, previous: string[]) => Promise<string>;
+    /** Notified with the stored merge ref so the host can suppress the echo. */
+    onMergeStored?: (ref: string) => void;
+    /** Optional structured logger. */
+    log?: (level: 'info' | 'warn' | 'error', msg: string) => void;
+}
+/**
+ * Resolves a single `dagBranch` conflict into a merge revision. For more than
+ * two tips it merges the two lowest-identity tips per call; the resulting
+ * smaller fork re-fires the observer and converges in further rounds.
+ */
+export declare class FsConflictResolver {
+    private readonly deps;
+    constructor(deps: ConflictResolverDeps);
+    private _log;
+    /**
+     * Resolves the conflict, returning the stored merge ref, or null when the
+     * conflict is not ours / not actionable.
+     * @param conflict - The detected DAG-branch conflict
+     * @returns The stored merge revision's root ref, or null
+     */
+    resolve(conflict: Conflict): Promise<string | null>;
+}

package/dist/fs-db-adapter.d.ts

@@ -1,4 +1,5 @@
 import { Db } from '@rljson/db';
+import { InsertHistoryTimeId } from '@rljson/rljson';
 import { FsTree } from './fs-scanner.js';
 /**
  * Options for storing filesystem trees in database
@@ -10,6 +11,13 @@ export interface StoreFsTreeOptions {
      * via the standard db.insertTrees() pipeline.
      */
     skipNotification?: boolean;
+    /**
+     * Explicit predecessor override for the InsertHistory row. When set, the
+     * stored revision's `previous` references exactly these timeIds instead of
+     * the controller-derived predecessor. Used to write a **merge revision**
+     * whose parents are both tips of a forked DAG, collapsing the fork.
+     */
+    previous?: InsertHistoryTimeId[];
 }
 /**
  * Adapter for storing filesystem trees in a database.

package/dist/fs-scanner.d.ts

@@ -9,16 +9,23 @@ export interface FsNodeMeta extends Json {
     name: string;
     /** Type of node */
     type: 'file' | 'directory';
-    /** Absolute path */
-    path: string;
-    /** Relative path from scan root */
+    /** Relative path from scan root (the cross-client-stable content identity) */
     relativePath: string;
     /** File size in bytes (for files) */
     size?: number;
-    /** Last modified timestamp (milliseconds since epoch) */
-    mtime: number;
     /** Blob ID for file content (files only) */
     blobId?: string;
+    /**
+     * Absolute path — informational only, NOT part of the content identity.
+     * Excluded from stored meta so tree refs are folder-independent (shared
+     * across clients). Retained in the type for back-compat.
+     */
+    path?: string;
+    /**
+     * Last modified timestamp — NOT part of the content identity (environment-
+     * specific). Excluded from stored meta so refs are mtime-independent.
+     */
+    mtime?: number;
 }
 /**
  * Tree structure with hash mapping

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { FsAgent, SYNC_ERROR_FILE, type FsAgentOptions, type RestoreOptions, type TimeoutConfig, } from './fs-agent.ts';
 export { FsBlobAdapter, type BlobToFileOptions, type FileBlobMeta, type FileToBlobOptions, } from './fs-blob-adapter.ts';
 export { FsDbAdapter, type StoreFsTreeOptions } from './fs-db-adapter.ts';
+export { compareTips, conflictCopyName, decideWinner, DIR_MARKER, findCommonAncestor, formatConflictTimestamp, FsConflictResolver, fsTreeToContentMap, threeWayMerge, type BranchTip, type ConflictCopy, type ConflictResolverDeps, type ContentMap, type MergePlan, } from './fs-conflict-resolver.ts';
 export { FsScanner, type FsChange, type FsChangeCallback, type FsChangeType, type FsNodeMeta, type FsScanOptions, type FsTree, } from './fs-scanner.ts';
 export { runClientServerSetup, type ClientServerSetupOptions, type ClientServerSetupResult, } from './client-server/client-server-setup.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rljson/fs-agent",
-  "version": "0.0.11",
+  "version": "0.0.14",
   "description": "Rljson fs-agent description",
   "homepage": "https://github.com/rljson/fs-agent",
   "bugs": "https://github.com/rljson/fs-agent/issues",
@@ -19,12 +19,20 @@
     "dist"
   ],
   "type": "module",
+  "scripts": {
+    "build": "pnpm exec vite build && tsc && node scripts/copy-readme-to-dist.js",
+    "test": "cross-env NODE_OPTIONS=--max-old-space-size=8192 pnpm exec vitest run --coverage && pnpm run lint",
+    "prebuild": "npm run test",
+    "prepublishOnly": "npm run build",
+    "lint": "pnpm exec eslint .",
+    "updateGoldens": "cross-env UPDATE_GOLDENS=true pnpm test"
+  },
   "devDependencies": {
     "@rljson/server": "^0.0.10",
     "@types/node": "^25.3.1",
     "@typescript-eslint/eslint-plugin": "^8.56.1",
     "@typescript-eslint/parser": "^8.56.1",
-    "@vitest/coverage-v8": "^4.0.18",
+    "@vitest/coverage-v8": "^4.1.8",
     "cross-env": "^10.1.0",
     "eslint": "~9.39.3",
     "eslint-plugin-jsdoc": "^62.7.1",
@@ -38,12 +46,12 @@
     "vite-node": "^5.3.0",
     "vite-plugin-dts": "^4.5.4",
     "vite-tsconfig-paths": "^6.1.1",
-    "vitest": "^4.0.18",
+    "vitest": "^4.1.8",
     "vitest-dom": "^0.1.1"
   },
   "dependencies": {
     "@rljson/bs": "^0.0.21",
-    "@rljson/db": "^0.0.15",
+    "@rljson/db": "^0.0.22",
     "@rljson/hash": "^0.0.18",
     "@rljson/io": "^0.0.66",
     "@rljson/json": "^0.0.23",
@@ -51,11 +59,13 @@
     "socket.io": "^4.8.3",
     "socket.io-client": "^4.8.3"
   },
-  "scripts": {
-    "build": "pnpm exec vite build && tsc && node scripts/copy-readme-to-dist.js",
-    "test": "cross-env NODE_OPTIONS=--max-old-space-size=8192 pnpm exec vitest run --coverage && pnpm run lint",
-    "prebuild": "npm run test",
-    "lint": "pnpm exec eslint .",
-    "updateGoldens": "cross-env UPDATE_GOLDENS=true pnpm test"
-  }
-}
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ],
+    "overrides": {
+      "@rljson/rljson": "^0.0.78"
+    }
+  },
+  "packageManager": "pnpm@10.11.0"
+}