@vrtmrz/livesync-commonlib 0.1.42 → 0.1.44

package/dist/diagnostics/types.js

@@ -0,0 +1,13 @@
+class DiagnosticReadError extends Error {
+  constructor(reason, missing = false) {
+    super(reason);
+    this.reason = reason;
+    this.missing = missing;
+    this.name = "DiagnosticReadError";
+  }
+  reason;
+  missing;
+}
+export {
+  DiagnosticReadError
+};

package/dist/diagnostics/usage.d.ts

@@ -0,0 +1,55 @@
+export interface DatabaseUsageGetOptions {
+    revs?: boolean;
+    revs_info?: boolean;
+    conflicts?: boolean;
+    rev?: string;
+}
+export interface DatabaseUsageSource {
+    info(): Promise<{
+        update_seq?: string | number;
+    }>;
+    enumerateIds(): AsyncIterable<string>;
+    get(id: string, options?: DatabaseUsageGetOptions): Promise<object | null | undefined>;
+}
+export interface DatabaseUsageProgress {
+    phase: "reading" | "accounting";
+    idsProcessed: number;
+    revisionsProcessed: number;
+    processed: number;
+    total: number;
+    totalIsFinal: boolean;
+}
+export type DatabaseUsageStatus = "complete" | "partial" | "failed" | "cancelled";
+export type DatabaseUsageErrorCode = "start_info_read_failed" | "start_update_seq_unavailable" | "end_info_read_failed" | "end_update_seq_unavailable" | "configuration_changed" | "id_enumeration_failed" | "revision_list_read_failed" | "revision_not_found" | "revision_read_failed" | "revision_document_invalid";
+export interface DatabaseUsageError {
+    code: DatabaseUsageErrorCode;
+    id?: string;
+    revision?: string;
+}
+export interface DatabaseUsageRow {
+    title: string;
+    id: string;
+    path: string;
+    revision: string;
+    rev: string;
+    revHash: string;
+    uniqueChunkCount: number;
+    sharedChunkCount: number;
+    uniqueChunkSize: number;
+    sharedChunkSize: number;
+}
+export interface DatabaseUsageResult {
+    version: 1;
+    kind: "usage";
+    status: DatabaseUsageStatus;
+    startUpdateSeq?: string | number;
+    endUpdateSeq?: string | number;
+    changedDuringRun?: boolean;
+    rows: DatabaseUsageRow[];
+    errors: DatabaseUsageError[];
+}
+export declare function analyseDatabaseUsage(options: {
+    source: DatabaseUsageSource;
+    signal?: AbortSignal;
+    onProgress?: (progress: DatabaseUsageProgress) => void;
+}): Promise<DatabaseUsageResult>;

package/dist/diagnostics/usage.js

