mixdog 1.3.1 → 1.3.3

package/src/runtime/shared/worktrees/registry.mjs

@@ -6,15 +6,18 @@
  * transaction ledger that makes creation rollback and deletion resumable:
  * which resources this transaction created ('pending' is written before a
  * resource is made, 'created' after), the deletion decision and any recovery
- * diagnostics. Writes are atomic (temp file + rename) under a file lock; an
- * unreadable registry is an error, never silently replaced.
+ * diagnostics. Writes are atomic (temp file + rename) under a file lock and keep
+ * the replaced version as registry.json.bak. A damaged registry (NUL, truncated,
+ * malformed) never blocks worktree operations: its bytes are kept aside as
+ * registry.json.corrupt-<ts>, the last good copy is restored when there is one,
+ * and otherwise the registry starts empty (worktree folders on disk are never
+ * touched by that).
  */
-import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { parseJsonText, withFileLock, writeJsonAtomicAsync } from '../atomic-file.mjs';
+import { readJsonState, readJsonStateSync, updateJsonAtomic } from '../atomic-file.mjs';
 import { isPlainObject } from '../object.mjs';
 import { resolvePluginData } from '../plugin-paths.mjs';
-import { normalizeWorktreeEntry, WORKTREE_STORE_DIR } from './contract.mjs';
+import { normalizeWorktreeEntry, WORKTREE_SNAPSHOT_KIND, WORKTREE_STORE_DIR } from './contract.mjs';
 
 const REGISTRY_VERSION = 1;
 
@@ -30,24 +33,21 @@ function emptyDoc() {
   return { version: REGISTRY_VERSION, entries: {} };
 }
 
