@vrtmrz/livesync-commonlib 0.1.42 → 0.1.43

package/dist/diagnostics/integrity.js

@@ -0,0 +1,674 @@
+import {
+  DOCID_SYNC_PARAMETERS,
+  EntryTypes,
+  MILESTONE_DOCID,
+  NODEINFO_DOCID,
+  SYNCINFO_ID,
+  VERSIONING_DOCID
+} from "../common/types.js";
+import { isChunk } from "../common/typeUtils.js";
+import { readAsBlob } from "../common/utils.js";
+import {
+  inspectMetadataDocumentIdentity,
+  MetadataDocumentIdentityStatuses
+} from "../serviceFeatures/offlineScanner.js";
+import { DiagnosticReadError } from "./types.js";
+const EXCLUDED_IDS = /* @__PURE__ */ new Set([
+  DOCID_SYNC_PARAMETERS,
+  MILESTONE_DOCID,
+  NODEINFO_DOCID,
+  SYNCINFO_ID,
+  VERSIONING_DOCID
+]);
+const INITIAL_COVERAGE = {
+  status: "not-checked",
+  documents: 0,
+  metadata: 0,
+  excluded: 0,
+  conflictBranches: 0,
+  contentReads: 0,
+  changedDuringRun: false
+};
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function isCurrentMetadata(value) {
+  return isRecord(value) && (value.type === EntryTypes.NOTE_BINARY || value.type === EntryTypes.NOTE_PLAIN);
+}
+function isValidCurrentMetadata(value) {
+  return typeof value._id === "string" && typeof value._rev === "string" && typeof value.path === "string" && Array.isArray(value.children) && value.children.every((child) => typeof child === "string");
+}
+function isMissingRead(error) {
+  if (error instanceof DiagnosticReadError) return error.missing;
+  if (!isRecord(error)) return false;
+  return error.status === 404 || error.name === "not_found" || error.error === "not_found";
+}
+function reasonFromReadError(error, fallback) {
+  return error instanceof DiagnosticReadError ? error.reason : fallback;
+}
+function hasUpdateSequence(value) {
+  return typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function appendError(errors, source, reason, details = {}) {
+  errors.push({ source, reason, ...details });
+}
+function progress(options, phase, processed) {
+  try {
+    options.onProgress?.({ phase, processed });
+  } catch {
+  }
+}
+function cancelled(options) {
+  return options.signal?.aborted === true;
+}
+function isConfigurationCurrent(options) {
+  try {
+    return options.isConfigurationCurrent();
+  } catch {
+    return false;
+  }
+}
+function isSkippedDocumentId(id) {
+  return isChunk(id) || id.startsWith("_local/") || id.startsWith("_design/") || EXCLUDED_IDS.has(id);
+}
+function makeSourceRun(name, source) {
+  return {
+    name,
+    source,
+    coverage: { ...INITIAL_COVERAGE, status: "partial" },
+    errors: [],
+    observations: [],
+    metadataScanComplete: false,
+    enumerationComplete: false,
+    endInfoAvailable: true
+  };
+}
+async function classifyObservation(options, run, document, branch, conflictCount, reference) {
+  if (!isValidCurrentMetadata(document)) {
+    appendError(run.errors, run.name, "invalid-metadata", {
+      id: typeof document._id === "string" ? document._id : void 0,
+      revision: typeof document._rev === "string" ? document._rev : void 0
+    });
+    return void 0;
+  }
+  try {
+    const identity = await inspectMetadataDocumentIdentity({ services: { path: options.path } }, document);
+    if (identity.status === MetadataDocumentIdentityStatuses.EXCLUDED) {
+      run.coverage.excluded++;
+      return void 0;
+    }
+    const rawPath = document.path;
+    const mismatch = identity.status === MetadataDocumentIdentityStatuses.UNRESOLVED ? identity.diagnostic.reason : void 0;
+    const report = {
+      reference,
+      source: run.name,
+      id: document._id,
+      ...typeof document._rev === "string" ? { revision: document._rev } : {},
+      path: rawPath,
+      ...identity.status === MetadataDocumentIdentityStatuses.CONSISTENT ? { expectedId: identity.expectedDocumentId } : identity.status === MetadataDocumentIdentityStatuses.UNRESOLVED && identity.diagnostic.expectedDocumentId ? { expectedId: identity.diagnostic.expectedDocumentId } : {},
+      identity: identity.status === MetadataDocumentIdentityStatuses.CONSISTENT ? "consistent" : mismatch === "namespace-mismatch" ? "namespace-mismatch" : "document-id-mismatch",
+      logicallyDeleted: Boolean(document.deleted || document._deleted),
+      branch,
+      conflictCount,
+      pathIsNFC: rawPath === rawPath.normalize("NFC"),
+      caseEquivalentPaths: false,
+      nfcEquivalentPaths: false,
+      content: {
+        status: "not-checked",
+        chunksRead: 0,
+        unavailableChunks: []
+      },
+      otherSourceGroup: "not-checked",
+      vault: { reference: `vault:${reference}`, status: "not-checked" },
+      comparisons: []
+    };
+    const observation = { report, source: run.source, document };
+    run.observations.push(observation);
+    if (branch === "winner") run.coverage.metadata++;
+    else run.coverage.conflictBranches++;
+    return observation;
+  } catch {
+    appendError(run.errors, run.name, "invalid-metadata", {
+      id: document._id,
+      revision: document._rev,
+      path: document.path
+    });
+    return void 0;
+  }
+}
+async function scanSource(options, run, nextReference, metadataProgress) {
+  if (cancelled(options)) return;
+  try {
+    const info = await run.source.info();
+    run.startSeq = info.update_seq;
+    if (!hasUpdateSequence(run.startSeq)) appendError(run.errors, run.name, "source-unavailable");
+  } catch {
+    appendError(run.errors, run.name, "source-unavailable");
+  }
+  if (cancelled(options)) return;
+  let enumerationComplete = false;
+  try {
+    for await (const id of run.source.enumerateIds()) {
+      if (cancelled(options)) return;
+      if (typeof id !== "string") {
+        appendError(run.errors, run.name, "source-unavailable");
+        continue;
+      }
+      run.coverage.documents++;
+      metadataProgress.processed++;
+      progress(options, "metadata", metadataProgress.processed);
+      if (isSkippedDocumentId(id)) {
+        run.coverage.excluded++;
+        continue;
+      }
+      if (cancelled(options)) return;
+      let winnerValue;
+      try {
+        winnerValue = await run.source.get(id, { conflicts: true });
+      } catch (error) {
+        if (cancelled(options)) return;
+        appendError(run.errors, run.name, reasonFromReadError(error, "document-unreadable"), { id });
+        continue;
+      }
+      if (cancelled(options)) return;
+      if (!isRecord(winnerValue) || winnerValue._id !== id) {
+        appendError(run.errors, run.name, "invalid-metadata", { id });
+        continue;
+      }
+      if (!isCurrentMetadata(winnerValue)) {
+        run.coverage.excluded++;
+        continue;
+      }
+      const winner = winnerValue;
+      if (!isValidCurrentMetadata(winner)) {
+        appendError(run.errors, run.name, "invalid-metadata", {
+          id,
+          revision: typeof winner._rev === "string" ? winner._rev : void 0
+        });
+        continue;
+      }
+      const conflictRevisions = Array.isArray(winner._conflicts) ? winner._conflicts.filter((revision) => typeof revision === "string") : [];
+      await classifyObservation(
+        options,
+        run,
+        winner,
+        "winner",
+        conflictRevisions.length,
+        nextReference(run.name)
+      );
+      if (cancelled(options)) return;
+      for (const revision of conflictRevisions) {
+        if (cancelled(options)) return;
+        let branchValue;
+        try {
+          branchValue = await run.source.get(id, { rev: revision, conflicts: true });
+        } catch (error) {
+          if (cancelled(options)) return;
+          appendError(run.errors, run.name, reasonFromReadError(error, "revision-unavailable"), {
+            id,
+            revision
+          });
+          continue;
+        }
+        if (cancelled(options)) return;
+        if (!isRecord(branchValue) || branchValue._id !== id || branchValue._rev !== revision) {
+          appendError(run.errors, run.name, "revision-unavailable", { id, revision });
+          continue;
+        }
+        if (!isCurrentMetadata(branchValue)) {
+          run.coverage.excluded++;
+          continue;
+        }
+        await classifyObservation(
+          options,
+          run,
+          branchValue,
+          "conflict",
+          conflictRevisions.length,
+          nextReference(run.name)
+        );
+      }
+    }
+    enumerationComplete = true;
+  } catch {
+    if (!cancelled(options)) appendError(run.errors, run.name, "source-unavailable");
+  }
+  if (cancelled(options)) return;
+  run.metadataScanComplete = enumerationComplete && run.errors.length === 0;
+  run.enumerationComplete = enumerationComplete;
+}
+function groupObservations(runs) {
+  const observations = runs.flatMap((run) => run.observations);
+  const parents = observations.map((_, index) => index);
+  const find = (index) => {
+    if (parents[index] !== index) parents[index] = find(parents[index]);
+    return parents[index];
+  };
+  const union = (left, right) => {
+    const leftRoot = find(left);
+    const rightRoot = find(right);
+    if (leftRoot !== rightRoot) parents[rightRoot] = leftRoot;
+  };
+  const byExpectedId = /* @__PURE__ */ new Map();
+  const byRawPath = /* @__PURE__ */ new Map();
+  observations.forEach((observation, index) => {
+    const { expectedId, path } = observation.report;
+    if (expectedId !== void 0) {
+      const previous = byExpectedId.get(expectedId);
+      if (previous === void 0) byExpectedId.set(expectedId, index);
+      else union(index, previous);
+    }
+    const previousPath = byRawPath.get(path);
+    if (previousPath === void 0) byRawPath.set(path, index);
+    else union(index, previousPath);
+  });
+  const groupsByRoot = /* @__PURE__ */ new Map();
+  observations.forEach((observation, index) => {
+    const root = find(index);
+    const group = groupsByRoot.get(root) ?? { key: `group:${root}`, observations: [], suspect: false };
+    group.observations.push(observation);
+    groupsByRoot.set(root, group);
+  });
+  return [...groupsByRoot.values()];
+}
+function markPathEquivalences(observations) {
+  const pathsByCaseFold = /* @__PURE__ */ new Map();
+  const pathsByNfc = /* @__PURE__ */ new Map();
+  for (const observation of observations) {
+    const path = observation.report.path;
+    const caseFold = path.toLowerCase();
+    const casePaths = pathsByCaseFold.get(caseFold) ?? /* @__PURE__ */ new Set();
+    casePaths.add(path);
+    pathsByCaseFold.set(caseFold, casePaths);
+    const nfc = path.normalize("NFC");
+    const nfcPaths = pathsByNfc.get(nfc) ?? /* @__PURE__ */ new Set();
+    nfcPaths.add(path);
+    pathsByNfc.set(nfc, nfcPaths);
+  }
+  for (const observation of observations) {
+    const path = observation.report.path;
+    observation.report.caseEquivalentPaths = (pathsByCaseFold.get(path.toLowerCase())?.size ?? 0) > 1;
+    observation.report.nfcEquivalentPaths = (pathsByNfc.get(path.normalize("NFC"))?.size ?? 0) > 1;
+  }
+}
+function markSuspectGroups(groups, runs) {
+  const crossSourceComparisonAvailable = runs.some((run) => run.name === "local" && run.metadataScanComplete) && runs.some((run) => run.name === "remote" && run.metadataScanComplete);
+  for (const group of groups) {
+    const observations = group.observations;
+    group.suspect = observations.some((observation) => observation.report.identity !== "consistent") || observations.some((observation) => observation.report.conflictCount > 0);
+    const claimsBySourceAndPath = /* @__PURE__ */ new Map();
+    for (const observation of observations) {
+      const key = `${observation.report.source}\0${observation.report.path}`;
+      const ids = claimsBySourceAndPath.get(key) ?? /* @__PURE__ */ new Set();
+      ids.add(observation.report.id);
+      claimsBySourceAndPath.set(key, ids);
+    }
+    if ([...claimsBySourceAndPath.values()].some((ids) => ids.size > 1)) group.suspect = true;
+    for (const observation of observations) {
+      const otherSource = observation.report.source === "local" ? "remote" : "local";
+      const otherRun = runs.find((run) => run.name === otherSource);
+      observation.report.otherSourceGroup = observations.some((other) => other.report.source === otherSource) ? "present" : otherRun?.metadataScanComplete ? "missing" : "not-checked";
+    }
+    if (!crossSourceComparisonAvailable) continue;
+    const localWinners = observations.filter(
+      (observation) => observation.report.source === "local" && observation.report.branch === "winner"
+    );
+    const remoteWinners = observations.filter(
+      (observation) => observation.report.source === "remote" && observation.report.branch === "winner"
+    );
+    if (localWinners.length === 0 || remoteWinners.length === 0) {
+      group.suspect = true;
+      continue;
+    }
+    const state = (observation) => `${observation.report.revision ?? ""}\0${observation.report.logicallyDeleted}`;
+    if (localWinners.some((local) => !remoteWinners.some((remote) => state(local) === state(remote))) || remoteWinners.some((remote) => !localWinners.some((local) => state(remote) === state(local)))) {
+      group.suspect = true;
+    }
+  }
+}
+function isValidChunk(value, id) {
+  return isRecord(value) && value._id === id && value.type === EntryTypes.CHUNK && typeof value.data === "string";
+}
+function getEdenChunk(document, id) {
+  const eden = document.eden;
+  if (!isRecord(eden)) return void 0;
+  const chunk = eden[id];
+  if (!isRecord(chunk) || typeof chunk.data !== "string") return void 0;
+  return chunk.data;
+}
+async function readObservationContent(options, observation, run) {
+  run.coverage.contentReads++;
+  const unavailableChunks = [];
+  const data = [];
+  let chunksRead = 0;
+  if (observation.document.type !== EntryTypes.NOTE_BINARY && observation.document.type !== EntryTypes.NOTE_PLAIN) {
+    appendError(run.errors, run.name, "unsupported-content", {
+      id: observation.report.id,
+      revision: observation.report.revision,
+      path: observation.report.path
+    });
+    return {
+      content: { status: "unreadable", reason: "unsupported-content" },
+      chunksRead,
+      unavailableChunks
+    };
+  }
+  for (const child of observation.document.children) {
+    if (cancelled(options)) return { content: { status: "not-checked" }, chunksRead, unavailableChunks };
+    const eden = getEdenChunk(observation.document, child);
+    if (eden !== void 0) {
+      data.push(eden);
+      chunksRead++;
+      continue;
+    }
+    try {
+      const chunk = await observation.source.get(child);
+      if (cancelled(options)) return { content: { status: "not-checked" }, chunksRead, unavailableChunks };
+      if (!isValidChunk(chunk, child) || chunk._deleted === true) {
+        unavailableChunks.push({ id: child, status: "unreadable" });
+        appendError(run.errors, run.name, "chunk-unreadable", {
+          id: observation.report.id,
+          revision: observation.report.revision,
+          path: observation.report.path,
+          chunkId: child
+        });
+        continue;
+      }
+      data.push(chunk.data);
+      chunksRead++;
+    } catch (error) {
+      if (cancelled(options)) return { content: { status: "not-checked" }, chunksRead, unavailableChunks };
+      if (isMissingRead(error)) {
+        const eden2 = getEdenChunk(observation.document, child);
+        if (eden2 !== void 0) {
+          data.push(eden2);
+          chunksRead++;
+          continue;
+        }
+        unavailableChunks.push({ id: child, status: "missing" });
+        appendError(run.errors, run.name, reasonFromReadError(error, "chunk-missing"), {
+          id: observation.report.id,
+          revision: observation.report.revision,
+          path: observation.report.path,
+          chunkId: child
+        });
+        continue;
+      }
+      unavailableChunks.push({ id: child, status: "unreadable" });
+      appendError(run.errors, run.name, reasonFromReadError(error, "chunk-unreadable"), {
+        id: observation.report.id,
+        revision: observation.report.revision,
+        path: observation.report.path,
+        chunkId: child
+      });
+    }
+  }
+  if (unavailableChunks.length > 0) {
+    const hasUnreadable = unavailableChunks.some((chunk) => chunk.status === "unreadable");
+    return {
+      content: {
+        status: hasUnreadable ? "unreadable" : "missing",
+        reason: hasUnreadable ? "chunk-unreadable" : "chunk-missing"
+      },
+      chunksRead,
+      unavailableChunks
+    };
+  }
+  try {
+    const loaded = {
+      ...observation.document,
+      data,
+      datatype: observation.document.type
+    };
+    const blob = readAsBlob(loaded);
+    const bytes = new Uint8Array(await blob.arrayBuffer());
+    if (cancelled(options)) return { content: { status: "not-checked" }, chunksRead, unavailableChunks };
+    return {
+      content: { status: "available", bytes },
+      chunksRead,
+      unavailableChunks
+    };
+  } catch {
+    if (cancelled(options)) return { content: { status: "not-checked" }, chunksRead, unavailableChunks };
+    appendError(run.errors, run.name, "unsupported-content", {
+      id: observation.report.id,
+      revision: observation.report.revision,
+      path: observation.report.path
+    });
+    return {
+      content: { status: "unreadable", reason: "unsupported-content" },
+      chunksRead,
+      unavailableChunks
+    };
+  }
+}
+function relation(left, right) {
+  if (left.status === "not-checked" || right.status === "not-checked") return "not-checked";
+  if (left.status !== "available" || right.status !== "available") return "unavailable";
+  if (left.bytes.length !== right.bytes.length) return "different";
+  for (let index = 0; index < left.bytes.length; index++) {
+    if (left.bytes[index] !== right.bytes[index]) return "different";
+  }
+  return "equal";
+}
+async function readVaultContent(options, path, errors) {
+  if (cancelled(options)) return { status: "not-checked" };
+  try {
+    const content = await options.readStorage(path);
+    if (cancelled(options)) return { status: "not-checked" };
+    if (content.status === "unreadable" || content.reason) {
+      appendError(errors, "storage", content.reason ?? "content-unreadable", { path });
+    }
+    return content;
+  } catch (error) {
+    if (cancelled(options)) return { status: "not-checked" };
+    const reason = error instanceof DiagnosticReadError ? error.reason : "content-unreadable";
+    appendError(errors, "storage", reason, { path });
+    return { status: "unreadable", reason };
+  }
+}
+async function inspectGroupContent(options, group, runsByName, errors, contentProgress) {
+  if (!group.suspect) return;
+  const byRawPath = /* @__PURE__ */ new Map();
+  for (const observation of group.observations) {
+    if (!byRawPath.has(observation.report.path)) byRawPath.set(observation.report.path, observation);
+  }
+  const vaultReferences = /* @__PURE__ */ new Map();
+  for (const [path, representative] of byRawPath) {
+    vaultReferences.set(path, `vault:${representative.report.reference}`);
+  }
+  for (const observation of group.observations) {
+    observation.report.comparisons = [
+      ...group.observations.filter((other) => other !== observation).map((other) => ({ against: other.report.reference, relation: "not-checked" })),
+      ...[...vaultReferences.values()].map((against) => ({ against, relation: "not-checked" }))
+    ];
+  }
+  const contentByObservation = /* @__PURE__ */ new Map();
+  const contentByReference = /* @__PURE__ */ new Map();
+  for (const observation of group.observations) {
+    if (cancelled(options)) return;
+    const run = runsByName.get(observation.report.source);
+    if (!run) continue;
+    const outcome = await readObservationContent(options, observation, run);
+    observation.report.content = {
+      status: outcome.content.status,
+      ...outcome.content.reason ? { reason: outcome.content.reason } : {},
+      chunksRead: outcome.chunksRead,
+      unavailableChunks: outcome.unavailableChunks
+    };
+    contentByObservation.set(observation, outcome.content);
+    contentByReference.set(observation.report.reference, outcome.content);
+    contentProgress.processed++;
+    progress(options, "content", contentProgress.processed);
+    if (cancelled(options)) return;
+  }
+  const vaultByPath = /* @__PURE__ */ new Map();
+  for (const [path] of byRawPath) {
+    if (cancelled(options)) return;
+    const vaultContent = await readVaultContent(options, path, errors);
+    vaultByPath.set(path, vaultContent);
+    const vaultReference = vaultReferences.get(path);
+    if (vaultReference) contentByReference.set(vaultReference, vaultContent);
+    for (const observation of group.observations) {
+      if (observation.report.path !== path) continue;
+      observation.report.vault = {
+        reference: vaultReference ?? `vault:${observation.report.reference}`,
+        status: vaultContent.status,
+        ...vaultContent.reason ? { reason: vaultContent.reason } : {}
+      };
+    }
+    if (cancelled(options)) return;
+  }
+  for (const observation of group.observations) {
+    const ownContent = contentByObservation.get(observation) ?? { status: "not-checked" };
+    for (const comparison of observation.report.comparisons) {
+      const comparedContent = contentByReference.get(comparison.against) ?? { status: "not-checked" };
+      comparison.relation = relation(ownContent, comparedContent);
+    }
+  }
+}
+function determineStatus(wasCancelled, errors, runs, configurationChanged) {
+  if (wasCancelled) return "cancelled";
+  if (configurationChanged || errors.length > 0) {
+    const anyCompletedSource = runs.some((run) => run.metadataScanComplete);
+    const allUnavailable = runs.length > 0 && runs.every((run) => run.coverage.status === "failed");
+    return allUnavailable && !anyCompletedSource ? "failed" : "partial";
+  }
+  if (runs.length === 0 || runs.some((run) => run.coverage.status !== "complete")) return "partial";
+  return "complete";
+}
+async function analyseDatabaseIntegrity(options) {
+  const errors = [];
+  const runs = [];
+  const metadataProgress = { processed: 0 };
+  const contentProgress = { processed: 0 };
+  const referenceNumbers = { local: 0, remote: 0 };
+  const nextReference = (source) => `${source}:${++referenceNumbers[source]}`;
+  let wasCancelled = cancelled(options);
+  let configurationChanged = false;
+  let ownedRemote;
+  if (!wasCancelled && !isConfigurationCurrent(options)) {
+    configurationChanged = true;
+    appendError(errors, "configuration", "configuration-changed");
+  }
+  try {
+    if (!wasCancelled && !configurationChanged) {
+      const localRun = makeSourceRun("local", options.local);
+      runs.push(localRun);
+      await scanSource(options, localRun, nextReference, metadataProgress);
+      if (!cancelled(options)) {
+        if (!options.remote) {
+          const remoteRun = { ...makeSourceRun("remote", options.local), source: options.local };
+          remoteRun.coverage.status = "failed";
+          remoteRun.endInfoAvailable = false;
+          appendError(errors, "remote", options.remoteUnavailableReason ?? "source-unavailable");
+          runs.push(remoteRun);
+        } else {
+          try {
+            ownedRemote = await options.remote();
+            if (cancelled(options)) {
+              wasCancelled = true;
+            } else {
+              const remoteRun = makeSourceRun("remote", ownedRemote);
+              runs.push(remoteRun);
+              await scanSource(options, remoteRun, nextReference, metadataProgress);
+            }
+          } catch {
+            if (cancelled(options)) {
+              wasCancelled = true;
+            } else {
+              const remoteRun = { ...makeSourceRun("remote", options.local), source: options.local };
+              remoteRun.coverage.status = "failed";
+              remoteRun.endInfoAvailable = false;
+              appendError(errors, "remote", options.remoteUnavailableReason ?? "source-unavailable");
+              runs.push(remoteRun);
+            }
+          }
+        }
+      }
+      if (cancelled(options)) wasCancelled = true;
+      if (!wasCancelled) {
+        const groups = groupObservations(runs);
+        markPathEquivalences(runs.flatMap((run) => run.observations));
+        markSuspectGroups(groups, runs);
+        const runsByName = new Map(runs.map((run) => [run.name, run]));
+        for (const group of groups) {
+          if (cancelled(options)) {
+            wasCancelled = true;
+            break;
+          }
+          await inspectGroupContent(options, group, runsByName, errors, contentProgress);
+          if (cancelled(options)) {
+            wasCancelled = true;
+            break;
+          }
+        }
+      }
+    }
+    if (!wasCancelled && !cancelled(options)) {
+      for (const run of runs) {
+        if (!run.endInfoAvailable) continue;
+        if (cancelled(options)) {
+          wasCancelled = true;
+          break;
+        }
+        try {
+          const info = await run.source.info();
+          run.endSeq = info.update_seq;
+          if (!hasUpdateSequence(run.endSeq)) {
+            appendError(run.errors, run.name, "source-unavailable");
+          } else if (hasUpdateSequence(run.startSeq) && run.startSeq !== run.endSeq) {
+            run.coverage.changedDuringRun = true;
+            appendError(run.errors, run.name, "source-changed");
+          }
+        } catch {
+          appendError(run.errors, run.name, "source-unavailable");
+        }
+      }
+    }
+  } finally {
+    if (ownedRemote) {
+      try {
+        await ownedRemote.close();
+      } catch {
+        appendError(errors, "remote", "source-unavailable");
+      }
+    }
+  }
+  if (cancelled(options)) wasCancelled = true;
+  if (!wasCancelled && !configurationChanged && !isConfigurationCurrent(options)) {
+    configurationChanged = true;
+    appendError(errors, "configuration", "configuration-changed");
+  }
+  for (const run of runs) {
+    if (run.coverage.status === "failed") continue;
+    const runHasErrors = run.errors.length > 0 || errors.some((error) => error.source === run.name);
+    run.coverage.status = wasCancelled ? run.coverage.documents > 0 || run.coverage.metadata > 0 ? "partial" : "not-checked" : runHasErrors ? run.coverage.metadata > 0 || run.enumerationComplete ? "partial" : "failed" : run.metadataScanComplete ? "complete" : "partial";
+    errors.push(...run.errors);
+  }
+  const coverage = {
+    local: { ...INITIAL_COVERAGE },
+    remote: { ...INITIAL_COVERAGE }
+  };
+  for (const run of runs) coverage[run.name] = { ...run.coverage };
+  const allObservations = runs.flatMap((run) => run.observations.map((observation) => observation.report));
+  const status = determineStatus(wasCancelled, errors, runs, configurationChanged);
+  return {
+    schemaVersion: 1,
+    kind: "integrity",
+    status,
+    settings: { ...options.settings },
+    coverage,
+    observations: allObservations,
+    errors,
+    scope: {
+      metadata: "normal-files-and-current-conflicts",
+      content: "suspect-groups-only",
+      history: "not-checked",
+      atomicSnapshot: false
+    }
+  };
+}
+export {
+  analyseDatabaseIntegrity
+};

package/dist/diagnostics/local.d.ts

@@ -0,0 +1,4 @@
+import type { EntryDoc } from "../common/types.js";
+import type { DiagnosticDatabaseSource } from "./types.js";
+/** Wrap an existing local handle without taking ownership or using chunk caches. */
+export declare function createLocalDiagnosticSource(database: Pick<PouchDB.Database<EntryDoc>, "info" | "allDocs" | "get">): DiagnosticDatabaseSource;