@@ -0,0 +1,345 @@
+const USAGE_ACCOUNTING_YIELD_EVERY = 64;
+function asRecord(value) {
+  return value;
+}
+function getRevisionNumber(revision) {
+  const generation = revision.split("-")[0];
+  return `${generation ? Number.parseInt(generation) : 0}`;
+}
+function getRevisionHash(revision) {
+  const hash = revision.split("-")[1];
+  if (hash === void 0) throw new Error("invalid revision");
+  return hash.substring(0, 6);
+}
+function getRevisionInfos(value) {
+  if (!Array.isArray(value)) return [];
+  return value;
+}
+function getChildren(value) {
+  const children = value ?? [];
+  if (!Array.isArray(children) || !children.every((child) => typeof child === "string")) {
+    throw new Error("invalid chunk references");
+  }
+  return new Set(children);
+}
+function getStringField(value) {
+  if (typeof value !== "string") throw new Error("invalid document field");
+  return value;
+}
+async function analyseDatabaseUsage(options) {
+  const { source, signal, onProgress } = options;
+  const errors = [];
+  const documentMap = /* @__PURE__ */ new Map();
+  const chunkMap = /* @__PURE__ */ new Map();
+  const progress = {
+    phase: "reading",
+    idsProcessed: 0,
+    revisionsProcessed: 0,
+    processed: 0,
+    total: 0,
+    totalIsFinal: false
+  };
+  let startUpdateSeq;
+  let endUpdateSeq;
+  let enumerationFailed = false;
+  const reportProgress = () => {
+    try {
+      onProgress?.({ ...progress });
+    } catch {
+    }
+  };
+  const isCancelled = () => signal?.aborted === true;
+  let cancelled = isCancelled();
+  let documentRevisionCount = 0;
+  let referenceCount = 0;
+  reportProgress();
+  if (isCancelled()) cancelled = true;
+  if (!cancelled) {
+    try {
+      const info = await source.info();
+      startUpdateSeq = info.update_seq;
+      if (startUpdateSeq === void 0) errors.push({ code: "start_update_seq_unavailable" });
+    } catch {
+      errors.push({ code: "start_info_read_failed" });
+    }
+    if (isCancelled()) cancelled = true;
+  }
+  let enumerationFinished = false;
+  try {
+    if (!cancelled && !isCancelled()) {
+      for await (const id of source.enumerateIds()) {
+        if (isCancelled()) {
+          cancelled = true;
+          break;
+        }
+        let revisionInfos = [];
+        let revisionList;
+        let revisionListReadFailed = false;
+        try {
+          revisionList = await source.get(id, { revs: true, revs_info: true, conflicts: true });
+        } catch {
+          if (!isCancelled()) {
+            errors.push({ code: "revision_list_read_failed", id });
+            revisionListReadFailed = true;
+          }
+        }
+        if (isCancelled()) {
+          cancelled = true;
+          break;
+        }
+        if (revisionList) revisionInfos = getRevisionInfos(asRecord(revisionList)._revs_info);
+        else if (!revisionListReadFailed) {
+          errors.push({ code: "revision_list_read_failed", id });
+        }
+        progress.idsProcessed++;
+        for (const revisionInfo of revisionInfos) {
+          if (revisionInfo.status === "available" && typeof revisionInfo.rev === "string") {
+            progress.total++;
+          }
+        }
+        reportProgress();
+        if (isCancelled()) {
+          cancelled = true;
+          break;
+        }
+        for (const revisionInfo of revisionInfos) {
+          if (isCancelled()) {
+            cancelled = true;
+            break;
+          }
+          if (revisionInfo.status !== "available") continue;
+          const revision = typeof revisionInfo.rev === "string" ? revisionInfo.rev : void 0;
+          if (revision === void 0) {
+            errors.push({ code: "revision_document_invalid", id });
+            continue;
+          }
+          let rawDocument;
+          try {
+            rawDocument = await source.get(id, { rev: revision });
+          } catch {
+            if (isCancelled()) {
+              cancelled = true;
+              break;
+            }
+            errors.push({ code: "revision_read_failed", id, revision });
+            progress.revisionsProcessed++;
+            progress.processed++;
+            reportProgress();
+            continue;
+          }
+          if (isCancelled()) {
+            cancelled = true;
+            break;
+          }
+          if (!rawDocument) {
+            errors.push({ code: "revision_not_found", id, revision });
+            progress.revisionsProcessed++;
+            progress.processed++;
+            reportProgress();
+            continue;
+          }
+          try {
+            const document = asRecord(rawDocument);
+            if ("children" in document) {
+              const documentId = getStringField(document._id);
+              const documentRevision = getStringField(document._rev);
+              const path = getStringField(document.path);
+              const chunks = getChildren(document.children);
+              const revisions = documentMap.get(documentId) ?? [];
+              revisions.push({
+                id: documentId,
+                revision: documentRevision,
+                path,
+                chunks,
+                uniqueChunks: /* @__PURE__ */ new Set(),
+                sharedChunks: /* @__PURE__ */ new Set(),
+                uniqueChunkSize: 0,
+                sharedChunkSize: 0
+              });
+              documentMap.set(documentId, revisions);
+              documentRevisionCount++;
+              referenceCount += chunks.size;
+            } else if (document.type === "leaf") {
+              const chunkId = getStringField(document._id);
+              if (!chunkMap.has(chunkId) && !document._deleted) {
+                if (typeof document.data !== "string") throw new Error("invalid chunk data");
+                chunkMap.set(chunkId, { length: document.data.length, refCount: 0 });
+              }
+            }
+          } catch {
+            errors.push({ code: "revision_document_invalid", id, revision });
+          }
+          progress.revisionsProcessed++;
+          progress.processed++;
+          reportProgress();
+        }
+        if (isCancelled()) cancelled = true;
+        if (cancelled) break;
+      }
+      if (!cancelled && !isCancelled()) enumerationFinished = true;
+    } else if (isCancelled()) {
+      cancelled = true;
+    }
+  } catch {
+    if (isCancelled()) cancelled = true;
+    else {
+      enumerationFailed = true;
+      errors.push({ code: "id_enumeration_failed" });
+    }
+  }
+  if (isCancelled()) cancelled = true;
+  if (enumerationFinished) {
+    progress.totalIsFinal = true;
+    reportProgress();
+    if (isCancelled()) cancelled = true;
+  }
+  const readingWasCancelled = cancelled;
+  progress.phase = "accounting";
+  progress.processed = 0;
+  progress.total = referenceCount + documentRevisionCount + chunkMap.size;
+  progress.totalIsFinal = true;
+  reportProgress();
+  let accountingCancelled = !readingWasCancelled && isCancelled();
+  const rows = [];
+  const accountingErrors = [];
+  const recordAccountingWork = () => {
+    progress.processed++;
+    return progress.processed % USAGE_ACCOUNTING_YIELD_EVERY === 0;
+  };
+  const yieldAfterAccountingBatch = async () => {
+    reportProgress();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    return readingWasCancelled || !isCancelled();
+  };
+  if (!readingWasCancelled && isCancelled()) accountingCancelled = true;
+  if (!accountingCancelled) {
+    for (const revisions of documentMap.values()) {
+      for (const document of revisions) {
+        for (const chunkId of document.chunks) {
+          const chunk = chunkMap.get(chunkId);
+          if (chunk) {
+            if (chunk.refCount === 0) {
+              document.uniqueChunks.add(chunkId);
+              document.uniqueChunkSize += chunk.length;
+            } else {
+              document.sharedChunks.add(chunkId);
+              document.sharedChunkSize += chunk.length;
+            }
+            chunk.refCount++;
+          }
+          if (recordAccountingWork() && !await yieldAfterAccountingBatch()) {
+            accountingCancelled = true;
+            break;
+          }
+        }
+        if (accountingCancelled) break;
+      }
+      if (accountingCancelled) break;
+    }
+  }
+  if (!accountingCancelled) {
+    for (const revisions of documentMap.values()) {
+      for (const document of revisions) {
+        const revisionNumber = getRevisionNumber(document.revision);
+        let revisionHash;
+        try {
+          revisionHash = getRevisionHash(document.revision);
+        } catch {
+          accountingErrors.push({
+            code: "revision_document_invalid",
+            id: document.id,
+            revision: document.revision
+          });
+          if (recordAccountingWork() && !await yieldAfterAccountingBatch()) {
+            accountingCancelled = true;
+            break;
+          }
+          continue;
+        }
+        rows.push({
+          title: `${document.path} (${document.revision})`,
+          id: document.id,
+          path: document.path,
+          revision: document.revision,
+          rev: revisionNumber,
+          revHash: revisionHash,
+          uniqueChunkCount: document.uniqueChunks.size,
+          sharedChunkCount: document.sharedChunks.size,
+          uniqueChunkSize: document.uniqueChunkSize,
+          sharedChunkSize: document.sharedChunkSize
+        });
+        if (recordAccountingWork() && !await yieldAfterAccountingBatch()) {
+          accountingCancelled = true;
+          break;
+        }
+      }
+      if (accountingCancelled) break;
+    }
+  }
+  let orphanChunkCount = 0;
+  let orphanChunkSize = 0;
+  if (!accountingCancelled) {
+    for (const chunk of chunkMap.values()) {
+      if (chunk.refCount === 0) {
+        orphanChunkCount++;
+        orphanChunkSize += chunk.length;
+      }
+      if (recordAccountingWork() && !await yieldAfterAccountingBatch()) {
+        accountingCancelled = true;
+        break;
+      }
+    }
+  }
+  if (accountingCancelled) {
+    cancelled = true;
+    rows.length = 0;
+  } else {
+    errors.push(...accountingErrors);
+    rows.push({
+      title: "__orphan",
+      id: "__orphan",
+      path: "__orphan",
+      revision: "1-xxxxx",
+      rev: "1",
+      revHash: "xxxxx",
+      uniqueChunkCount: orphanChunkCount,
+      sharedChunkCount: 0,
+      uniqueChunkSize: orphanChunkSize,
+      sharedChunkSize: 0
+    });
+  }
+  if (!cancelled && !isCancelled()) {
+    try {
+      const info = await source.info();
+      endUpdateSeq = info.update_seq;
+      if (endUpdateSeq === void 0) errors.push({ code: "end_update_seq_unavailable" });
+    } catch {
+      errors.push({ code: "end_info_read_failed" });
+    }
+  }
+  if (isCancelled()) cancelled = true;
+  reportProgress();
+  if (isCancelled()) cancelled = true;
+  const changedDuringRun = startUpdateSeq === void 0 || endUpdateSeq === void 0 ? void 0 : startUpdateSeq !== endUpdateSeq;
+  const snapshotUncertain = startUpdateSeq === void 0 || endUpdateSeq === void 0;
+  const hasDocumentRows = rows.length > 1;
+  let status;
+  if (cancelled) status = "cancelled";
+  else if (changedDuringRun === true || snapshotUncertain) status = "partial";
+  else if (enumerationFailed && !hasDocumentRows) status = "failed";
+  else if (errors.length > 0) status = "partial";
+  else status = "complete";
+  return {
+    version: 1,
+    kind: "usage",
+    status,
+    ...startUpdateSeq === void 0 ? {} : { startUpdateSeq },
+    ...endUpdateSeq === void 0 ? {} : { endUpdateSeq },
+    ...changedDuringRun === void 0 ? {} : { changedDuringRun },
+    rows,
+    errors
+  };
+}
+export {
+  analyseDatabaseUsage
+};

