@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/dist/clients/project-snapshot.js

@@ -0,0 +1,1333 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+import { gunzipSync, gzipSync } from "node:zlib";
+import { writeFileAtomic } from "./atomic-write.js";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { getProjectDataDir } from "./file-utils.js";
+import { incrementDegradationCount } from "./degradation-ledger.js";
+import { withGenerationLockSync } from "./generation-lock.js";
+import { isStaleStageFile } from "./instance-reaper.js";
+import { readJsonCache } from "./json-cache-read.js";
+import { logLatency } from "./latency-logger.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { fingerprintProjectSnapshotJson } from "./project-snapshot-fingerprint.js";
+import { detectProjectConventions } from "./project-conventions.js";
+import { readWorkerHeapStatistics } from "./persist-worker-stats.js";
+import { deserializeWordIndex, recordPersistedWordIndexWireBytes, serializeWordIndex } from "./word-index.js";
+export const PROJECT_SNAPSHOT_VERSION = 2;
+function parseSequenceIndex(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const index = value;
+  if (typeof index.projectSeq !== "number")
+    return;
+  if (!Array.isArray(index.fileSeqByPath))
+    return;
+  const fileSeqByPath = index.fileSeqByPath.filter((entry) => Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "number");
+  return { projectSeq: index.projectSeq, fileSeqByPath };
+}
+export function getProjectSnapshotPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "project-snapshot.json.gz");
+}
+export function getProjectSnapshotLegacyPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "project-snapshot.json");
+}
+export function getProjectSnapshotMetaPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "cache", "project-snapshot.meta.json");
+}
+const INCOMPLETE_STORED_SEQ = -2;
+function storedSeq(snapshot) {
+  return snapshot.incomplete ? { seq: INCOMPLETE_STORED_SEQ, incompleteSeq: snapshot.seq } : { seq: snapshot.seq };
+}
+function storedSnapshot(snapshot) {
+  if (!snapshot.incomplete)
+    return snapshot;
+  const stored = { ...snapshot };
+  delete stored.incomplete;
+  return { ...stored, ...storedSeq(snapshot) };
+}
+function readStoredSeq(stored) {
+  if (typeof stored.incompleteSeq === "number") {
+    return { seq: stored.incompleteSeq, incomplete: true };
+  }
+  return typeof stored.seq === "number" ? { seq: stored.seq } : null;
+}
+export function isProjectSnapshotFresh(snapshot, currentProjectSeq, unlockedThrough = 0) {
+  return !!snapshot && snapshot.version === PROJECT_SNAPSHOT_VERSION && !snapshot.incomplete && (snapshot.logEntries ?? 0) >= unlockedThrough && snapshot.seq === currentProjectSeq;
+}
+function parseSnapshot(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const snapshot = value;
+  if (snapshot.version !== PROJECT_SNAPSHOT_VERSION)
+    return null;
+  if (typeof snapshot.projectRoot !== "string")
+    return null;
+  if (typeof snapshot.generatedAt !== "string")
+    return null;
+  const stored = readStoredSeq(value);
+  if (!stored)
+    return null;
+  if (!Array.isArray(snapshot.cachedExports))
+    return null;
+  return {
+    version: PROJECT_SNAPSHOT_VERSION,
+    projectRoot: snapshot.projectRoot,
+    generatedAt: snapshot.generatedAt,
+    seq: stored.seq,
+    files: snapshot.files ?? {},
+    symbols: snapshot.symbols ?? {},
+    reverseDeps: snapshot.reverseDeps ?? {},
+    cachedExports: snapshot.cachedExports.filter((entry) => Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "string"),
+    ...stored.incomplete ? { incomplete: true } : {},
+    logEntries: typeof snapshot.logEntries === "number" ? snapshot.logEntries : undefined,
+    sequenceIndex: parseSequenceIndex(snapshot.sequenceIndex),
+    wordIndex: snapshot.wordIndex,
+    projectRulesScan: snapshot.projectRulesScan,
+    startupScan: snapshot.startupScan,
+    languageProfile: snapshot.languageProfile,
+    conventions: snapshot.conventions
+  };
+}
+function parseSnapshotMeta(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const meta = value;
+  if (typeof meta.version !== "number")
+    return null;
+  const stored = readStoredSeq(value);
+  if (!stored)
+    return null;
+  return {
+    timestamp: typeof meta.timestamp === "string" ? meta.timestamp : "",
+    version: meta.version,
+    seq: stored.seq,
+    fingerprint: typeof meta.fingerprint === "string" && /^[a-f0-9]{64}$/.test(meta.fingerprint) ? meta.fingerprint : undefined,
+    gzBytes: typeof meta.gzBytes === "number" && Number.isInteger(meta.gzBytes) && meta.gzBytes > 0 ? meta.gzBytes : undefined,
+    ...stored.incomplete ? { incomplete: true } : {},
+    logEntries: typeof meta.logEntries === "number" ? meta.logEntries : undefined,
+    sequenceIndex: parseSequenceIndex(meta.sequenceIndex)
+  };
+}
+export function readProjectSnapshotMeta(cwd) {
+  const meta = readJsonCache(getProjectSnapshotMetaPath(cwd), (parsed) => parseSnapshotMeta(parsed) ?? undefined);
+  return meta ?? null;
+}
+export function isProjectSnapshotMetaStale(meta, currentProjectSeq, unlockedThrough = 0) {
+  return meta.version !== PROJECT_SNAPSHOT_VERSION || meta.incomplete === true || (meta.logEntries ?? 0) < unlockedThrough || meta.seq !== currentProjectSeq;
+}
+export const SNAPSHOT_PARSE_CACHE_MAX = 4;
+const SNAPSHOT_PARSE_CACHE_MAX_BYTES = 24 * 1024 * 1024;
+const snapshotParseCache = new BoundedFifoMap(SNAPSHOT_PARSE_CACHE_MAX);
+function withoutWordIndex(snapshot) {
+  if (!snapshot?.wordIndex)
+    return snapshot;
+  const { wordIndex: _releasedPostings, ...stripped } = snapshot;
+  return stripped;
+}
+function cacheParsedSnapshot(snapshotPath, entry) {
+  snapshotParseCache.delete(snapshotPath);
+  snapshotParseCache.set(snapshotPath, entry);
+}
+const authoritativeSnapshots = new Map;
+export const PROJECT_SNAPSHOT_MAX_WARM_ROOTS = 8;
+const PROJECT_SNAPSHOT_IDLE_EVICT_MS_DEFAULT = 20 * 60000;
+function projectSnapshotIdleEvictMs() {
+  const value = Number.parseInt(process.env.DM_LENS_PROJECT_SNAPSHOT_IDLE_EVICT_MS ?? "", 10);
+  return Number.isSafeInteger(value) && value > 0 ? value : PROJECT_SNAPSHOT_IDLE_EVICT_MS_DEFAULT;
+}
+function clearAuthoritativeSnapshotTimer(entry) {
+  if (entry.idleTimer)
+    clearTimeout(entry.idleTimer);
+  entry.idleTimer = undefined;
+}
+function deleteAuthoritativeSnapshot(key) {
+  const entry = authoritativeSnapshots.get(key);
+  if (entry)
+    clearAuthoritativeSnapshotTimer(entry);
+  authoritativeSnapshots.delete(key);
+}
+function scheduleAuthoritativeSnapshotEviction(key, entry) {
+  clearAuthoritativeSnapshotTimer(entry);
+  const generation = entry.lastUsedAt;
+  entry.idleTimer = setTimeout(() => {
+    entry.idleTimer = undefined;
+    if (authoritativeSnapshots.get(key) !== entry || entry.lastUsedAt !== generation)
+      return;
+    deleteAuthoritativeSnapshot(key);
+  }, projectSnapshotIdleEvictMs());
+  entry.idleTimer.unref?.();
+}
+function touchAuthoritativeSnapshot(key, entry) {
+  entry.lastUsedAt = Date.now();
+  scheduleAuthoritativeSnapshotEviction(key, entry);
+}
+function enforceAuthoritativeSnapshotCap() {
+  while (authoritativeSnapshots.size > PROJECT_SNAPSHOT_MAX_WARM_ROOTS) {
+    const victim = [...authoritativeSnapshots.entries()].sort(([, a], [, b]) => a.lastUsedAt - b.lastUsedAt)[0];
+    if (!victim)
+      return;
+    clearAuthoritativeSnapshotTimer(victim[1]);
+    deleteAuthoritativeSnapshot(victim[0]);
+  }
+}
+export function _getAuthoritativeSnapshotCacheKeysForTests() {
+  return [...authoritativeSnapshots.entries()].sort(([, a], [, b]) => a.lastUsedAt - b.lastUsedAt).map(([key]) => key);
+}
+export function _resetProjectSnapshotParseCacheForTests() {
+  snapshotParseCache.clear();
+  for (const entry of authoritativeSnapshots.values())
+    clearAuthoritativeSnapshotTimer(entry);
+  authoritativeSnapshots.clear();
+}
+export function _projectSnapshotParseCacheRetainsWordIndexForTests() {
+  return [...snapshotParseCache.values()].some((entry) => entry.snapshot?.wordIndex !== undefined);
+}
+function resolveSnapshotBodyPath(cwd) {
+  const gzPath = getProjectSnapshotPath(cwd);
+  try {
+    const stat = fs.statSync(gzPath);
+    return { path: gzPath, gz: true, mtimeMs: stat.mtimeMs, size: stat.size };
+  } catch {}
+  const legacyPath = getProjectSnapshotLegacyPath(cwd);
+  try {
+    const stat = fs.statSync(legacyPath);
+    return {
+      path: legacyPath,
+      gz: false,
+      mtimeMs: stat.mtimeMs,
+      size: stat.size
+    };
+  } catch {
+    return null;
+  }
+}
+let _snapshotBodyReadCountForTests = 0;
+export function getSnapshotBodyReadCountForTests() {
+  return _snapshotBodyReadCountForTests;
+}
+export function resetSnapshotBodyReadCountForTests() {
+  _snapshotBodyReadCountForTests = 0;
+}
+function readSnapshotBody(bodyPath, gz) {
+  _snapshotBodyReadCountForTests++;
+  if (!gz) {
+    const snapshot = readJsonCache(bodyPath, (parsed) => parseSnapshot(parsed) ?? undefined) ?? null;
+    let rawBytes = 0;
+    try {
+      rawBytes = fs.statSync(bodyPath).size;
+    } catch {}
+    return { snapshot, rawBytes };
+  }
+  try {
+    const json = gunzipSync(fs.readFileSync(bodyPath)).toString("utf-8");
+    const snapshot = parseSnapshot(JSON.parse(json)) ?? null;
+    return { snapshot, rawBytes: Buffer.byteLength(json) };
+  } catch (err) {
+    logLatency({
+      type: "phase",
+      phase: "project_snapshot_body_corrupt",
+      filePath: bodyPath,
+      durationMs: 0,
+      metadata: { error: err instanceof Error ? err.message : String(err) }
+    });
+    return { snapshot: null, rawBytes: 0 };
+  }
+}
+function skipJsonValue(text, start) {
+  let i = start;
+  while (i < text.length && /\s/.test(text[i]))
+    i++;
+  const ch = text[i];
+  if (ch === '"') {
+    i++;
+    while (i < text.length) {
+      if (text[i] === "\\") {
+        i += 2;
+        continue;
+      }
+      if (text[i] === '"') {
+        i++;
+        break;
+      }
+      i++;
+    }
+    return i;
+  }
+  if (ch === "{" || ch === "[") {
+    const open = ch;
+    const close = open === "{" ? "}" : "]";
+    let depth = 0;
+    let inString = false;
+    for (;i < text.length; i++) {
+      const c = text[i];
+      if (inString) {
+        if (c === "\\") {
+          i++;
+          continue;
+        }
+        if (c === '"')
+          inString = false;
+        continue;
+      }
+      if (c === '"') {
+        inString = true;
+        continue;
+      }
+      if (c === open)
+        depth++;
+      else if (c === close) {
+        depth--;
+        if (depth === 0) {
+          i++;
+          break;
+        }
+      }
+    }
+    return i;
+  }
+  while (i < text.length && !",}]".includes(text[i]))
+    i++;
+  return i;
+}
+function stripTopLevelJsonKeys(text, keysToStrip) {
+  const objStart = text.indexOf("{");
+  if (objStart === -1)
+    return text;
+  let out = text.slice(0, objStart + 1);
+  let i = objStart + 1;
+  let wroteField = false;
+  while (i < text.length) {
+    while (i < text.length && /\s/.test(text[i]))
+      i++;
+    if (text[i] === "}" || i >= text.length) {
+      out += text.slice(i);
+      break;
+    }
+    if (text[i] === ",") {
+      i++;
+      continue;
+    }
+    const keyStart = i;
+    const keyTextEnd = skipJsonValue(text, keyStart);
+    let key;
+    try {
+      key = JSON.parse(text.slice(keyStart, keyTextEnd));
+    } catch {
+      return text;
+    }
+    let j = keyTextEnd;
+    while (j < text.length && /\s/.test(text[j]))
+      j++;
+    const valueStart = j + 1;
+    const valueEnd = skipJsonValue(text, valueStart);
+    if (!keysToStrip.has(key)) {
+      out += (wroteField ? "," : "") + text.slice(keyStart, valueEnd);
+      wroteField = true;
+    }
+    i = valueEnd;
+  }
+  return out;
+}
+export function _stripTopLevelJsonKeysForTests(text, keysToStrip) {
+  return stripTopLevelJsonKeys(text, new Set(keysToStrip));
+}
+const HEAVY_SNAPSHOT_KEYS = new Set([
+  "wordIndex",
+  "files",
+  "symbols",
+  "reverseDeps"
+]);
+const NARROW_DIGEST_HEAVY_KEY_LITERALS = [
+  "wordIndex",
+  "files",
+  "symbols",
+  "reverseDeps"
+];
+let _lastNarrowParseDigestForTests;
+export function getLastNarrowParseDigestForTests() {
+  return _lastNarrowParseDigestForTests;
+}
+export function resetLastNarrowParseDigestForTests() {
+  _lastNarrowParseDigestForTests = undefined;
+}
+function parseExportsAndRulesOnly(json) {
+  const narrowed = stripTopLevelJsonKeys(json, HEAVY_SNAPSHOT_KEYS);
+  _lastNarrowParseDigestForTests = {
+    length: narrowed.length,
+    containsHeavyKey: NARROW_DIGEST_HEAVY_KEY_LITERALS.some((key) => narrowed.includes(`"${key}":`))
+  };
+  const parsed = JSON.parse(narrowed);
+  if (parsed.version !== PROJECT_SNAPSHOT_VERSION)
+    return null;
+  const stored = readStoredSeq(parsed);
+  if (!stored)
+    return null;
+  if (!Array.isArray(parsed.cachedExports))
+    return null;
+  return {
+    version: PROJECT_SNAPSHOT_VERSION,
+    seq: stored.seq,
+    ...stored.incomplete ? { incomplete: true } : {},
+    logEntries: typeof parsed.logEntries === "number" ? parsed.logEntries : undefined,
+    cachedExports: parsed.cachedExports.filter((entry) => Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "string"),
+    projectRulesScan: parsed.projectRulesScan
+  };
+}
+function readSnapshotExportsAndRulesBody(bodyPath, gz) {
+  try {
+    const json = gz ? gunzipSync(fs.readFileSync(bodyPath)).toString("utf-8") : fs.readFileSync(bodyPath, "utf-8");
+    return parseExportsAndRulesOnly(json);
+  } catch (err) {
+    logLatency({
+      type: "phase",
+      phase: "project_snapshot_body_corrupt",
+      filePath: bodyPath,
+      durationMs: 0,
+      metadata: {
+        error: err instanceof Error ? err.message : String(err),
+        narrow: true
+      }
+    });
+    return null;
+  }
+}
+export function loadProjectSnapshotExportsAndRules(cwd) {
+  const key = normalizeMapKey(cwd);
+  const body = resolveSnapshotBodyPath(cwd);
+  const authoritative = authoritativeSnapshots.get(key);
+  if (authoritative) {
+    const notSuperseded = body === null || body.mtimeMs <= authoritative.knownMtime && body.size === authoritative.knownSize;
+    if (notSuperseded) {
+      const { version, seq, incomplete, logEntries, cachedExports, projectRulesScan } = authoritative.snapshot;
+      return {
+        version,
+        seq,
+        ...incomplete ? { incomplete } : {},
+        logEntries,
+        cachedExports,
+        projectRulesScan
+      };
+    }
+  }
+  if (!body)
+    return null;
+  return readSnapshotExportsAndRulesBody(body.path, body.gz);
+}
+function loadProjectSnapshotInternal(cwd, requireWordIndex) {
+  const key = normalizeMapKey(cwd);
+  const body = resolveSnapshotBodyPath(cwd);
+  const authoritative = authoritativeSnapshots.get(key);
+  if (authoritative) {
+    const notSuperseded = body === null || body.mtimeMs <= authoritative.knownMtime && body.size === authoritative.knownSize;
+    if (notSuperseded) {
+      touchAuthoritativeSnapshot(key, authoritative);
+      return authoritative.snapshot;
+    }
+    deleteAuthoritativeSnapshot(key);
+  }
+  if (!body) {
+    snapshotParseCache.delete(getProjectSnapshotPath(cwd));
+    return null;
+  }
+  const cacheKey = body.path;
+  const cached = snapshotParseCache.get(cacheKey);
+  if (cached && cached.mtimeMs === body.mtimeMs && cached.size === body.size) {
+    if (!requireWordIndex || !cached.snapshot || cached.snapshot.wordIndex) {
+      return cached.snapshot;
+    }
+  }
+  const { snapshot, rawBytes } = readSnapshotBody(body.path, body.gz);
+  const cacheSnapshot = withoutWordIndex(snapshot);
+  if (rawBytes > 0 && (rawBytes <= SNAPSHOT_PARSE_CACHE_MAX_BYTES || snapshot?.wordIndex)) {
+    cacheParsedSnapshot(cacheKey, {
+      mtimeMs: body.mtimeMs,
+      size: body.size,
+      snapshot: cacheSnapshot
+    });
+  } else {
+    snapshotParseCache.delete(cacheKey);
+  }
+  return snapshot;
+}
+export function loadProjectSnapshot(cwd) {
+  return loadProjectSnapshotInternal(cwd, true);
+}
+export function loadProjectSnapshotWithoutWordIndex(cwd) {
+  return loadProjectSnapshotInternal(cwd, false);
+}
+const _snapshotGenerationStates = new Map;
+const _successfulSnapshotPersists = new BoundedFifoMap(PROJECT_SNAPSHOT_MAX_WARM_ROOTS);
+const _failedSnapshotPersists = new BoundedFifoMap(PROJECT_SNAPSHOT_MAX_WARM_ROOTS);
+const _activeSnapshotPersists = new Map;
+const _queuedSnapshotPersists = new Map;
+const _snapshotWorkerRequests = new Map;
+let _snapshotPersistWorker;
+let _snapshotWorkerRequestId = 0;
+let _snapshotWorkerDisabled = false;
+let _snapshotGenerationGateEnabledForTests = true;
+let _snapshotPromotionSeamForTests;
+let _lastSnapshotPersistErrorForTests;
+let _snapshotExiting = false;
+let _snapshotWorkerBodyWritesForTests = 0;
+let _snapshotPersistWorkerHeapStatistics = null;
+export function refreshProjectSnapshotPersistWorkerHeapStatistics() {
+  const worker = _snapshotPersistWorker;
+  if (!worker || typeof worker.getHeapStatistics !== "function") {
+    return Promise.resolve();
+  }
+  return readWorkerHeapStatistics(worker).then((stats) => {
+    if (_snapshotPersistWorker === worker)
+      _snapshotPersistWorkerHeapStatistics = stats;
+  }).catch(() => {});
+}
+export function getProjectSnapshotPersistWorkerHeapStatistics() {
+  return _snapshotPersistWorkerHeapStatistics;
+}
+function snapshotWorkerEnabled() {
+  const raw = process.env.DM_LENS_SNAPSHOT_PERSIST_SYNC;
+  return !(raw === "1" || raw === "true");
+}
+function pendingSnapshotIsCurrent(pending) {
+  return !_snapshotGenerationGateEnabledForTests || _snapshotGenerationStates.get(pending.key)?.generation === pending.generation;
+}
+function rememberSuccessfulSnapshotPersist(key, record) {
+  _successfulSnapshotPersists.delete(key);
+  _successfulSnapshotPersists.set(key, record);
+}
+function assessSnapshotBodyIntegrity(meta, body) {
+  if (meta.gzBytes === undefined) {
+    return { outcome: "legacy-meta", actualBytes: body.size };
+  }
+  if (!body.gz || body.size !== meta.gzBytes) {
+    return {
+      outcome: "size-mismatch",
+      expectedGzBytes: meta.gzBytes,
+      actualBytes: body.size
+    };
+  }
+  return {
+    outcome: "ok",
+    expectedGzBytes: meta.gzBytes,
+    actualBytes: body.size
+  };
+}
+function noteSnapshotBodyIntegrityWithheld(args) {
+  incrementDegradationCount({
+    kind: "snapshot-integrity",
+    subject: args.gzPath,
+    reason: args.verdict
+  });
+  logLatency({
+    type: "phase",
+    phase: "project_snapshot_body_integrity",
+    filePath: args.gzPath,
+    durationMs: 0,
+    metadata: {
+      outcome: "dedupe_withheld",
+      reason: args.verdict,
+      ...args.seq !== undefined ? { seq: args.seq } : {},
+      ...args.expectedGzBytes === undefined ? {} : { expectedGzBytes: args.expectedGzBytes },
+      actualBytes: args.actualBytes
+    }
+  });
+}
+function noteSnapshotSkipRefused(args) {
+  logLatency({
+    type: "phase",
+    phase: "project_snapshot_body_integrity",
+    filePath: args.gzPath,
+    durationMs: 0,
+    metadata: {
+      outcome: "skip_refused_rewrite",
+      reason: args.verdict,
+      seq: args.seq
+    }
+  });
+}
+function snapshotPersistBaselinesFor(cwd, key) {
+  const local = _successfulSnapshotPersists.get(key);
+  const meta = readProjectSnapshotMeta(cwd);
+  const body = resolveSnapshotBodyPath(cwd);
+  if (!meta?.fingerprint || !body) {
+    if (!body)
+      _successfulSnapshotPersists.delete(key);
+    return { fingerprints: [] };
+  }
+  const integrity = assessSnapshotBodyIntegrity(meta, body);
+  if (integrity.outcome !== "ok") {
+    noteSnapshotBodyIntegrityWithheld({
+      gzPath: getProjectSnapshotPath(cwd),
+      verdict: integrity.outcome,
+      seq: meta.seq,
+      expectedGzBytes: integrity.expectedGzBytes,
+      actualBytes: integrity.actualBytes
+    });
+    return { fingerprints: [] };
+  }
+  const durable = {
+    seq: meta.seq,
+    fingerprint: meta.fingerprint,
+    generatedAt: meta.timestamp,
+    generation: _snapshotGenerationStates.get(key)?.generation ?? 0,
+    gzBytes: meta.gzBytes
+  };
+  const fingerprints = [durable.fingerprint];
+  if (local && local.fingerprint !== durable.fingerprint) {
+    fingerprints.push(local.fingerprint);
+  }
+  return { durable, fingerprints, integrity: "ok" };
+}
+function seedSnapshotPersistBaselineFromDurable(key, durable) {
+  if (!durable || _successfulSnapshotPersists.has(key))
+    return;
+  rememberSuccessfulSnapshotPersist(key, durable);
+}
+function writeProjectSnapshotMeta(metaPath, snapshot, bodyRecord) {
+  writeFileAtomic(metaPath, JSON.stringify({
+    timestamp: bodyRecord?.generatedAt ?? snapshot.generatedAt,
+    version: snapshot.version,
+    ...storedSeq(snapshot),
+    ...bodyRecord ? {
+      fingerprint: bodyRecord.fingerprint,
+      ...bodyRecord.gzBytes === undefined ? {} : { gzBytes: bodyRecord.gzBytes }
+    } : {},
+    logEntries: snapshot.logEntries,
+    ...snapshot.sequenceIndex ? { sequenceIndex: snapshot.sequenceIndex } : {}
+  }), { bestEffort: false });
+}
+function recordSnapshotPersistFailure(pending, error, bodyPersisted = false) {
+  _lastSnapshotPersistErrorForTests = error;
+  _failedSnapshotPersists.set(pending.key, {
+    seq: pending.snapshot.seq,
+    generation: pending.generation
+  });
+  deleteAuthoritativeSnapshot(pending.key);
+  logLatency({
+    type: "phase",
+    phase: "project_snapshot_persist_failed",
+    filePath: pending.gzPath,
+    durationMs: 0,
+    metadata: {
+      error,
+      seq: pending.snapshot.seq,
+      outcome: bodyPersisted ? "metadata_repair_required" : "failed",
+      ...bodyPersisted ? { bodyPersisted: true } : {}
+    }
+  });
+}
+function logSnapshotPersistSuccess(pending, fingerprint, stats) {
+  rememberSuccessfulSnapshotPersist(pending.key, {
+    seq: pending.snapshot.seq,
+    fingerprint,
+    generatedAt: pending.snapshot.generatedAt,
+    generation: pending.generation,
+    rawBytes: stats.rawBytes,
+    gzBytes: stats.gzBytes
+  });
+  _failedSnapshotPersists.delete(pending.key);
+  logLatency({
+    type: "phase",
+    phase: "project_snapshot_persist",
+    filePath: pending.gzPath,
+    durationMs: stats.serializeMs + stats.writeMs,
+    metadata: { seq: pending.snapshot.seq, outcome: "executed", ...stats }
+  });
+}
+function logSnapshotPersistDecision(args) {
+  logLatency({
+    type: "phase",
+    phase: "project_snapshot_persist_decision",
+    filePath: getProjectSnapshotPath(args.cwd),
+    durationMs: 0,
+    metadata: {
+      seq: args.seq,
+      decision: args.decision,
+      ...args.fingerprint ? { fingerprint: args.fingerprint.slice(0, 12) } : {},
+      ...args.avoidedRawBytes === undefined ? {} : { avoidedRawBytes: args.avoidedRawBytes },
+      ...args.avoidedGzipBytes === undefined ? {} : { avoidedGzipBytes: args.avoidedGzipBytes },
+      ...args.diskSeq === undefined ? {} : { diskSeq: args.diskSeq }
+    }
+  });
+}
+function reconcileAuthoritativeAfterWrite(pending, rawBytes) {
+  const entry = authoritativeSnapshots.get(pending.key);
+  if (!entry || entry.snapshot !== pending.snapshot)
+    return;
+  if (pending.snapshot.wordIndex) {
+    try {
+      const stat = fs.statSync(pending.gzPath);
+      cacheParsedSnapshot(pending.gzPath, {
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+        snapshot: withoutWordIndex(pending.snapshot)
+      });
+    } catch {}
+    deleteAuthoritativeSnapshot(pending.key);
+    logLatency({
+      type: "phase",
+      phase: "project_snapshot_word_index_released",
+      filePath: pending.gzPath,
+      durationMs: 0,
+      metadata: { rawBytes }
+    });
+    return;
+  }
+  if (rawBytes > SNAPSHOT_PARSE_CACHE_MAX_BYTES) {
+    logLatency({
+      type: "phase",
+      phase: "project_snapshot_authoritative_dropped_oversized",
+      filePath: pending.gzPath,
+      durationMs: 0,
+      metadata: { rawBytes, maxBytes: SNAPSHOT_PARSE_CACHE_MAX_BYTES }
+    });
+    deleteAuthoritativeSnapshot(pending.key);
+    return;
+  }
+  try {
+    const stat = fs.statSync(pending.gzPath);
+    entry.knownMtime = stat.mtimeMs;
+    entry.knownSize = stat.size;
+  } catch {}
+}
+function finalizeProjectSnapshotMeta(pending, record) {
+  try {
+    writeProjectSnapshotMeta(getProjectSnapshotMetaPath(pending.cwd), pending.snapshot, record);
+    return true;
+  } catch (err) {
+    recordSnapshotPersistFailure(pending, err instanceof Error ? err.message : String(err), true);
+    return false;
+  }
+}
+function completeSnapshotPersist(pending) {
+  if (_activeSnapshotPersists.get(pending.key) !== pending)
+    return;
+  _activeSnapshotPersists.delete(pending.key);
+  if (_snapshotExiting)
+    return;
+  const queued = _queuedSnapshotPersists.get(pending.key);
+  if (!queued)
+    return;
+  _queuedSnapshotPersists.delete(pending.key);
+  dispatchSnapshotPersist(queued);
+}
+const SNAPSHOT_CACHE_LOCK = { staleMs: 5000, waitMs: 500 };
+function withSnapshotCacheLock(gzPath, purpose, op) {
+  const result = withGenerationLockSync(`${gzPath}.locks`, SNAPSHOT_CACHE_LOCK, op);
+  if (!result.held) {
+    const code = result.cause?.code;
+    incrementDegradationCount({
+      kind: "project-snapshot-lock-unavailable",
+      subject: gzPath,
+      reason: `${purpose} skipped: ${code ? `lock failed (${code})` : "lock wait ran out"}`
+    });
+  }
+  return result;
+}
+function promoteSnapshotBody(pending, body, record) {
+  const dropStage = () => {
+    if ("stagePath" in body)
+      fs.rmSync(body.stagePath, { force: true });
+  };
+  const locked = withSnapshotCacheLock(pending.gzPath, "body promotion", () => {
+    const onDisk = readProjectSnapshotMeta(pending.cwd);
+    if (onDisk && onDisk.seq > pending.snapshot.seq) {
+      dropStage();
+      return onDisk.seq;
+    }
+    if ("stagePath" in body)
+      fs.renameSync(body.stagePath, pending.gzPath);
+    else
+      writeFileAtomic(pending.gzPath, body.gzip, { bestEffort: false });
+    fs.rmSync(pending.legacyPath, { force: true });
+    return finalizeProjectSnapshotMeta(pending, record);
+  });
+  if (!locked.held) {
+    dropStage();
+    recordSnapshotPersistFailure(pending, "project snapshot cache lock unavailable");
+    return false;
+  }
+  if (typeof locked.value === "boolean")
+    return locked.value;
+  deleteAuthoritativeSnapshot(pending.key);
+  logSnapshotPersistDecision({
+    cwd: pending.cwd,
+    seq: pending.snapshot.seq,
+    decision: "superseded_on_disk",
+    diskSeq: locked.value
+  });
+  return false;
+}
+function serializeSnapshotBody(snapshot) {
+  const started = performance.now();
+  const stored = storedSnapshot(snapshot);
+  const spliced = stored.wordIndex === undefined ? undefined : spliceWordIndexBody(stored);
+  const bytes = spliced?.bytes ?? new TextEncoder().encode(JSON.stringify(stored));
+  return {
+    bytes,
+    serializeMs: performance.now() - started,
+    wordIndexWireBytes: spliced?.wordIndexWireBytes
+  };
+}
+const WORD_INDEX_PLACEHOLDER = `\x00dm-lens-word-index-${process.pid}-${Date.now()}\x00`;
+const WORD_INDEX_KEY_JSON = '"wordIndex":';
+const WORD_INDEX_PLACEHOLDER_JSON = `${WORD_INDEX_KEY_JSON}${JSON.stringify(WORD_INDEX_PLACEHOLDER)}`;
+function spliceWordIndexBody(stored) {
+  const marker = WORD_INDEX_PLACEHOLDER_JSON;
+  const head = JSON.stringify({ ...stored, wordIndex: WORD_INDEX_PLACEHOLDER });
+  const at = head.indexOf(marker);
+  if (at < 0)
+    return;
+  const prefix = head.slice(0, at + WORD_INDEX_KEY_JSON.length);
+  const suffix = head.slice(at + marker.length);
+  const wordIndex = JSON.stringify(stored.wordIndex);
+  const prefixBytes = Buffer.byteLength(prefix);
+  const wordIndexWireBytes = Buffer.byteLength(wordIndex);
+  const bytes = new Uint8Array(prefixBytes + wordIndexWireBytes + Buffer.byteLength(suffix));
+  const encoder = new TextEncoder;
+  encoder.encodeInto(prefix, bytes.subarray(0, prefixBytes));
+  encoder.encodeInto(wordIndex, bytes.subarray(prefixBytes, prefixBytes + wordIndexWireBytes));
+  encoder.encodeInto(suffix, bytes.subarray(prefixBytes + wordIndexWireBytes));
+  return { bytes, wordIndexWireBytes };
+}
+function writeSnapshotBodyOnMainThread(pending, reason) {
+  if (!pendingSnapshotIsCurrent(pending)) {
+    completeSnapshotPersist(pending);
+    return;
+  }
+  if (reason) {
+    logLatency({
+      type: "phase",
+      phase: "project_snapshot_worker_fallback",
+      filePath: pending.gzPath,
+      durationMs: 0,
+      metadata: {
+        reason,
+        seq: pending.snapshot.seq,
+        degraded: reason !== "exit_hook"
+      }
+    });
+  }
+  try {
+    const { bytes, serializeMs, wordIndexWireBytes } = serializeSnapshotBody(pending.snapshot);
+    pending.wordIndexWireBytes = wordIndexWireBytes;
+    const rawBytes = bytes.byteLength;
+    const fingerprint = fingerprintProjectSnapshotJson(bytes, pending.snapshot.generatedAt);
+    if (pending.dedupeFingerprints.includes(fingerprint)) {
+      const current = snapshotPersistBaselinesFor(pending.cwd, pending.key);
+      if (current.integrity === "ok") {
+        const prior = current.durable ?? pending.durablePersist;
+        if (authoritativeSnapshots.get(pending.key)?.snapshot === pending.snapshot) {
+          deleteAuthoritativeSnapshot(pending.key);
+        }
+        logSnapshotPersistDecision({
+          cwd: pending.cwd,
+          seq: pending.snapshot.seq,
+          fingerprint,
+          decision: "skipped_unchanged",
+          avoidedRawBytes: rawBytes,
+          avoidedGzipBytes: prior?.gzBytes
+        });
+        return;
+      }
+      if (current.integrity !== undefined) {
+        noteSnapshotSkipRefused({
+          gzPath: pending.gzPath,
+          verdict: current.integrity,
+          seq: pending.snapshot.seq
+        });
+      }
+    }
+    const writeStarted = performance.now();
+    const gzip = gzipSync(bytes);
+    fs.mkdirSync(path.dirname(pending.gzPath), { recursive: true });
+    const promoted = promoteSnapshotBody(pending, { gzip }, {
+      fingerprint,
+      generatedAt: pending.snapshot.generatedAt,
+      gzBytes: gzip.byteLength
+    });
+    if (!promoted)
+      return;
+    recordPersistedWordIndexWireBytes(pending.snapshot.wordIndex, pending.wordIndexWireBytes);
+    reconcileAuthoritativeAfterWrite(pending, rawBytes);
+    logSnapshotPersistSuccess(pending, fingerprint, {
+      rawBytes,
+      gzBytes: gzip.byteLength,
+      serializeMs,
+      writeMs: performance.now() - writeStarted,
+      offloaded: false
+    });
+    if (reason)
+      _lastSnapshotPersistErrorForTests = reason;
+  } catch (err) {
+    recordSnapshotPersistFailure(pending, err instanceof Error ? err.message : String(err));
+  } finally {
+    completeSnapshotPersist(pending);
+  }
+}
+function dispatchMainThreadWriteThroughSeam(pending, reason) {
+  if (_snapshotPromotionSeamForTests) {
+    _snapshotPromotionSeamForTests().then(() => writeSnapshotBodyOnMainThread(pending, reason));
+    return;
+  }
+  writeSnapshotBodyOnMainThread(pending, reason);
+}
+function handleSnapshotWorkerResult(result) {
+  const pending = _snapshotWorkerRequests.get(result.id);
+  if (!pending) {
+    fs.rmSync(result.stagePath, { force: true });
+    return;
+  }
+  _snapshotWorkerRequests.delete(result.id);
+  if (result.error || result.rawBytes === undefined || result.gzBytes === undefined || result.serializeMs === undefined || result.writeMs === undefined || result.semanticFingerprint === undefined) {
+    fs.rmSync(result.stagePath, { force: true });
+    dispatchMainThreadWriteThroughSeam(pending, result.error ?? "invalid worker result");
+    return;
+  }
+  if (!result.skippedUnchanged)
+    _snapshotWorkerBodyWritesForTests++;
+  if (_snapshotGenerationGateEnabledForTests && _snapshotGenerationStates.get(pending.key)?.generation !== result.generation) {
+    fs.rmSync(result.stagePath, { force: true });
+    completeSnapshotPersist(pending);
+    return;
+  }
+  if (result.skippedUnchanged) {
+    const baselines = snapshotPersistBaselinesFor(pending.cwd, pending.key);
+    if (baselines.integrity !== "ok") {
+      if (baselines.integrity !== undefined) {
+        noteSnapshotSkipRefused({
+          gzPath: pending.gzPath,
+          verdict: baselines.integrity,
+          seq: pending.snapshot.seq
+        });
+      }
+      dispatchMainThreadWriteThroughSeam(pending, "snapshot body integrity regressed");
+      return;
+    }
+    const prior = baselines.durable ?? pending.durablePersist;
+    if (authoritativeSnapshots.get(pending.key)?.snapshot === pending.snapshot) {
+      deleteAuthoritativeSnapshot(pending.key);
+    }
+    logSnapshotPersistDecision({
+      cwd: pending.cwd,
+      seq: pending.snapshot.seq,
+      fingerprint: result.semanticFingerprint,
+      decision: "skipped_unchanged",
+      avoidedRawBytes: result.rawBytes,
+      avoidedGzipBytes: prior?.gzBytes
+    });
+    completeSnapshotPersist(pending);
+    return;
+  }
+  try {
+    const promoted = promoteSnapshotBody(pending, { stagePath: result.stagePath }, {
+      fingerprint: result.semanticFingerprint,
+      generatedAt: pending.snapshot.generatedAt,
+      gzBytes: result.gzBytes
+    });
+    if (!promoted) {
+      completeSnapshotPersist(pending);
+      return;
+    }
+    recordPersistedWordIndexWireBytes(pending.snapshot.wordIndex, pending.wordIndexWireBytes);
+    reconcileAuthoritativeAfterWrite(pending, result.rawBytes);
+    logSnapshotPersistSuccess(pending, result.semanticFingerprint, {
+      rawBytes: result.rawBytes,
+      gzBytes: result.gzBytes,
+      serializeMs: pending.serializeMs ?? result.serializeMs,
+      writeMs: result.writeMs,
+      offloaded: true
+    });
+    completeSnapshotPersist(pending);
+  } catch (err) {
+    fs.rm(result.stagePath, { force: true }, () => {});
+    dispatchMainThreadWriteThroughSeam(pending, err instanceof Error ? err.message : String(err));
+  }
+}
+function dispatchSnapshotPersist(pending) {
+  const baselines = snapshotPersistBaselinesFor(pending.cwd, pending.key);
+  pending.durablePersist = baselines.durable;
+  pending.dedupeFingerprints = baselines.fingerprints;
+  seedSnapshotPersistBaselineFromDurable(pending.key, baselines.durable);
+  _activeSnapshotPersists.set(pending.key, pending);
+  if (!snapshotWorkerEnabled()) {
+    dispatchMainThreadWriteThroughSeam(pending, undefined);
+    return;
+  }
+  const worker = getSnapshotPersistWorker();
+  if (!worker) {
+    dispatchMainThreadWriteThroughSeam(pending, "persist worker unavailable");
+    return;
+  }
+  let serialized;
+  try {
+    serialized = serializeSnapshotBody(pending.snapshot);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    incrementDegradationCount({
+      kind: "project-snapshot-serialize-failed",
+      subject: pending.gzPath,
+      reason: `snapshot body serialization failed: ${message}`
+    });
+    recordSnapshotPersistFailure(pending, message);
+    completeSnapshotPersist(pending);
+    return;
+  }
+  pending.serializeMs = serialized.serializeMs;
+  pending.wordIndexWireBytes = serialized.wordIndexWireBytes;
+  const id = ++_snapshotWorkerRequestId;
+  _snapshotWorkerRequests.set(id, pending);
+  const request = {
+    id,
+    generation: pending.generation,
+    stagePath: pending.stagePath,
+    data: serialized.bytes,
+    generatedAt: pending.snapshot.generatedAt,
+    priorFingerprints: pending.dedupeFingerprints,
+    testDelayMs: undefined
+  };
+  try {
+    worker.postMessage(request, [serialized.bytes.buffer]);
+  } catch (err) {
+    _snapshotWorkerRequests.delete(id);
+    dispatchMainThreadWriteThroughSeam(pending, err instanceof Error ? err.message : String(err));
+  }
+}
+function handleSnapshotWorkerDeath(reason) {
+  _snapshotPersistWorker = undefined;
+  _snapshotPersistWorkerHeapStatistics = null;
+  _snapshotWorkerDisabled = true;
+  const requests = [..._snapshotWorkerRequests.values()];
+  _snapshotWorkerRequests.clear();
+  for (const pending of requests)
+    dispatchMainThreadWriteThroughSeam(pending, reason);
+}
+function resolveSnapshotPersistWorkerPath() {
+  const candidates = [
+    new URL("./project-snapshot-persist-worker.js", import.meta.url),
+    new URL("./workers/project-snapshot-persist-worker.js", import.meta.url),
+    new URL("../workers/project-snapshot-persist-worker.js", import.meta.url)
+  ];
+  for (const url of candidates) {
+    try {
+      const resolved = fileURLToPath(url);
+      if (fs.existsSync(resolved))
+        return resolved;
+    } catch {}
+  }
+  return;
+}
+function getSnapshotPersistWorker() {
+  if (_snapshotWorkerDisabled)
+    return;
+  if (_snapshotPersistWorker)
+    return _snapshotPersistWorker;
+  try {
+    const workerPath = resolveSnapshotPersistWorkerPath();
+    if (workerPath === undefined) {
+      handleSnapshotWorkerDeath("persist worker script not found in any layout");
+      return;
+    }
+    const worker = new Worker(workerPath);
+    worker.on("message", (result) => {
+      if (_snapshotPromotionSeamForTests) {
+        _snapshotPromotionSeamForTests().then(() => handleSnapshotWorkerResult(result));
+        return;
+      }
+      handleSnapshotWorkerResult(result);
+    });
+    worker.on("error", (err) => handleSnapshotWorkerDeath(err.message));
+    worker.on("exit", (code) => {
+      if (_snapshotPersistWorker === worker) {
+        _snapshotPersistWorker = undefined;
+        _snapshotPersistWorkerHeapStatistics = null;
+      }
+      const stranded = [..._snapshotWorkerRequests.values()];
+      if (stranded.length > 0) {
+        _snapshotWorkerRequests.clear();
+        for (const pending of stranded) {
+          dispatchMainThreadWriteThroughSeam(pending, `persist worker exited with code ${code}`);
+        }
+      }
+      if (code !== 0)
+        _snapshotWorkerDisabled = true;
+    });
+    worker.unref();
+    _snapshotPersistWorker = worker;
+    return worker;
+  } catch (err) {
+    handleSnapshotWorkerDeath(err instanceof Error ? err.message : String(err));
+    return;
+  }
+}
+const _sweptSnapshotStageDirs = new Set;
+function sweepStaleSnapshotStageFiles(cacheDir) {
+  if (_sweptSnapshotStageDirs.has(cacheDir))
+    return;
+  _sweptSnapshotStageDirs.add(cacheDir);
+  fs.readdir(cacheDir, (err, entries) => {
+    if (err)
+      return;
+    for (const entry of entries) {
+      if (!isStaleStageFile(entry, "project-snapshot.json.gz.stage-"))
+        continue;
+      fs.rm(path.join(cacheDir, entry), { force: true }, () => {});
+    }
+  });
+}
+function flushSnapshotPersistsAtExit() {
+  _snapshotExiting = true;
+  const latestByKey = new Map;
+  for (const pending of _snapshotWorkerRequests.values()) {
+    latestByKey.set(pending.key, pending);
+  }
+  for (const pending of _queuedSnapshotPersists.values()) {
+    const prior = latestByKey.get(pending.key);
+    if (!prior || prior.generation <= pending.generation) {
+      latestByKey.set(pending.key, pending);
+    }
+  }
+  _snapshotWorkerRequests.clear();
+  _queuedSnapshotPersists.clear();
+  _activeSnapshotPersists.clear();
+  for (const pending of latestByKey.values()) {
+    writeSnapshotBodyOnMainThread(pending, "exit_hook");
+  }
+  _snapshotPersistWorker?.terminate();
+}
+let _snapshotExitHookInstalled = false;
+function ensureSnapshotPersistExitHook() {
+  if (_snapshotExitHookInstalled)
+    return;
+  _snapshotExitHookInstalled = true;
+  process.once("exit", flushSnapshotPersistsAtExit);
+}
+export function runSnapshotPersistExitFlushForTests() {
+  flushSnapshotPersistsAtExit();
+}
+export function saveProjectSnapshot(cwd, snapshot) {
+  const gzPath = getProjectSnapshotPath(cwd);
+  const legacyPath = getProjectSnapshotLegacyPath(cwd);
+  const metaPath = getProjectSnapshotMetaPath(cwd);
+  const cacheDir = path.dirname(gzPath);
+  const key = normalizeMapKey(cwd);
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const baselines = snapshotPersistBaselinesFor(cwd, key);
+  const priorPersist = baselines.durable;
+  logSnapshotPersistDecision({
+    cwd,
+    seq: snapshot.seq,
+    decision: "requested"
+  });
+  if (_failedSnapshotPersists.delete(key)) {
+    logSnapshotPersistDecision({ cwd, seq: snapshot.seq, decision: "retry" });
+  }
+  withSnapshotCacheLock(gzPath, "admission meta write", () => {
+    const onDisk = readProjectSnapshotMeta(cwd);
+    if (!onDisk || onDisk.seq < snapshot.seq) {
+      writeProjectSnapshotMeta(metaPath, snapshot);
+    }
+  });
+  const priorBody = resolveSnapshotBodyPath(cwd);
+  const knownMtime = priorBody ? priorBody.mtimeMs : Number.NEGATIVE_INFINITY;
+  const knownSize = priorBody ? priorBody.size : Number.NEGATIVE_INFINITY;
+  const authoritativeEntry = {
+    snapshot,
+    knownMtime,
+    knownSize,
+    lastUsedAt: Date.now()
+  };
+  const previousAuthoritativeEntry = authoritativeSnapshots.get(key);
+  if (previousAuthoritativeEntry)
+    clearAuthoritativeSnapshotTimer(previousAuthoritativeEntry);
+  authoritativeSnapshots.set(key, authoritativeEntry);
+  scheduleAuthoritativeSnapshotEviction(key, authoritativeEntry);
+  enforceAuthoritativeSnapshotCap();
+  snapshotParseCache.delete(gzPath);
+  const generationState = _snapshotGenerationStates.get(key);
+  const generation = generationState?.seq === snapshot.seq ? generationState.generation : (generationState?.generation ?? 0) + 1;
+  _snapshotGenerationStates.set(key, { generation, seq: snapshot.seq });
+  const stagePath = `${gzPath}.stage-${process.pid}-${generation}`;
+  const pending = {
+    key,
+    cwd,
+    gzPath,
+    legacyPath,
+    stagePath,
+    snapshot,
+    generation,
+    durablePersist: priorPersist,
+    dedupeFingerprints: baselines.fingerprints
+  };
+  sweepStaleSnapshotStageFiles(cacheDir);
+  ensureSnapshotPersistExitHook();
+  if (_activeSnapshotPersists.has(key)) {
+    _queuedSnapshotPersists.set(key, pending);
+    logSnapshotPersistDecision({
+      cwd,
+      seq: snapshot.seq,
+      decision: "coalesced"
+    });
+    return;
+  }
+  dispatchSnapshotPersist(pending);
+}
+export async function waitForProjectSnapshotPersistsForTests() {
+  for (let attempts = 0;attempts < 200 && (_snapshotWorkerRequests.size > 0 || _activeSnapshotPersists.size > 0 || _queuedSnapshotPersists.size > 0); attempts++) {
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+}
+export function flushProjectSnapshotPersistsForTests() {
+  const requests = [..._snapshotWorkerRequests.values()];
+  _snapshotWorkerRequests.clear();
+  for (const pending of requests) {
+    dispatchMainThreadWriteThroughSeam(pending, undefined);
+  }
+}
+export async function terminateProjectSnapshotPersistWorkerForTests() {
+  const worker = _snapshotPersistWorker;
+  if (worker)
+    await worker.terminate();
+}
+export function resetProjectSnapshotPersistWorkerForTests() {
+  _snapshotWorkerDisabled = false;
+  _snapshotGenerationGateEnabledForTests = true;
+  _snapshotPromotionSeamForTests = undefined;
+  _snapshotPersistWorker = undefined;
+  _snapshotPersistWorkerHeapStatistics = null;
+  _snapshotWorkerRequests.clear();
+  _snapshotGenerationStates.clear();
+  _successfulSnapshotPersists.clear();
+  _failedSnapshotPersists.clear();
+  _activeSnapshotPersists.clear();
+  _queuedSnapshotPersists.clear();
+  _snapshotExiting = false;
+  _snapshotWorkerBodyWritesForTests = 0;
+  _lastSnapshotPersistErrorForTests = undefined;
+}
+export function getProjectSnapshotPersistStateForTests(cwd) {
+  const key = normalizeMapKey(cwd);
+  return {
+    active: _activeSnapshotPersists.has(key),
+    queued: _queuedSnapshotPersists.has(key),
+    successfulFingerprint: _successfulSnapshotPersists.get(key)?.fingerprint,
+    workerBodyWrites: _snapshotWorkerBodyWritesForTests
+  };
+}
+export function setProjectSnapshotGenerationGateForTests(enabled) {
+  _snapshotGenerationGateEnabledForTests = enabled;
+}
+export function setProjectSnapshotPromotionSeamForTests(seam) {
+  _snapshotPromotionSeamForTests = seam;
+}
+export function getProjectSnapshotPersistErrorForTests() {
+  return _lastSnapshotPersistErrorForTests;
+}
+export function _seedSnapshotParseCacheForTests(key, entry) {
+  cacheParsedSnapshot(key, entry);
+}
+export function _snapshotParseCacheKeysForTests() {
+  return [...snapshotParseCache.keys()];
+}
+export function _snapshotParseCacheGetForTests(key) {
+  return snapshotParseCache.get(key) !== undefined;
+}
+export function _seedSuccessfulSnapshotPersistForTests(key, record) {
+  rememberSuccessfulSnapshotPersist(key, record);
+}
+export function _successfulSnapshotPersistKeysForTests() {
+  return [..._successfulSnapshotPersists.keys()];
+}
+export function _successfulSnapshotPersistGetForTests(key) {
+  return _successfulSnapshotPersists.get(key) !== undefined;
+}
+export function _seedFailedSnapshotPersistForTests(key, record) {
+  _failedSnapshotPersists.set(key, record);
+}
+export function _failedSnapshotPersistKeysForTests() {
+  return [..._failedSnapshotPersists.keys()];
+}
+export function buildProjectSnapshotFromRuntime(args) {
+  const incomplete = args.runtime.viewMissesLoggedEntries;
+  return {
+    version: PROJECT_SNAPSHOT_VERSION,
+    projectRoot: normalizeMapKey(path.resolve(args.cwd)),
+    generatedAt: new Date().toISOString(),
+    seq: args.runtime.projectSeq,
+    ...incomplete ? { incomplete: true } : {},
+    logEntries: args.runtime.viewLogEntries,
+    files: {},
+    symbols: {},
+    reverseDeps: {},
+    cachedExports: [...args.runtime.cachedExports.entries()].sort((a, b) => a[0].localeCompare(b[0])),
+    sequenceIndex: incomplete ? undefined : {
+      projectSeq: args.runtime.projectSeq,
+      fileSeqByPath: args.runtime.getFileSeqEntries()
+    },
+    wordIndex: args.runtime.wordIndex ? serializeWordIndex(args.runtime.wordIndex) : undefined,
+    projectRulesScan: args.runtime.projectRulesScan,
+    startupScan: args.startupScan,
+    languageProfile: args.languageProfile,
+    conventions: args.conventions
+  };
+}
+export function hydrateRuntimeFromProjectSnapshot(runtime, snapshot) {
+  runtime.cachedExports.clear();
+  for (const [name, filePath] of snapshot.cachedExports) {
+    runtime.cachedExports.set(name, filePath);
+  }
+  if (snapshot.projectRulesScan) {
+    runtime.projectRulesScan = snapshot.projectRulesScan;
+  }
+  runtime.wordIndex = deserializeWordIndex(snapshot.wordIndex);
+}
+export function hydrateRuntimeFromProjectSnapshotIfIdle(runtime, snapshot) {
+  let hydratedAnything = false;
+  if (runtime.cachedExports.size === 0 && snapshot.cachedExports.length > 0) {
+    runtime.cachedExports.clear();
+    for (const [name, filePath] of snapshot.cachedExports) {
+      runtime.cachedExports.set(name, filePath);
+    }
+    hydratedAnything = true;
+  }
+  if (!runtime.projectRulesScan.hasCustomRules && runtime.projectRulesScan.rules.length === 0 && snapshot.projectRulesScan) {
+    runtime.projectRulesScan = snapshot.projectRulesScan;
+    hydratedAnything = true;
+  }
+  return hydratedAnything;
+}
+export function saveRuntimeProjectSnapshot(args) {
+  try {
+    if (typeof args.runtime.projectSeq !== "number")
+      return;
+    const existing = loadProjectSnapshot(args.cwd);
+    let conventions = args.conventions ?? existing?.conventions;
+    if (!conventions) {
+      try {
+        conventions = detectProjectConventions(args.cwd);
+      } catch (err) {
+        args.dbg?.(`project_snapshot: convention detection failed: ${err}`);
+      }
+    }
+    const snapshot = buildProjectSnapshotFromRuntime({
+      ...args,
+      startupScan: args.startupScan ?? existing?.startupScan,
+      languageProfile: args.languageProfile ?? existing?.languageProfile,
+      conventions
+    });
+    if (existing) {
+      snapshot.files = existing.files ?? {};
+      snapshot.symbols = existing.symbols ?? {};
+      snapshot.reverseDeps = existing.reverseDeps ?? {};
+      if (!snapshot.wordIndex && existing.wordIndex && existing.seq === snapshot.seq && (snapshot.incomplete || !existing.incomplete)) {
+        snapshot.wordIndex = existing.wordIndex;
+      }
+    }
+    saveProjectSnapshot(args.cwd, snapshot);
+    args.dbg?.(`project_snapshot: saved seq=${snapshot.seq} exports=${snapshot.cachedExports.length}`);
+  } catch (err) {
+    args.dbg?.(`project_snapshot: save failed: ${err}`);
+  }
+}