@hraness/dawg 0.6.1 → 0.8.0

package/src/project/sync.ts

@@ -1,24 +1,31 @@
 /**
  * Two-way sync between the project files and the session score.
  *
- * files → score: a change to `song.ts` or `tracks/<slug>/track.ts` (fs.watch
- * plus a slow poll, debounced 150 ms) evaluates the project, adopts the
- * session's note ids, diffs against the current score and commits one
- * `files.apply` revision through the session port. A failed evaluation is
- * reported as a card and leaves the score alone.
+ * files → score: a change to any project source (`song.ts`, track files,
+ * helper modules they import, tuning files; fs.watch plus a slow poll,
+ * debounced 40 ms) evaluates the project, adopts the session's note ids,
+ * diffs against the current score and commits one `files.apply` revision
+ * through the session port. A failed evaluation is reported as a card and
+ * leaves the score alone.
  *
  * score → files: a new score revision reprints the project and writes only
- * the files whose bytes differ. Files whose last evaluation already equals
- * the score are never rewritten, so an author's own formatting survives.
+ * the files whose own slice of the score changed, so an author's formatting
+ * and comments in untouched files survive. A file edited since dawg last
+ * synced it (hash differs from `.dawg/sync.json`) is never overwritten: the
+ * edit wins and a card says so.
  *
- * Echo suppression: `.dawg/sync.json` records the hash of every file dawg
- * wrote; a watcher event whose file still hashes the same is ignored, in
- * this window and every other one.
+ * Echo suppression: `.dawg/sync.json` records the hash of every file as of
+ * the last time files and score agreed; a watcher event whose changed files
+ * all still hash the same is ignored, in this window and every other one.
+ *
+ * Ownership: `.dawg/sync.json` names the session the files belong to and
+ * the live windows syncing it. A window on a different session while the
+ * owner is still open never reads or writes the files.
  */
 