package/dist/pouchdb/encryption.d.ts

@@ -1,12 +1,14 @@
+import { Logger } from "../common/logger.js";
 import { type EntryDoc, type AnyEntry, type EntryLeaf, type DocumentID, type E2EEAlgorithm } from "../common/types.js";
 import { encryptWorker, decryptWorker, encryptHKDFWorker, decryptHKDFWorker } from "#worker";
 export declare const encrypt: typeof encryptWorker;
 export declare const decrypt: typeof decryptWorker;
 export declare const encryptHKDF: typeof encryptHKDFWorker;
 export declare const decryptHKDF: typeof decryptHKDFWorker;
+export declare function isEncryptedMeta<T extends AnyEntry>(doc: T): boolean;
 export declare let preprocessOutgoing: (doc: AnyEntry | EntryLeaf) => Promise<AnyEntry | EntryLeaf>;
 export declare let preprocessIncoming: (doc: EntryDoc) => Promise<EntryDoc>;
-export declare function getConfiguredFunctionsForEncryption(passphrase: string, useDynamicIterationCount: boolean, migrationDecrypt: boolean, getPBKDF2Salt: () => Promise<Uint8Array<ArrayBuffer>>, algorithm: E2EEAlgorithm, encryptInternalMetadata?: boolean): {
+export declare function getConfiguredFunctionsForEncryption(passphrase: string, useDynamicIterationCount: boolean, migrationDecrypt: boolean, getPBKDF2Salt: () => Promise<Uint8Array<ArrayBuffer>>, algorithm: E2EEAlgorithm, encryptInternalMetadata?: boolean, log?: typeof Logger): {
     incoming: (doc: AnyEntry | EntryLeaf) => Promise<AnyEntry | EntryLeaf>;
     outgoing: (doc: EntryDoc) => Promise<AnyEntry | EntryLeaf>;
 };

package/dist/pouchdb/encryption.js

@@ -32,20 +32,20 @@ function getEncryptionVersion(data) {
   }
   return EncryptionVersions.UNENCRYPTED;
 }