-async function readDoc(path) {
-  let text;
-  try {
-    text = await readFile(path, 'utf8');
-  } catch (error) {
-    if (error?.code === 'ENOENT') return emptyDoc();
-    throw error;
-  }
-  const value = parseJsonText(text);
-  if (!isPlainObject(value) || !isPlainObject(value.entries)) {
-    throw new Error(`Worktree registry ${path} is malformed.`);
-  }
+const isRegistryDoc = (value) => isPlainObject(value) && isPlainObject(value.entries);
+
+function validateDoc(value) {
+  if (!isRegistryDoc(value)) throw new Error('Worktree registry is malformed.');
   return value;
 }
 
 /** Snapshot of every record (plain clones). */
 export async function readRegistry() {
-  return readDoc(registryPath());
+  return (await readJsonState(registryPath(), { validate: validateDoc })) ?? emptyDoc();
+}
+
+/** readRegistry for synchronous callers (the workspace admission gate). */
+export function readRegistrySync() {
+  return readJsonStateSync(registryPath(), { validate: validateDoc }) ?? emptyDoc();
 }
 
 /**
@@ -58,17 +58,17 @@ export async function readRegistry() {
  * @returns {Promise<T>}
  */
 export async function mutateRegistry(mutate) {
-  const path = registryPath();
-  return withFileLock(
-    `${path}.lock`,
-    async () => {
-      const doc = await readDoc(path);
-      const result = mutate(doc);
-      await writeJsonAtomicAsync(path, doc, { lock: false });
-      return result;
+  let result;
+  await updateJsonAtomic(
+    registryPath(),
+    (current) => {
+      const doc = isRegistryDoc(current) ? current : emptyDoc();
+      result = mutate(doc);
+      return doc;
     },
-    { timeoutMs: 15_000 }
+    { timeoutMs: 15_000, backup: true }
   );
+  return result;
 }
 
 export async function getRecord(id) {
@@ -106,5 +106,7 @@ export function entryView(record) {
     mergeTarget: record.mergeTarget ?? null,
     warnings: Array.isArray(record.warnings) ? [...record.warnings] : [],
     disposable: record.disposable === true,
+    // The session whose turn made a snapshot (it is removed when that turn settles).
+    ...(record.kind === WORKTREE_SNAPSHOT_KIND ? { holderSessionId: record.holderSessionId ?? null } : {}),
   };
 }

package/src/runtime/shared/worktrees/tool-host.mjs

@@ -0,0 +1,39 @@
+// Agent tool → session runtime channel for managed-worktree operations. The
+// `git` tool (a builtin with no workspace authority of its own) reaches the
+// runtime that hosts the calling Lead session through the host that runtime
+// registers here; a caller no host claims (a delegated worker, a bare tool
+// run) is no Lead and gets no worktree authority.
+//
+// Dependency-free, and shared through a global symbol like the sidebar host,
+// so every bundle copy of this module sees one registry.
+
+const HOSTS_KEY = Symbol.for('mixdog.worktreeToolHosts.v1');
+
+function hosts() {
+  globalThis[HOSTS_KEY] ??= [];
+  return globalThis[HOSTS_KEY];
+}
+
+/**
+ * Register a runtime's host: `sessionId()` is the Lead session it hosts now
+ * (null before one exists); `run(request, context)` performs one operation
+ * (session-runtime/workspace/worktree-tool.mjs).
+ * @param {{ sessionId: () => string|null, run: (request: object, context: object) => Promise<object> }} host
+ * @returns {() => void} Unregister.
+ */
+export function registerWorktreeToolHost(host) {
+  const entry = { sessionId: host.sessionId, run: host.run };
+  hosts().push(entry);
+  return () => {
+    const list = hosts();
+    const index = list.indexOf(entry);
+    if (index >= 0) list.splice(index, 1);
+  };
+}
+
+/** The host of Lead session `sessionId` (the most recently registered), or null. */
+export function worktreeToolHost(sessionId) {
+  const id = String(sessionId || '').trim();
+  if (!id) return null;
+  return hosts().findLast((entry) => entry.sessionId() === id) ?? null;
+}

package/src/runtime/tidy/core-install.mjs

@@ -76,6 +76,11 @@ function powerShellHost(env) {
   return false;
 }
 
+function coreInstallable(id, manifest, env) {
+  if (!TIDY_CORE_ENGINE_IDS.includes(id) || !manifestAsset(manifest, id)) return false;
+  return id !== 'psscriptanalyzer' || powerShellHost(env);
+}
+
 let installJob = null;
 let installInFlight = null;
 // Bumped on every job mutation and every refreshed host-module probe, so the
@@ -118,6 +123,14 @@ async function cachedHostModuleProbe(engine) {
   return entry?.version || '';
 }
 
+/** A host-module engine (PSScriptAnalyzer) whose host exists but whose first
+ *  probe has not answered yet. Until then "module missing" only means "not
+ *  looked at yet", so the status reports it as pending instead. */
+function hostModuleProbing(catalog, engine) {
+  if (!catalog.managedModule || engine.source !== 'missing' || !engine.command) return false;
+  return (hostModuleCache.get(String(engine.command))?.at || 0) === 0;
+}
+
 function clampPercent(value) {
   return Math.max(0, Math.min(100, Math.round(value)));
 }
@@ -222,14 +235,17 @@ async function runCoreInstall({
   signal = null,
   installEngines = installEnginesImpl,
   resolveEngines = resolveEnginesImpl,
+  engines: only = null,
 } = {}) {
   const loaded = manifest || readEnginesManifest();
   const toolsDir = pluginData ? managedToolsDir(pluginData) : '';
-  const job = startJob(TIDY_CORE_ENGINE_IDS);
+  // A retry for named engines installs just those; the default is the set.
+  const wanted = Array.isArray(only) ? TIDY_CORE_ENGINE_IDS.filter((id) => only.includes(id)) : TIDY_CORE_ENGINE_IDS;
+  const job = startJob(wanted);
   try {
     const resolution = await resolveEngines({
       cwd: resolutionScope(toolsDir),
-      engineIds: [...TIDY_CORE_ENGINE_IDS],
+      engineIds: [...wanted],
       pluginData,
       manifest: loaded,
       env,
@@ -238,7 +254,7 @@ async function runCoreInstall({
     });
     const resolved = new Map((resolution.engines || []).map((engine) => [engine.id, engine]));
     const pending = [];
-    for (const id of TIDY_CORE_ENGINE_IDS) {
+    for (const id of wanted) {
       const catalog = ENGINE_CATALOG[id];
       const engine = resolved.get(id);
       if (id === 'psscriptanalyzer' && !powerShellHost(env)) {
@@ -400,6 +416,7 @@ function withInstallStatus(inventory) {
     toolsDir: inventory.toolsDir,
     core: [...inventory.core],
     engines: inventory.engines.map((engine) => ({ ...engine })),
+    probing: inventory.probing,
     installing: tidyInstallStatus(),
   };
 }
@@ -424,6 +441,7 @@ async function buildEngineInventory({ pluginData, manifest, env, probeVersions,
     const source = statusSource(engine.source);
     const version = engine.version || '';
     const installHint = engine.installHint || catalog.installHint || '';
+    const probing = hostModuleProbing(catalog, engine);
     return {
       id,
       title: catalog.title || id,
@@ -437,7 +455,11 @@ async function buildEngineInventory({ pluginData, manifest, env, probeVersions,
       // Managed engines carry their on-disk cost; a host binary is the user's.
       ...(source === 'managed' ? { bytes: managedEngineBytes(pluginData, id, version) } : {}),
       ...(source === 'missing' && installHint ? { installHint } : {}),
+      // The host probe has not answered: pending, neither installed nor missing.
+      ...(probing ? { probing: true } : {}),
+      // A missing core engine the Install/Retry control can fetch right now.
+      ...(source === 'missing' && !probing && coreInstallable(id, loaded, env) ? { installable: true } : {}),
     };
   });
-  return { toolsDir, core: [...TIDY_CORE_ENGINE_IDS], engines };
+  return { toolsDir, core: [...TIDY_CORE_ENGINE_IDS], engines, probing: engines.some((engine) => engine.probing) };
 }

package/src/runtime/tidy/install.mjs

@@ -4,11 +4,12 @@
 // Policy gating happens BEFORE any network call: 'never' refuses, 'ask' returns
 // needsApproval unless the call carried approveDownloads:true, 'auto' proceeds.
 // Toolchain engines (rustfmt, gofmt, zig fmt, ...) are never downloadable.
-import { chmodSync, existsSync, mkdirSync, renameSync, rmSync, statSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { join } from 'node:path';
 import { MAX_NATIVE_BINARY_DOWNLOAD_BYTES, streamResponseToFile } from '../shared/bounded-download.mjs';
 import { platformEntryKey, platformKey, sha256File } from '../shared/native-asset.mjs';
+import { fileHasData } from '../shared/file-has-data.mjs';
 import { readJsonSafe } from '../shared/json-file.mjs';
 import { ENGINE_CATALOG } from './engines.mjs';
 import { extractArchive } from './extract.mjs';
@@ -51,7 +52,7 @@ export function managedEngineBinary({ id, manifest, pluginData }) {
   const binPath = String(found.asset.binPath || '');
   if (!binPath) return null;
   const full = join(managedEngineDir(pluginData, id, found.version), binPath);
-  return existsSync(full) ? { path: full, version: found.version } : null;
+  return fileHasData(full) ? { path: full, version: found.version } : null;
 }
 
 /** Throws unless `filePath` hashes to `expected`. */
@@ -148,44 +149,109 @@ export function planInstall({ ids = [], manifest, pluginData = '', policy = 'aut
   return { targets, present, errors, needsApproval: null };
 }
 
-async function downloadAsset(target, tmpDir, fetchFn, signal, onProgress) {
-  const archiveFile = join(tmpDir, `asset-${target.id}`);
-  const response = await fetchFn(target.url, { signal, redirect: 'follow' });
-  if (!response?.ok) {
-    throw new Error(`${LABEL} ${target.id}: HTTP ${response?.status || 0} for ${target.url}`);
+// A network switch can leave a socket open that never delivers another byte;
+// without a deadline the install (and the single in-flight job behind it)
+// would wait forever.
+const DEFAULT_STALL_TIMEOUT_MS = 60_000;
+// A `.tmp-<pid>-<ms>-…` staging dir whose owner crashed is never cleaned by
+// that owner; an hour is far beyond any live download.
+const STALE_TMP_AGE_MS = 60 * 60 * 1000;
+
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code === 'EPERM';
+  }
+}
+
+/** Remove staging dirs a killed install left behind (dead owner, or ancient). */
+function reclaimStaleStaging(engineRoot) {
+  let names;
+  try {
+    names = readdirSync(engineRoot);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const match = /^\.tmp-(\d+)-(\d+)-/.exec(name);
+    if (!match) continue;
+    const pid = Number(match[1]);
+    const ownerGone = pid !== process.pid && !pidAlive(pid);
+    if (!ownerGone && Date.now() - Number(match[2]) < STALE_TMP_AGE_MS) continue;
+    try {
+      rmSync(join(engineRoot, name), { recursive: true, force: true });
+    } catch {
+      /* best-effort */
+    }
   }
-  await streamResponseToFile(response, archiveFile, {
-    maxBytes: MAX_NATIVE_BINARY_DOWNLOAD_BYTES,
-    label: `${LABEL} ${target.id}`,
-    // Byte progress per engine: the desktop card renders it live, so the
-    // callback carries the engine id the bytes belong to.
-    ...(typeof onProgress === 'function'
-      ? {
-          onProgress: ({ downloaded, total }) => {
-            onProgress({ id: target.id, receivedBytes: downloaded, totalBytes: total });
-          },
+}
+
+async function downloadAsset(target, tmpDir, fetchFn, signal, onProgress, stallTimeoutMs) {
+  const archiveFile = join(tmpDir, `asset-${target.id}`);
+  const stalled = new AbortController();
+  const merged = signal ? AbortSignal.any([signal, stalled.signal]) : stalled.signal;
+  let timer;
+  const arm = () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => stalled.abort(), stallTimeoutMs);
+  };
+  arm();
+  try {
+    const response = await fetchFn(target.url, { signal: merged, redirect: 'follow' });
+    if (!response?.ok) {
+      throw new Error(`${LABEL} ${target.id}: HTTP ${response?.status || 0} for ${target.url}`);
+    }
+    await streamResponseToFile(response, archiveFile, {
+      maxBytes: MAX_NATIVE_BINARY_DOWNLOAD_BYTES,
+      label: `${LABEL} ${target.id}`,
+      signal: merged,
+      // Byte progress per engine: the desktop card renders it live, so the
+      // callback carries the engine id the bytes belong to. Any bytes also
+      // prove the connection is alive.
+      onProgress: ({ downloaded, total }) => {
+        arm();
+        if (typeof onProgress === 'function') {
+          onProgress({ id: target.id, receivedBytes: downloaded, totalBytes: total });
         }
-      : {}),
-  });
+      },
+    });
+  } catch (error) {
+    if (stalled.signal.aborted && !signal?.aborted) {
+      throw new Error(`${LABEL} ${target.id}: download stalled (no data for ${stallTimeoutMs / 1000}s)`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
   return archiveFile;
 }
 
 /** Download + verify + extract one engine into its versioned managed dir. */
 export async function installEngine(
   target,
-  { pluginData, fetchFn = globalThis.fetch, signal = null, onProgress = null } = {}
+  {
+    pluginData,
+    fetchFn = globalThis.fetch,
+    signal = null,
+    onProgress = null,
+    stallTimeoutMs = DEFAULT_STALL_TIMEOUT_MS,
+  } = {}
 ) {
   const engineRoot = join(managedToolsDir(pluginData), target.id);
   const finalDir = managedEngineDir(pluginData, target.id, target.version);
   const binFull = join(finalDir, target.binPath);
-  if (existsSync(binFull)) {
+  // An engine binary a crash left NUL-filled is not present: it is installed again.
+  if (fileHasData(binFull)) {
     return { id: target.id, version: target.version, path: binFull, bytes: 0, status: 'present' };
   }
   mkdirSync(engineRoot, { recursive: true });
+  reclaimStaleStaging(engineRoot);
   const tmpDir = join(engineRoot, `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
   mkdirSync(tmpDir, { recursive: true });
   try {
-    const archiveFile = await downloadAsset(target, tmpDir, fetchFn, signal, onProgress);
+    const archiveFile = await downloadAsset(target, tmpDir, fetchFn, signal, onProgress, stallTimeoutMs);
     await verifyDownloadDigest(archiveFile, target.sha256);
     const bytes = statSync(archiveFile).size;
     const stageDir = join(tmpDir, 'stage');
@@ -207,6 +273,7 @@ export async function installEngine(
       }
     }
     try {
+      if (existsSync(finalDir) && !fileHasData(binFull)) rmSync(finalDir, { recursive: true, force: true });
       renameSync(stageDir, finalDir);
     } catch (error) {
       // A concurrent install won the race; its verified copy is equivalent.
@@ -235,6 +302,7 @@ export async function installEngines({
   fetchFn = globalThis.fetch,
   signal = null,
   onProgress = null,
+  stallTimeoutMs = undefined,
 } = {}) {
   const loaded = manifest || readEnginesManifest();
   const plan = planInstall({ ids, manifest: loaded, pluginData, policy, approveDownloads });
@@ -249,7 +317,7 @@ export async function installEngines({
   }
   for (const target of plan.targets) {
     try {
-      installed.push(await installEngine(target, { pluginData, fetchFn, signal, onProgress }));
+      installed.push(await installEngine(target, { pluginData, fetchFn, signal, onProgress, stallTimeoutMs }));
     } catch (error) {
       errors.push({ id: target.id, error: error?.message || String(error) });
     }

package/src/runtime/tidy/process.mjs

@@ -4,7 +4,7 @@
 // binaries and file paths are untrusted input, so no value ever reaches a shell
 // parser.
 import { spawn } from 'node:child_process';
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { delimiter, extname, isAbsolute, join } from 'node:path';
 
 const DEFAULT_PROCESS_TIMEOUT_MS = 90_000;
@@ -36,19 +36,52 @@ function isExecutableFile(candidate) {
   }
 }
 
-/** First match for `name` on PATH, or null. Pure filesystem lookup, no spawn. */
-export function which(name, { env = process.env } = {}) {
+const pathDirs = (env) =>
+  String(env.PATH || env.Path || '')
+    .split(delimiter)
+    .map((value) => value.trim())
+    .filter(Boolean);
+
+const nameKey = (value) => (process.platform === 'win32' ? value.toLowerCase() : value);
+
+/**
+ * One PATH's directory listings, read once per directory on first use, for a
+ * batch of `which` lookups. Resolving the whole engine catalog probed every
+ * PATH dir × PATHEXT extension × engine name with its own statSync (≈17k
+ * synchronous stats on a 65-entry PATH); with an index a name that is on no
+ * directory costs no filesystem call at all.
+ */
+export function createPathIndex(env = process.env) {
+  const listings = new Map(); // dir -> Set of entry names, or null (unlistable)
+  return {
+    dirs: pathDirs(env),
+    has(dir, candidate) {
+      if (!listings.has(dir)) {
+        let names = null;
+        try {
+          names = new Set(readdirSync(dir).map(nameKey));
+        } catch {
+          // Unlistable (no list permission, gone): probe it per candidate.
+        }
+        listings.set(dir, names);
+      }
+      const names = listings.get(dir);
+      return names ? names.has(nameKey(candidate)) : true;
+    },
+  };
+}
+
+/** First match for `name` on PATH, or null. Pure filesystem lookup, no spawn.
+ *  `index` (createPathIndex over the same env) answers from directory listings. */
+export function which(name, { env = process.env, index = null } = {}) {
   const bin = String(name || '').trim();
   if (!bin) return null;
   if (isAbsolute(bin) || bin.includes('/') || bin.includes('\\')) {
     return existsSync(bin) ? bin : null;
   }
-  const dirs = String(env.PATH || env.Path || '')
-    .split(delimiter)
-    .map((value) => value.trim())
-    .filter(Boolean);
-  for (const dir of dirs) {
+  for (const dir of index ? index.dirs : pathDirs(env)) {
     for (const candidate of executableCandidates(bin)) {
+      if (index && !index.has(dir, candidate)) continue;
       const full = join(dir, candidate);
       if (isExecutableFile(full)) return full;
     }

package/src/runtime/tidy/resolve.mjs

@@ -7,7 +7,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ENGINE_CATALOG, ENGINE_IDS, engineEntry, enginesForLanguages } from './engines.mjs';
-import { mapLimit, runProcess, which } from './process.mjs';
+import { createPathIndex, mapLimit, runProcess, which } from './process.mjs';
 import { managedEngineBinary, manifestAsset, readEnginesManifest } from './install.mjs';
 
 const DOWNLOAD_POLICIES = Object.freeze(['ask', 'auto', 'never']);
@@ -113,9 +113,9 @@ export function projectConfigFileFor(cwd, entry) {
   return null;
 }
 
-function pathBinary(entry, env) {
+function pathBinary(entry, env, index) {
   for (const name of [entry.bin, ...(entry.altBins || [])]) {
-    const found = which(name, { env });
+    const found = which(name, { env, index });
     if (found) return { path: found, bin: name };
   }
   return null;
@@ -135,7 +135,7 @@ function installableFlag(entry, manifest) {
   return entry.managed && manifestAsset(manifest, entry.id) ? { installable: true } : {};
 }
 
-function resolveOne({ cwd, entry, config, env, manifest, pluginData }) {
+function resolveOne({ cwd, entry, config, env, manifest, pluginData, pathIndex }) {
   const base = {
     id: entry.id,
     kind: entry.kind,
@@ -159,7 +159,7 @@ function resolveOne({ cwd, entry, config, env, manifest, pluginData }) {
     return { ...base, source: 'missing', path: '', missing: true };
   }
   if (entry.managedModule) {
-    const host = pathBinary(entry, env);
+    const host = pathBinary(entry, env, pathIndex);
     if (!host) {
       return {
         ...base,
@@ -191,7 +191,7 @@ function resolveOne({ cwd, entry, config, env, manifest, pluginData }) {
       ...installableFlag(entry, manifest),
     };
   }
-  const onPath = pathBinary(entry, env);
+  const onPath = pathBinary(entry, env, pathIndex);
   if (onPath) return { ...base, source: 'path', path: onPath.path, ...commandFor(entry, onPath.path) };
   if (entry.managed && pluginData) {
     const managed = managedEngineBinary({ id: entry.id, manifest, pluginData });
@@ -282,9 +282,12 @@ export async function resolveEngines({
   else if (languages.length > 0) requested = enginesForLanguages(languages);
   const unknown = engineIds.filter((id) => !ENGINE_IDS.includes(id));
 
+  // One listing per PATH dir for the whole batch: this runs synchronously on
+  // the host loop (the desktop's Code Tidy status read at startup).
+  const pathIndex = createPathIndex(env);
   const resolved = requested.map((id) => {
     const entry = ENGINE_CATALOG[id];
-    const result = resolveOne({ cwd, entry, config, env, manifest: loadedManifest, pluginData });
+    const result = resolveOne({ cwd, entry, config, env, manifest: loadedManifest, pluginData, pathIndex });
     const configFile = projectConfigFileFor(cwd, entry);
     if (configFile) result.configFile = configFile;
     if (entry.requiresConfig && !configFile && result.source !== 'project-config') {

package/src/runtime/web-search/lib/config.mjs

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { resolvePluginData } from '../../shared/plugin-paths.mjs';
-import { renameWithRetrySync, writeJsonAtomicSync } from '../../shared/atomic-file.mjs';
+import { readJsonStateSync, writeJsonAtomicSync } from '../../shared/atomic-file.mjs';
 
 // Unified mode: web search shares the plugin data dir with the rest of mixdog.
 const SHARED_DATA_DIR = resolvePluginData();
@@ -19,22 +19,10 @@ export function ensureDataDir() {
   fs.mkdirSync(DATA_DIR, { recursive: true });
 }
 
+// usage/cache state: a damaged file (empty, NUL-filled, truncated) is kept as
+// <file>.corrupt-<ts> and reads as `fallback`, so search/fetch keep working.
 export function readJson(filePath, fallback) {
-  try {
-    const raw = fs.readFileSync(filePath, 'utf8');
-    try {
-      return JSON.parse(raw);
-    } catch (parseErr) {
-      try {
-        renameWithRetrySync(filePath, `${filePath}.corrupt.${Date.now()}`);
-      } catch {}
-      process.stderr.write(`[web-search-config] corrupt JSON backed up: ${filePath}\n`);
-      throw parseErr;
-    }
-  } catch (err) {
-    if (err.code === 'ENOENT') return fallback;
-    throw err;
-  }
+  return readJsonStateSync(filePath, { fallback });
 }
 
 export function writeJson(filePath, value) {