-import { createHash } from "node:crypto";
-import { watch, type FSWatcher } from "node:fs";
-import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { watch, type Dirent, type FSWatcher } from "node:fs";
+import { mkdir, readdir, readFile, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import {
   adoptNoteIds,
@@ -34,10 +41,15 @@ import {
   type EvalResult,
 } from "../../core/sdk/eval.ts";
 import { printProject } from "../../core/sdk/print.ts";
+import { acquireSessionLock } from "../session/lock.ts";
 import { writeAtomic } from "./init.ts";
 import { typecheckProject, type TypecheckResult } from "./typecheck.ts";
 
-export const SYNC_DEBOUNCE_MS = 150;
+/**
+ * Quiet time after a file event before evaluating: long enough to coalesce
+ * an editor's write-then-rename, short enough that a save feels immediate.
+ */
+export const SYNC_DEBOUNCE_MS = 40;
 export const SYNC_POLL_MS = 1_500;
 const SYNC_STATE_FILE = ".dawg/sync.json";
 const MAX_TRACKED_FILES = 512;
@@ -73,6 +85,11 @@ export function applyFiles(
 /** What the sync needs from its window. */
 export type SyncHost = Readonly<{
   project: string;
+  /**
+   * The session this window is attached to; it may change when the window
+   * switches sessions. Omitted, the files are never treated as owned.
+   */
+  sessionId?: () => string | undefined;
   /** Current session score. */
   current(): TrackScore;
   /**
@@ -111,7 +128,15 @@ export type ProjectSync = Readonly<{
   stop(): Promise<void>;
 }>;
 
-type SyncState = { files: Record<string, string> };
+type Holder = { pid: number; token: string };
+type SyncOwner = { sessionId: string; holders: Holder[] };
+type SyncState = { files: Record<string, string>; owner?: SyncOwner };
+
+/** Tokens of the syncs running in this process (pids alone cannot tell them apart). */
+const liveTokens = new Set<string>();
+const SYNC_LOCK_FILE = ".dawg/sync.lock";
+const MAX_HOLDERS = 64;
+const TRACK_FILE = /^tracks\/[^/]+\/track\.ts$/;
 
 export function startProjectSync(
   host: SyncHost,
@@ -124,13 +149,24 @@ export function startProjectSync(
   const debounceMs = options.debounceMs ?? SYNC_DEBOUNCE_MS;
   const project = host.project;
   const statePath = join(project, SYNC_STATE_FILE);
-  /** Hashes of the project files as of the last successful evaluation. */
+  const lockPath = join(project, SYNC_LOCK_FILE);
+  const token = randomUUID();
+  liveTokens.add(token);
+  /** Hashes of the project sources as of this window's last look. */
   let seen = new Map<string, string>();
   /** Outcome of the last evaluation, returned when the files did not change. */
   let lastOutcome = "files match the score";
   /** Encoded score the files were last known to equal. */
   let filesEqual = "";
+  /** Per file: the canonical print its current contents are known to evaluate to. */
+  let known = new Map<string, string>();
   let lastRejection = "";
+  let lastConflict = "";
+  /** Session id this window last claimed the files for; undefined while detached. */
+  let attached: string | undefined;
+  let detachedNotice = "";
+  /** The next look at the files decides who wins (startup, session switch). */
+  let needsStartup = true;
   let stopped = false;
   let queue: Promise<void> = Promise.resolve();
   let fileTimer: ReturnType<typeof setTimeout> | undefined;
@@ -152,25 +188,99 @@ export function startProjectSync(
     try {
       const value: unknown = JSON.parse(await readFile(statePath, "utf8"));
       if (typeof value !== "object" || value === null) return { files: {} };
-      const files = (value as Record<string, unknown>).files;
-      if (typeof files !== "object" || files === null) return { files: {} };
+      const record = value as Record<string, unknown>;
+      const files = record.files;
       const out: Record<string, string> = {};
-      for (const [path, hash] of Object.entries(
-        files as Record<string, unknown>,
-      ))
-        if (
-          typeof hash === "string" &&
-          /^[0-9a-f]{64}$/.test(hash) &&
-          path.length < 512
-        )
-          out[path] = hash;
-      return { files: out };
+      if (typeof files === "object" && files !== null)
+        for (const [path, hash] of Object.entries(
+          files as Record<string, unknown>,
+        ))
+          if (
+            typeof hash === "string" &&
+            /^[0-9a-f]{64}$/.test(hash) &&
+            path.length < 512
+          )
+            out[path] = hash;
+      const state: SyncState = { files: out };
+      const owner = parseOwner(record.owner);
+      if (owner) state.owner = owner;
+      return state;
     } catch {
       return { files: {} };
     }
   };
   const writeState = (state: SyncState) =>
     writeAtomic(statePath, `${JSON.stringify(state, null, 2)}\n`);
+  /** Serializes every read-modify-write of sync.json and the files across windows. */
+  const locked = async <T>(task: () => Promise<T>): Promise<T> => {
+    await mkdir(join(project, ".dawg"), { recursive: true });
+    const release = await acquireSessionLock(lockPath);
+    try {
+      return await task();
+    } finally {
+      await release();
+    }
+  };
+
+  /**
+   * Claims the files for this window's session. A different session owns
+   * them while any of its windows is still open: this window then stays
+   * detached and never touches the files. Returns whether the files are
+   * this window's; a changed session makes the next look a fresh startup.
+   */
+  const claim = async (): Promise<{ ok: boolean }> => {
+    const sessionId = host.sessionId?.();
+    if (sessionId === undefined) return { ok: true };
+    const result = await locked(async () => {
+      const state = await readState();
+      const owner = state.owner;
+      const others = (owner?.holders ?? []).filter(
+        (holder) => holder.token !== token && holderAlive(holder),
+      );
+      if (owner && owner.sessionId !== sessionId && others.length > 0)
+        return { ok: false, owner: owner.sessionId };
+      const holders =
+        owner?.sessionId === sessionId
+          ? [...others, { pid: process.pid, token }]
+          : [{ pid: process.pid, token }];
+      const next: SyncOwner = {
+        sessionId,
+        holders: holders.slice(-MAX_HOLDERS),
+      };
+      if (JSON.stringify(next) !== JSON.stringify(owner))
+        await writeState({ ...state, owner: next });
+      return { ok: true, owner: sessionId };
+    });
+    if (!result.ok) {
+      attached = undefined;
+      const notice = `files belong to session ${result.owner}`;
+      if (notice !== detachedNotice) {
+        detachedNotice = notice;
+        host.card(
+          `${notice} · not synced here`,
+          "warning",
+          "another window has them open; close it or switch to that session",
+        );
+      }
+      return { ok: false };
+    }
+    detachedNotice = "";
+    if (attached !== sessionId) needsStartup = true;
+    attached = sessionId;
+    return { ok: true };
+  };
+
+  const recordSynced = async (hashes: Map<string, string>): Promise<void> => {
+    await locked(async () => {
+      const state = await readState();
+      const files = { ...state.files };
+      for (const [path, hash] of hashes) files[path] = hash;
+      for (const path of Object.keys(files))
+        if (!hashes.has(path) && !(await exists(join(project, path))))
+          delete files[path];
+      await writeState({ ...state, files });
+    });
+  };
 
   /**
    * Evaluates the files. In `files-win` mode (edits) the result is committed;
@@ -178,11 +288,51 @@ export function startProjectSync(
    * the files from the score instead.
    */
   const checkFilesNow = async (
-    mode: "files-win" | "score-wins" = "files-win",
+    requested: "files-win" | "score-wins" = "files-win",
   ): Promise<string> => {
+    let mode = requested;
     if (stopped) return lastOutcome;
+    const claimed = await claim();
+    if (!claimed.ok) return (lastOutcome = detachedNotice);
+    if (needsStartup) {
+      // First look (or this window switched sessions): files edited since
+      // dawg last synced them (or never recorded) win; otherwise the
+      // session score wins and reprints what the files lack.
+      needsStartup = false;
+      seen = new Map();
+      known = new Map();
+      filesEqual = "";
+      const state = await readState();
+      const hashes = await hashProject(project);
+      const edited =
+        hashes.size === 0 ||
+        [...hashes].some(([path, hash]) => state.files[path] !== hash);
+      mode = edited ? "files-win" : "score-wins";
+    }
     const current = await hashProject(project);
-    if (mode === "files-win" && sameHashes(current, seen)) return lastOutcome;
+    if (mode === "files-win") {
+      // Nothing re-evaluated: a standing rejection still holds, anything
+      // else is reported as unchanged rather than repeating an old apply.
+      if (sameHashes(current, seen))
+        return lastRejection ? lastOutcome : (lastOutcome = UNCHANGED);
+      // An echo: every changed file is exactly what dawg (this window or
+      // another) last synced, so the session already holds it.
+      const state = await readState();
+      const changed = changedPaths(current, seen);
+      if (
+        seen.size > 0 &&
+        !lastRejection &&
+        changed.every(
+          (path) =>
+            current.get(path) !== undefined &&
+            state.files[path] === current.get(path),
+        )
+      ) {
+        for (const path of changed) known.delete(path);
+        seen = current;
+        return (lastOutcome = "files match the score");
+      }
+    }
     const result = await evaluate(project);
     if (!result.ok) {
       const text = result.diagnostics.map(formatDiagnostic).join("; ");
@@ -194,19 +344,23 @@ export function startProjectSync(
           "fix the file to apply",
         );
       }
+      seen = current;
       void runTypecheck();
       return (lastOutcome = `files rejected · ${text}`);
     }
     lastRejection = "";
     seen = current;
+    known = printedTexts(result.score);
     const plan = applyFiles(host.current(), result.score);
     if (plan.operations.length === 0) {
       filesEqual = encodeLoop(host.current());
+      await recordSynced(current);
       void runTypecheck();
       return (lastOutcome = "files match the score");
     }
     if (mode === "score-wins") {
       pendingScore = host.current();
+      await recordSynced(current);
       await flushScoreNow();
       void runTypecheck();
       return (lastOutcome = "files reprinted from the score");
@@ -215,6 +369,7 @@ export function startProjectSync(
     try {
       const committed = await host.commit(plan, summary);
       filesEqual = encodeLoop(committed);
+      await recordSynced(current);
       host.card(`applied from files · ${summary}`, "success");
       lastOutcome = `applied from files · ${summary}`;
     } catch (error) {
@@ -229,35 +384,81 @@ export function startProjectSync(
   };
 
   const flushScoreNow = async (): Promise<void> => {
+    if (stopped || !pendingScore) return;
+    const claimed = await claim();
+    if (!claimed.ok) return;
+    if (needsStartup) await checkFilesNow("files-win");
     if (stopped || !pendingScore) return;
     const score = pendingScore;
     pendingScore = undefined;
     const encoded = encodeLoop(score);
     if (encoded === filesEqual) return;
     const printed = printProject(score);
-    const state = await readState();
-    const files = { ...state.files };
-    const expected = new Set(printed.files.map((file) => file.path));
-    const hashes = new Map<string, string>();
-    for (const file of printed.files) {
-      const hash = sha256(file.text);
-      hashes.set(file.path, hash);
-      const existing = await readOptional(join(project, file.path));
-      if (existing === file.text) continue;
-      await writeAtomic(join(project, file.path), file.text);
-      files[file.path] = hash;
+    const conflicts: string[] = [];
+    /** Paths this flush wrote (hash) or removed (undefined). */
+    const wrote = new Map<string, string | undefined>();
+    await locked(async () => {
+      const state = await readState();
+      const files = { ...state.files };
+      const expected = new Set(printed.files.map((file) => file.path));
+      for (const file of printed.files) {
+        const path = join(project, file.path);
+        const existing = await readOptional(path);
+        if (existing === file.text) {
+          files[file.path] = sha256(existing);
+          known.set(file.path, file.text);
+          continue;
+        }
+        // This file's slice of the score is unchanged: keep the author's text.
+        if (existing !== undefined && known.get(file.path) === file.text)
+          continue;
+        // Edited since dawg last synced it (or never synced): the edit wins.
+        if (existing !== undefined && files[file.path] !== sha256(existing)) {
+          conflicts.push(file.path);
+          continue;
+        }
+        await writeAtomic(path, file.text);
+        files[file.path] = sha256(file.text);
+        wrote.set(file.path, files[file.path]);
+        known.set(file.path, file.text);
+      }
+      // Track files dawg printed earlier for tracks that no longer exist.
+      for (const [path, hash] of Object.entries(state.files)) {
+        if (expected.has(path) || !TRACK_FILE.test(path)) continue;
+        const existing = await readOptional(join(project, path));
+        if (existing !== undefined && sha256(existing) !== hash) continue;
+        if (existing !== undefined)
+          await rm(join(project, path), { force: true });
+        wrote.set(path, undefined);
+        delete files[path];
+        known.delete(path);
+      }
+      await writeState({ ...state, files });
+    });
+    // Only our own writes are folded into `seen`: an edit the author saved
+    // to any other file since the last look must still be evaluated. While
+    // the files are rejected nothing is folded, so the next look re-evaluates.
+    if (!lastRejection) {
+      seen = new Map(seen);
+      for (const [path, hash] of wrote)
+        if (hash === undefined) seen.delete(path);
+        else seen.set(path, hash);
+    }
+    if (conflicts.length === 0) {
+      filesEqual = encoded;
+      lastConflict = "";
+      return;
     }
-    // Track files we printed earlier for tracks that no longer exist.
-    for (const [path, hash] of Object.entries(state.files)) {
-      if (expected.has(path) || !path.startsWith("tracks/")) continue;
-      const existing = await readOptional(join(project, path));
-      if (existing !== undefined && sha256(existing) === hash)
-        await rm(join(project, path), { force: true });
-      delete files[path];
+    filesEqual = "";
+    const text = conflicts.join(", ");
+    if (text !== lastConflict) {
+      lastConflict = text;
+      host.card(
+        `${text} edited · not overwritten`,
+        "warning",
+        "save it to apply, or delete it to reprint",
+      );
     }
-    await writeState({ files });
-    seen = await hashProject(project);
-    filesEqual = encoded;
   };
 
   let typecheckRunning = false;
@@ -283,12 +484,29 @@ export function startProjectSync(
     }
   };
 
+  /** Errors (a lock timeout, a full disk) become a card, never an unhandled rejection. */
+  const guarded =
+    <T>(task: () => Promise<T>, fallback: T) =>
+    async (): Promise<T> => {
+      try {
+        return await task();
+      } catch (error) {
+        host.card(
+          `file sync failed · ${firstLine(error instanceof Error ? error.message : String(error))}`,
+          "warning",
+        );
+        return fallback;
+      }
+    };
+  const filesWin = guarded(() => checkFilesNow("files-win"), "");
+  const flush = guarded(flushScoreNow, undefined);
+
   const scheduleFiles = () => {
     if (stopped) return;
     if (fileTimer) clearTimeout(fileTimer);
     fileTimer = setTimeout(() => {
       fileTimer = undefined;
-      void enqueue(() => checkFilesNow("files-win"));
+      void enqueue(filesWin);
     }, debounceMs);
   };
 
@@ -312,21 +530,12 @@ export function startProjectSync(
       watchers = [];
     }
     poll = setInterval(
-      () => void enqueue(() => checkFilesNow("files-win")),
+      () => void enqueue(filesWin),
       options.pollMs ?? SYNC_POLL_MS,
     );
     poll.unref?.();
   }
-  // Startup: files edited since dawg last wrote them (or never recorded)
-  // win; otherwise the session score wins and reprints what files lack.
-  void enqueue(async () => {
-    const state = await readState();
-    const current = await hashProject(project);
-    const edited =
-      current.size === 0 ||
-      [...current].some(([path, hash]) => state.files[path] !== hash);
-    await checkFilesNow(edited ? "files-win" : "score-wins");
-  });
+  void enqueue(filesWin);
 
   return Object.freeze({
     scoreChanged(score: TrackScore) {
@@ -335,7 +544,7 @@ export function startProjectSync(
       if (scoreTimer) clearTimeout(scoreTimer);
       scoreTimer = setTimeout(() => {
         scoreTimer = undefined;
-        void enqueue(flushScoreNow);
+        void enqueue(flush);
       }, debounceMs);
     },
     checkFiles: () => enqueue(() => checkFilesNow("files-win")),
@@ -348,48 +557,171 @@ export function startProjectSync(
       watchers.forEach((watcher) => watcher.close());
       watchers = [];
       await queue.catch(() => undefined);
+      liveTokens.delete(token);
+      // Release this window's hold so another session may take the files.
+      await locked(async () => {
+        const state = await readState();
+        if (!state.owner?.holders.some((holder) => holder.token === token))
+          return;
+        await writeState({
+          ...state,
+          owner: {
+            ...state.owner,
+            holders: state.owner.holders.filter(
+              (holder) => holder.token !== token,
+            ),
+          },
+        });
+      }).catch(() => undefined);
     },
   });
 }
 
-/** Project-relative source paths: `song.ts` and each track file under `tracks/`. */
+/** Text extensions a project's evaluation can read: modules, data and tuning. */
+const SOURCE_EXTENSION = /\.(?:[cm]?[jt]sx?|json|scl|kbm)$/;
+const MAX_SOURCE_DEPTH = 6;
+/** Outcome when no project source changed since the last look. */
+export const UNCHANGED = "files unchanged";
+/** Project configuration, not evaluated: editing it never re-evaluates. */
+const CONFIG_FILES = new Set([
+  "dawg.json",
+  "tsconfig.json",
+  "jsconfig.json",
+  "package.json",
+]);
+/** Larger files are fingerprinted by size and mtime instead of content. */
+const MAX_HASHED_BYTES = 2 * 1024 * 1024;
+
+/**
+ * Project-relative source paths: `song.ts`, each `tracks/<slug>/track.ts`,
+ * and every other module, JSON or tuning file in the project that an
+ * evaluation could import or read. Dot directories (`.dawg`, `.git`) and
+ * `node_modules` are skipped; bounded by count and depth.
+ */
 export async function projectSourceFiles(project: string): Promise<string[]> {
-  const files = ["song.ts"];
-  let dirs: string[] = [];
-  try {
-    dirs = (await readdir(join(project, "tracks"), { withFileTypes: true }))
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name)
-      .sort();
-  } catch {
-    dirs = [];
-  }
-  for (const dir of dirs.slice(0, MAX_TRACKED_FILES)) {
-    const path = `tracks/${dir}/track.ts`;
+  const out: string[] = [];
+  const walk = async (dir: string, depth: number): Promise<void> => {
+    if (depth > MAX_SOURCE_DEPTH || out.length >= MAX_TRACKED_FILES) return;
+    let entries: Dirent[];
     try {
-      if ((await stat(join(project, path))).isFile()) files.push(path);
+      entries = await readdir(join(project, dir), { withFileTypes: true });
     } catch {
-      // A directory without a track file (samples only) is not a source.
+      return;
     }
-  }
-  return files;
+    entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    for (const entry of entries) {
+      if (out.length >= MAX_TRACKED_FILES) return;
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const path = dir ? `${dir}/${entry.name}` : entry.name;
+      if (CONFIG_FILES.has(path)) continue;
+      if (entry.isDirectory()) await walk(path, depth + 1);
+      else if (entry.isFile() && SOURCE_EXTENSION.test(entry.name))
+        out.push(path);
+    }
+  };
+  await walk("", 0);
+  return out.sort(
+    (a, b) => sourceRank(a) - sourceRank(b) || (a < b ? -1 : a > b ? 1 : 0),
+  );
+}
+
+/** `song.ts` first, then track files, then everything else. */
+function sourceRank(path: string): number {
+  return path === "song.ts" ? 0 : TRACK_FILE.test(path) ? 1 : 2;
 }
 
 function isProjectSource(name: string): boolean {
-  return (
-    name === "song.ts" || /(^|\/)track\.ts$/.test(name) || !name.includes(".")
-  );
+  const base = name.split(/[\\/]/).pop() ?? name;
+  if (base.startsWith(".") && base.length > 0) return false;
+  return SOURCE_EXTENSION.test(base) || !base.includes(".");
 }
 
 async function hashProject(project: string): Promise<Map<string, string>> {
   const out = new Map<string, string>();
   for (const path of await projectSourceFiles(project)) {
-    const text = await readOptional(join(project, path));
-    if (text !== undefined) out.set(path, sha256(text));
+    const hash = await hashFile(join(project, path));
+    if (hash !== undefined) out.set(path, hash);
   }
   return out;
 }
 
+async function hashFile(path: string): Promise<string | undefined> {
+  try {
+    const info = await stat(path);
+    if (info.size > MAX_HASHED_BYTES)
+      return sha256(`${info.size}:${info.mtimeMs}`);
+    return sha256(await readFile(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function printedTexts(score: TrackScore): Map<string, string> {
+  return new Map(
+    printProject(score).files.map((file) => [file.path, file.text]),
+  );
+}
+
+function changedPaths(
+  a: Map<string, string>,
+  b: Map<string, string>,
+): string[] {
+  const out = new Set<string>();
+  for (const [path, hash] of a) if (b.get(path) !== hash) out.add(path);
+  for (const path of b.keys()) if (!a.has(path)) out.add(path);
+  return [...out];
+}
+
+function parseOwner(value: unknown): SyncOwner | undefined {
+  if (typeof value !== "object" || value === null) return undefined;
+  const record = value as Record<string, unknown>;
+  if (
+    typeof record.sessionId !== "string" ||
+    record.sessionId.length === 0 ||
+    record.sessionId.length > 128 ||
+    !Array.isArray(record.holders)
+  )
+    return undefined;
+  const holders: Holder[] = [];
+  for (const holder of record.holders.slice(0, MAX_HOLDERS)) {
+    if (typeof holder !== "object" || holder === null) continue;
+    const { pid, token } = holder as Record<string, unknown>;
+    if (
+      typeof pid === "number" &&
+      Number.isSafeInteger(pid) &&
+      pid > 0 &&
+      typeof token === "string" &&
+      token.length > 0 &&
+      token.length <= 64
+    )
+      holders.push({ pid, token });
+  }
+  return { sessionId: record.sessionId, holders };
+}
+
+function holderAlive(holder: Holder): boolean {
+  if (holder.pid === process.pid) return liveTokens.has(holder.token);
+  try {
+    process.kill(holder.pid, 0);
+    return true;
+  } catch (error) {
+    return !(
+      error instanceof Error &&
+      "code" in error &&
+      error.code === "ESRCH"
+    );
+  }
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function sameHashes(a: Map<string, string>, b: Map<string, string>): boolean {
   if (a.size !== b.size) return false;
   for (const [path, hash] of a) if (b.get(path) !== hash) return false;