-async function tryDecryptV1AsFallback(encryptedData, passphrase, useDynamicIterationCount) {
+async function tryDecryptV1AsFallback(encryptedData, passphrase, useDynamicIterationCount, log = Logger) {
   try {
     return await decrypt(encryptedData, passphrase, useDynamicIterationCount);
   } catch (ex) {
     try {
-      Logger(
+      log(
         "Failed to decrypt with V1 method. Fallback to disable useDynamicIterationCount.",
         LOG_LEVEL_VERBOSE
       );
-      Logger(ex, LOG_LEVEL_VERBOSE);
+      log(ex, LOG_LEVEL_VERBOSE);
       return await decrypt(encryptedData, passphrase, false);
     } catch (ex2) {
-      Logger("Completely failed to decrypt with V1 method.", LOG_LEVEL_VERBOSE);
-      Logger(ex2, LOG_LEVEL_VERBOSE);
+      log("Completely failed to decrypt with V1 method.", LOG_LEVEL_VERBOSE);
+      log(ex2, LOG_LEVEL_VERBOSE);
       return false;
     }
   }
@@ -153,7 +153,7 @@ async function incomingEncryptHKDF(doc, passphrase, useDynamicIterationCount, ge
   }
   return saveDoc;
 }
-async function outgoingDecryptHKDF(doc, migrationDecrypt, decrypted, passphrase, useDynamicIterationCount, getPBKDF2Salt) {
+async function outgoingDecryptHKDF(doc, migrationDecrypt, decrypted, passphrase, useDynamicIterationCount, getPBKDF2Salt, log) {
   const loadDoc = {
     ...doc
   };
@@ -165,21 +165,26 @@ async function outgoingDecryptHKDF(doc, migrationDecrypt, decrypted, passphrase,
         loadDoc.data = await decryptHKDF(loadDoc.data, passphrase, pbkdf2salt);
         delete loadDoc.e_;
       } else if (encryptionVersion === EncryptionVersions.ENCRYPTED) {
-        const decryptedData = await tryDecryptV1AsFallback(loadDoc.data, passphrase, useDynamicIterationCount);
+        const decryptedData = await tryDecryptV1AsFallback(
+          loadDoc.data,
+          passphrase,
+          useDynamicIterationCount,
+          log
+        );
         if (decryptedData === false) {
-          Logger(MESSAGE_FALLBACK_DECRYPT_FAILED, LOG_LEVEL_NOTICE);
+          log(MESSAGE_FALLBACK_DECRYPT_FAILED, LOG_LEVEL_NOTICE);
           throw new Error(MESSAGE_FALLBACK_DECRYPT_FAILED);
         }
         loadDoc.data = decryptedData;
         delete loadDoc.e_;
       } else if (encryptionVersion === EncryptionVersions.UNENCRYPTED) {
       } else {
-        Logger("Unknown encryption version. Cannot decrypt.", LOG_LEVEL_NOTICE);
+        log("Unknown encryption version. Cannot decrypt.", LOG_LEVEL_NOTICE);
         throw new Error("Unknown encryption version. Cannot decrypt.");
       }
     } catch (ex) {
-      Logger(DECRYPTION_HKDF_FAILED, LOG_LEVEL_NOTICE);
-      Logger(ex);
+      log(DECRYPTION_HKDF_FAILED, LOG_LEVEL_NOTICE);
+      log(ex);
       throw ex;
     }
   }
@@ -192,16 +197,16 @@ async function outgoingDecryptHKDF(doc, migrationDecrypt, decrypted, passphrase,
           loadDoc[key] = metadata[key];
         }
       } catch (ex) {
-        Logger(`${DECRYPTION_HKDF_FAILED} on Path`, LOG_LEVEL_NOTICE);
-        Logger(ex);
+        log(`${DECRYPTION_HKDF_FAILED} on Path`, LOG_LEVEL_NOTICE);
+        log(ex);
         throw ex;
       }
     } else {
       const path = getPath(loadDoc);
       if (isPathProbablyObfuscated(path)) {
-        const decryptedPath = await tryDecryptV1AsFallback(path, passphrase, useDynamicIterationCount);
+        const decryptedPath = await tryDecryptV1AsFallback(path, passphrase, useDynamicIterationCount, log);
         if (decryptedPath === false) {
-          Logger(`${MESSAGE_FALLBACK_DECRYPT_FAILED} on Path`, LOG_LEVEL_NOTICE);
+          log(`${MESSAGE_FALLBACK_DECRYPT_FAILED} on Path`, LOG_LEVEL_NOTICE);
           throw new Error(MESSAGE_FALLBACK_DECRYPT_FAILED);
         }
         loadDoc.path = decryptedPath;
@@ -215,7 +220,8 @@ async function outgoingDecryptHKDF(doc, migrationDecrypt, decrypted, passphrase,
       const decryptedEden = await tryDecryptV1AsFallback(
         loadDoc.eden[EDEN_ENCRYPTED_KEY].data,
         passphrase,
-        useDynamicIterationCount
+        useDynamicIterationCount,
+        log
       );
       if (decryptedEden === false) throw new Error(MESSAGE_FALLBACK_DECRYPT_FAILED);
       readEden = {
@@ -224,8 +230,8 @@ async function outgoingDecryptHKDF(doc, migrationDecrypt, decrypted, passphrase,
       };
       edenDecrypted = true;
     } catch (ex) {
-      Logger(`${DECRYPTION_FALLBACK_FAILED} on Eden`, LOG_LEVEL_NOTICE);
-      Logger(ex);
+      log(`${DECRYPTION_FALLBACK_FAILED} on Eden`, LOG_LEVEL_NOTICE);
+      log(ex);
       throw ex;
     }
   }
@@ -243,8 +249,8 @@ async function outgoingDecryptHKDF(doc, migrationDecrypt, decrypted, passphrase,
       };
       edenDecrypted = true;
     } catch (ex) {
-      Logger(`${DECRYPTION_HKDF_FAILED} on Eden`, LOG_LEVEL_NOTICE);
-      Logger(ex);
+      log(`${DECRYPTION_HKDF_FAILED} on Eden`, LOG_LEVEL_NOTICE);
+      log(ex);
       throw ex;
     }
   }
@@ -296,7 +302,7 @@ async function incomingEncryptV1(doc, passphrase, useDynamicIterationCount) {
   }
   return saveDoc;
 }
-async function outgoingDecryptV1(doc, migrationDecrypt, decrypted, passphrase, useDynamicIterationCount) {
+async function outgoingDecryptV1(doc, migrationDecrypt, decrypted, passphrase, useDynamicIterationCount, log) {
   const loadDoc = {
     ...doc
   };
@@ -361,15 +367,15 @@ async function outgoingDecryptV1(doc, migrationDecrypt, decrypted, passphrase, u
           if (migrationDecrypt && ex2 instanceof SyntaxError) {
             return loadDoc;
           }
-          Logger("Decryption failed.", LOG_LEVEL_NOTICE);
-          Logger(ex2, LOG_LEVEL_VERBOSE);
-          Logger(`id:${loadDoc._id}-${loadDoc._rev?.substring(0, 10)}`, LOG_LEVEL_VERBOSE);
+          log("Decryption failed.", LOG_LEVEL_NOTICE);
+          log(ex2, LOG_LEVEL_VERBOSE);
+          log(`id:${loadDoc._id}-${loadDoc._rev?.substring(0, 10)}`, LOG_LEVEL_VERBOSE);
           throw ex2;
         }
       } else {
-        Logger("Decryption failed.", LOG_LEVEL_NOTICE);
-        Logger(ex, LOG_LEVEL_VERBOSE);
-        Logger(`id:${loadDoc._id}-${loadDoc._rev?.substring(0, 10)}`, LOG_LEVEL_VERBOSE);
+        log("Decryption failed.", LOG_LEVEL_NOTICE);
+        log(ex, LOG_LEVEL_VERBOSE);
+        log(`id:${loadDoc._id}-${loadDoc._rev?.substring(0, 10)}`, LOG_LEVEL_VERBOSE);
         throw ex;
       }
     }
@@ -382,7 +388,7 @@ let preprocessOutgoing = async (doc) => {
 let preprocessIncoming = async (doc) => {
   return await Promise.resolve(doc);
 };
-function getConfiguredFunctionsForEncryption(passphrase, useDynamicIterationCount, migrationDecrypt, getPBKDF2Salt, algorithm, encryptInternalMetadata = false) {
+function getConfiguredFunctionsForEncryption(passphrase, useDynamicIterationCount, migrationDecrypt, getPBKDF2Salt, algorithm, encryptInternalMetadata = false, log = Logger) {
   const decryptedCache = /* @__PURE__ */ new Map();
   const incoming = (doc) => algorithm === E2EEAlgorithms.V2 ? incomingEncryptHKDF(doc, passphrase, useDynamicIterationCount, getPBKDF2Salt, encryptInternalMetadata) : incomingEncryptV1(doc, passphrase, useDynamicIterationCount);
   const outgoing = (doc) => algorithm !== E2EEAlgorithms.ForceV1 ? outgoingDecryptHKDF(
@@ -391,8 +397,9 @@ function getConfiguredFunctionsForEncryption(passphrase, useDynamicIterationCoun
     decryptedCache,
     passphrase,
     useDynamicIterationCount,
-    getPBKDF2Salt
-  ) : outgoingDecryptV1(doc, migrationDecrypt, decryptedCache, passphrase, useDynamicIterationCount);
+    getPBKDF2Salt,
+    log
+  ) : outgoingDecryptV1(doc, migrationDecrypt, decryptedCache, passphrase, useDynamicIterationCount, log);
   return {
     incoming,
     outgoing
@@ -459,6 +466,7 @@ export {
   encrypt,
   encryptHKDF,
   getConfiguredFunctionsForEncryption,
+  isEncryptedMeta,
   preprocessIncoming,
   preprocessOutgoing,
   shouldDecryptEden,

package/dist/serviceFeatures/offlineScanner.d.ts

@@ -1,6 +1,7 @@
 import { type DocumentID, type FilePathWithPrefix, type FilePathWithPrefixLC, type MetaEntry, type UXFileInfoStub, type ObsidianLiveSyncSettings, type LOG_LEVEL } from "../common/types.js";
 import { type LogFunction } from "../services/lib/logUtils.js";
 import type { NecessaryServices } from "../interfaces/ServiceModule.js";
+import type { IPathService } from "../services/base/IService.js";
 import { UnresolvedErrorManager } from "../services/base/UnresolvedErrorManager.js";
 import { VaultScanResults, type VaultScanResult } from "../services/base/VaultScanResult.js";
 export { VaultScanResults };
@@ -105,7 +106,11 @@ export declare function getMetadataDocumentNamespace(value: string): MetadataDoc
  * separate consistent document for the same logical path may still proceed
  * through ordinary path-based handling.
  */
-export declare function inspectMetadataDocumentIdentity(host: NecessaryServices<"path", never>, doc: MetaEntry): Promise<MetadataDocumentIdentityInspection>;
+export declare function inspectMetadataDocumentIdentity(host: {
+    services: {
+        path: Pick<IPathService, "getPath" | "path2id">;
+    };
+}, doc: MetaEntry): Promise<MetadataDocumentIdentityInspection>;
 /**
  * Enumerate Metadata from its actual local document IDs and report only the
  * entries which ordinary path-based inspection cannot address.
@@ -139,7 +144,11 @@ export declare function collectDeletedFiles(host: NecessaryServices<"setting" |
  * @param doc Meta entry document
  * @returns Path string
  */
-export declare function getPathFromEntry(host: NecessaryServices<"path", never>, doc: MetaEntry): FilePathWithPrefix;
+export declare function getPathFromEntry(host: {
+    services: {
+        path: Pick<IPathService, "getPath">;
+    };
+}, doc: MetaEntry): FilePathWithPrefix;
 /**
  * Synchronise a single file between database and storage based on freshness comparison.
  * @param host Services container

package/dist/serviceModules/Rebuilder.js

@@ -183,7 +183,7 @@ Please enable them from the settings screen after setup is complete.`,
     await assertUniqueStoragePathIdentities(selected, this.path);
     if (databaseReady) {
       await assertMetadataPathIdentities(
-        this.database.localDatabase.findAllDocs(),
+        this.database.localDatabase.findAllDocs({ conflicts: true }),
         this.path,
         requireMatchingIds
       );