@vrtmrz/livesync-commonlib 0.1.33 → 0.1.35

package/dist/managers/ChunkFetcher.js

@@ -5,6 +5,11 @@ import { DEFAULT_SETTINGS } from "../common/types.js";
 import {} from "./ChunkManager.js";
 import { compatGlobal } from "../common/coreEnvFunctions.js";
 import { DEFAULT_CHUNK_DELIVERY_STALL_TIMEOUT_MS } from "./ChunkDeliveryCoordinator.js";
+import { chunkFetchCounts, collectingChunks } from "../mock_and_interop/stores.js";
+import {
+  classifyFetchedChunks,
+  decideMissingChunkAction
+} from "./chunkFetcher.helper.js";
 const EVENT_MISSING_CHUNKS = "missingChunks";
 const EVENT_MISSING_CHUNK_REMOTE = "missingChunkRemote";
 const EVENT_CHUNK_FETCHED = "chunkFetched";
@@ -19,6 +24,13 @@ class ChunkFetcher {
   }
   queue = [];
   pendingClaims = /* @__PURE__ */ new Map();
+  reportedPendingCount = 0;
+  reportedFetchCounts = { initial: 0, retrying: 0 };
+  requestTimer;
+  requestTimerDueAt = 0;
+  finiteActivityWasActive;
+  finiteCompletionVersion = 0;
+  stopObservingDelivery;
   destroyed = false;
   get interval() {
     const settings = this.options.settingService.currentSettings();
@@ -31,6 +43,18 @@ class ChunkFetcher {
   abort = new AbortController();
   constructor(options) {
     this.options = options;
+    this.finiteActivityWasActive = this.chunkManager.deliveryCoordinator.isFiniteReplicationActive();
+    this.stopObservingDelivery = this.chunkManager.deliveryCoordinator.onChanged(() => {
+      const active = this.chunkManager.deliveryCoordinator.isFiniteReplicationActive();
+      const completed = this.finiteActivityWasActive && !active;
+      this.finiteActivityWasActive = active;
+      if (!completed) return;
+      this.finiteCompletionVersion++;
+      for (const pending of this.pendingClaims.values()) {
+        if (pending.missingResponses > 0 && !pending.inFlight) pending.nextRequestAt = Date.now();
+      }
+      this.scheduleRequest();
+    });
     this.chunkManager.addListener(EVENT_MISSING_CHUNKS, this.onEventHandler, {
       signal: this.abort.signal
     });
@@ -39,9 +63,12 @@ class ChunkFetcher {
     if (this.destroyed) return;
     this.destroyed = true;
     this.abort.abort();
+    this.stopObservingDelivery();
+    this.clearRequestTimer();
     this.queue = [];
-    const pendingDeliveries = new Set(this.pendingClaims.values());
+    const pendingDeliveries = new Set([...this.pendingClaims.values()].map((pending) => pending.delivery));
     this.pendingClaims.clear();
+    this.updatePendingCount();
     for (const pending of pendingDeliveries) {
       pending.resolveActivityBoundary(false);
       pending.claim.release();
@@ -52,9 +79,35 @@ class ChunkFetcher {
     if (this.destroyed) return;
     const claimedIds = this.ensureClaims(ids);
     this.queue = unique([...this.queue, ...claimedIds]);
-    if (this.canRequestMore()) {
-      compatGlobal.setTimeout(() => void this.requestMissingChunks(), 1);
+    this.scheduleRequest(1);
+  }
+  clearRequestTimer() {
+    if (this.requestTimer !== void 0) compatGlobal.clearTimeout(this.requestTimer);
+    this.requestTimer = void 0;
+  }
+  scheduleRequest(minimumDelayMs = 0) {
+    if (this.destroyed || this.currentProcessing >= this.concurrency || this.queue.length === 0) {
+      this.clearRequestTimer();
+      return;
+    }
+    let nextRequestAt = Infinity;
+    for (const id of this.queue) {
+      const pending = this.pendingClaims.get(id);
+      if (!pending?.inFlight) nextRequestAt = Math.min(nextRequestAt, pending?.nextRequestAt ?? 0);
     }
+    if (nextRequestAt === Infinity) {
+      this.clearRequestTimer();
+      return;
+    }
+    const now = Date.now();
+    const dueAt = Math.max(nextRequestAt, now + minimumDelayMs);
+    if (this.requestTimer !== void 0 && this.requestTimerDueAt <= dueAt) return;
+    this.clearRequestTimer();
+    this.requestTimerDueAt = dueAt;
+    this.requestTimer = compatGlobal.setTimeout(() => {
+      this.requestTimer = void 0;
+      void this.requestMissingChunks();
+    }, dueAt - now);
   }
   ensureClaims(ids) {
     const unclaimedIds = unique(ids.filter((id) => !this.pendingClaims.has(id)));
@@ -71,8 +124,9 @@ class ChunkFetcher {
       resolveActivityBoundary: activityBoundary.resolve
     };
     for (const id of unclaimedIds) {
-      this.pendingClaims.set(id, pending);
+      this.pendingClaims.set(id, { delivery: pending, missingResponses: 0, nextRequestAt: 0, inFlight: false });
     }
+    this.updatePendingCount();
     void this.options.replicatorService.runBoundedRemoteActivity(
       () => {
         pending.claim.touch();
@@ -92,45 +146,142 @@ class ChunkFetcher {
   }
   removePendingDelivery(pending, ids) {
     for (const id of ids) {
-      if (this.pendingClaims.get(id) === pending) {
+      if (this.pendingClaims.get(id)?.delivery === pending) {
         this.pendingClaims.delete(id);
       }
     }
     const removed = new Set(ids);
     this.queue = this.queue.filter((id) => !(removed.has(id) && !this.pendingClaims.has(id)));
+    this.updatePendingCount();
+    this.scheduleRequest();
+  }
+  updatePendingCount() {
+    const nextCount = this.pendingClaims.size;
+    const difference = nextCount - this.reportedPendingCount;
+    this.reportedPendingCount = nextCount;
+    if (difference !== 0) collectingChunks.value += difference;
+    const nextFetchCounts = { initial: 0, retrying: 0 };
+    for (const pending of this.pendingClaims.values()) {
+      if (pending.missingResponses > 0) nextFetchCounts.retrying++;
+      else nextFetchCounts.initial++;
+    }
+    const initialDifference = nextFetchCounts.initial - this.reportedFetchCounts.initial;
+    const retryingDifference = nextFetchCounts.retrying - this.reportedFetchCounts.retrying;
+    this.reportedFetchCounts = nextFetchCounts;
+    if (initialDifference !== 0 || retryingDifference !== 0) {
+      chunkFetchCounts.value = {
+        initial: chunkFetchCounts.value.initial + initialDifference,
+        retrying: chunkFetchCounts.value.retrying + retryingDifference
+      };
+    }
   }
   onClaimStalled(pending, stalledIds) {
     pending.resolveActivityBoundary(false);
     this.removePendingDelivery(pending, stalledIds);
     Logger(`Chunk delivery stalled for the following IDs: ${stalledIds.join(", ")}`, LOG_LEVEL_VERBOSE);
   }
-  settleClaim(id) {
-    const pending = this.pendingClaims.get(id);
-    if (!pending) return;
+  settleClaim(id, pending) {
+    if (!pending || this.pendingClaims.get(id) !== pending) return;
     this.pendingClaims.delete(id);
-    pending.claim.settle(id);
+    pending.delivery.claim.settle(id);
+    this.updatePendingCount();
   }
-  touchClaims(ids) {
-    const pendingDeliveries = new Set(
-      ids.map((id) => this.pendingClaims.get(id)).filter((pending) => pending !== void 0)
-    );
+  getActiveClaimIds(ids, claims) {
+    return ids.filter((id) => claims.has(id) && this.pendingClaims.get(id) === claims.get(id));
+  }
+  touchClaims(ids, claims) {
+    const pendingDeliveries = new Set(this.getActiveClaimIds(ids, claims).map((id) => claims.get(id).delivery));
     for (const pending of pendingDeliveries) {
       pending.claim.touch();
     }
   }
-  async waitForActivityBoundary(ids) {
-    const pendingDeliveries = new Set(
-      ids.map((id) => this.pendingClaims.get(id)).filter((pending) => pending !== void 0)
-    );
+  async waitForActivityBoundary(claims) {
+    const pendingDeliveries = new Set([...claims.values()].map((pending) => pending.delivery));
     const entered = new Map(
       await Promise.all(
         [...pendingDeliveries].map(async (pending) => [pending, await pending.activityBoundaryEntered])
       )
     );
-    return ids.filter((id) => {
-      const pending = this.pendingClaims.get(id);
-      return pending !== void 0 && entered.get(pending) === true;
+    return [...claims].flatMap(
+      ([id, pending]) => this.pendingClaims.get(id) === pending && entered.get(pending.delivery) === true ? [id] : []
+    );
+  }
+  async waitBeforeRemoteRequest(ids, claims, localCheckCompletionVersion) {
+    this.touchClaims(ids, claims);
+    while (!this.destroyed) {
+      const activeIds = this.getActiveClaimIds(ids, claims);
+      if (activeIds.length === 0) return [];
+      if (localCheckCompletionVersion !== this.finiteCompletionVersion) {
+        localCheckCompletionVersion = this.finiteCompletionVersion;
+        await this.resolveLocallyAvailableRetries(claims);
+        continue;
+      }
+      const now = Date.now();
+      const timeToWait = this.previousRequestTime + this.interval - now;
+      if (timeToWait > 0) {
+        await delay(timeToWait);
+        continue;
+      }
+      this.previousRequestTime = now;
+      this.touchClaims(activeIds, claims);
+      return activeIds;
+    }
+    return [];
+  }
+  async resolveLocallyAvailableRetries(claims) {
+    const retryIds = this.getActiveClaimIds([...claims.keys()], claims).filter(
+      (id) => claims.get(id).missingResponses > 0
+    );
+    if (retryIds.length === 0) return;
+    const localChunks = await this.chunkManager.read(retryIds, {
+      preventRemoteRequest: true,
+      skipCache: true,
+      waitForDelivery: false
     });
+    for (const chunk of localChunks) {
+      if (!chunk) continue;
+      this.chunkManager.emitEvent(EVENT_CHUNK_FETCHED, chunk);
+      this.settleClaim(chunk._id, claims.get(chunk._id));
+    }
+  }
+  logFetchedChunks(requestedIds, { chunks, invalidChunks }) {
+    if (invalidChunks.length > 0) {
+      Logger(
+        `Some fetched chunks are invalid and will be ignored: (${invalidChunks.length} / ${chunks.length + invalidChunks.length}).`,
+        LOG_LEVEL_VERBOSE
+      );
+      for (const chunk of invalidChunks) {
+        Logger(`Invalid chunk: ${JSON.stringify(chunk)}`, LOG_LEVEL_VERBOSE);
+      }
+    }
+    if (chunks.length === 0) {
+      Logger(`No valid chunks were found for the following IDs: ${requestedIds.join(", ")}`);
+    }
+  }
+  applyMissingChunkResults(missingIds, requestClaims, requestCompletionVersion) {
+    for (const chunkID of this.getActiveClaimIds(missingIds, requestClaims)) {
+      const pending = requestClaims.get(chunkID);
+      const completedDuringRequest = requestCompletionVersion !== this.finiteCompletionVersion;
+      const action = decideMissingChunkAction({
+        missingResponses: pending.missingResponses,
+        finiteReplicationActive: this.chunkManager.deliveryCoordinator.isFiniteReplicationActive(),
+        completedDuringRequest
+      });
+      if (action.kind === "missing") {
+        this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+        this.settleClaim(chunkID, pending);
+      } else {
+        pending.missingResponses = action.missingResponses;
+        pending.inFlight = false;
+        pending.nextRequestAt = Date.now() + action.delayMs;
+        this.queue.push(chunkID);
+        Logger(
+          `Remote chunk is not available yet; retrying ${chunkID} in ${action.delayMs} ms.`,
+          LOG_LEVEL_VERBOSE
+        );
+      }
+    }
+    this.updatePendingCount();
   }
   /**
    * Processing requests
@@ -143,30 +294,39 @@ class ChunkFetcher {
    */
   previousRequestTime = 0;
   canRequestMore() {
-    return this.currentProcessing < this.concurrency && this.queue.length > 0;
+    return this.currentProcessing < this.concurrency && this.queue.some((id) => this.isReady(id));
+  }
+  isReady(id) {
+    const pending = this.pendingClaims.get(id);
+    return !pending || !pending.inFlight && pending.nextRequestAt <= Date.now();
   }
   async requestMissingChunks() {
     if (this.destroyed || !this.canRequestMore()) {
+      this.scheduleRequest();
       return;
     }
     let requestIDs = [];
+    const requestClaims = /* @__PURE__ */ new Map();
     try {
-      let isValidChunk2 = function(chunk) {
-        return chunk && typeof chunk?._id === "string" && typeof chunk?.data === "string";
-      };
-      var isValidChunk = isValidChunk2;
       this.currentProcessing++;
-      requestIDs = this.queue.splice(0, BATCH_SIZE);
+      requestIDs = unique(this.queue.filter((id) => this.isReady(id))).slice(0, BATCH_SIZE);
+      const selectedIds = new Set(requestIDs);
+      this.queue = this.queue.filter((id) => !selectedIds.has(id));
       this.ensureClaims(requestIDs);
-      requestIDs = await this.waitForActivityBoundary(requestIDs);
+      for (const id of requestIDs) {
+        const pending = this.pendingClaims.get(id);
+        if (pending) {
+          pending.inFlight = true;
+          requestClaims.set(id, pending);
+        }
+      }
+      this.scheduleRequest();
+      requestIDs = await this.waitForActivityBoundary(requestClaims);
       if (requestIDs.length === 0) return;
-      this.touchClaims(requestIDs);
-      const now = Date.now();
-      const timeSinceLastRequest = now - this.previousRequestTime;
-      this.previousRequestTime = now;
-      const timeToWait = Math.max(this.interval - timeSinceLastRequest, 0);
-      if (timeToWait > 0) await delay(timeToWait);
-      this.touchClaims(requestIDs);
+      const localCheckCompletionVersion = this.finiteCompletionVersion;
+      await this.resolveLocallyAvailableRetries(requestClaims);
+      let pendingIDs = await this.waitBeforeRemoteRequest(requestIDs, requestClaims, localCheckCompletionVersion);
+      if (pendingIDs.length === 0) return;
       const replicator = this.options.replicatorService.getActiveReplicator();
       if (!replicator) {
         Logger("No active replicator was found to request missing chunks.");
@@ -174,58 +334,46 @@ class ChunkFetcher {
       }
       if (!canFetchRemoteChunks(replicator)) {
         Logger("The active replicator does not support fetching individual remote chunks.");
-        for (const chunkID of requestIDs) {
+        for (const chunkID of pendingIDs) {
           this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
         }
         return;
       }
-      const fetched = await replicator.fetchRemoteChunks(requestIDs, false);
-      this.touchClaims(requestIDs);
+      const requestCompletionVersion = this.finiteCompletionVersion;
+      const fetched = await replicator.fetchRemoteChunks(pendingIDs, false);
+      pendingIDs = this.getActiveClaimIds(pendingIDs, requestClaims);
+      this.touchClaims(pendingIDs, requestClaims);
       if (!fetched) {
-        Logger(`No chunks were found for the following IDs: ${requestIDs.join(", ")}`);
-        for (const chunkID of requestIDs) {
+        Logger(`No chunks were found for the following IDs: ${pendingIDs.join(", ")}`);
+        for (const chunkID of pendingIDs) {
           this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
         }
         return;
       }
-      const chunks = fetched.filter((chunk) => isValidChunk2(chunk));
-      if (chunks.length !== fetched.length) {
-        Logger(
-          `Some fetched chunks are invalid and will be ignored: (${fetched.length - chunks.length} / ${fetched.length}).`,
-          LOG_LEVEL_VERBOSE
-        );
-        for (const chunk of fetched) {
-          if (!isValidChunk2(chunk)) {
-            Logger(`Invalid chunk: ${JSON.stringify(chunk)}`, LOG_LEVEL_VERBOSE);
-          }
-        }
-      }
-      if (chunks.length === 0) {
-        Logger(`No valid chunks were found for the following IDs: ${requestIDs.join(", ")}`);
-      }
-      const missingIDs = requestIDs.filter((id) => !chunks.some((chunk) => chunk._id === id));
+      const classification = classifyFetchedChunks(pendingIDs, fetched);
+      this.logFetchedChunks(pendingIDs, classification);
+      const { chunks, missingIds, invalidIds } = classification;
       try {
-        if (chunks.length === 0) {
-          return;
-        }
-        Logger(`Writing fetched chunks (${chunks.length}) to the database...`);
-        const result = await this.chunkManager.write(
-          chunks,
-          {
-            skipCache: true,
-            force: true
-            // Force writing to ensure the chunks with existing _rev.
-          },
-          "ChunkFetcher"
-        );
-        this.touchClaims(requestIDs);
-        if (result.result === true) {
-          Logger(`Fetched chunks were stored successfully: ${chunks.length}`, LOG_LEVEL_VERBOSE);
-        } else {
-          Logger(
-            `Fetched chunks could not be stored: ${chunks.map((chunk) => chunk._id).join(", ")}`,
-            LOG_LEVEL_VERBOSE
+        if (chunks.length > 0) {
+          Logger(`Writing fetched chunks (${chunks.length}) to the database...`);
+          const result = await this.chunkManager.write(
+            chunks,
+            {
+              skipCache: true,
+              force: true
+              // Force writing to ensure the chunks with existing _rev.
+            },
+            "ChunkFetcher"
           );
+          this.touchClaims(pendingIDs, requestClaims);
+          if (result.result === true) {
+            Logger(`Fetched chunks were stored successfully: ${chunks.length}`, LOG_LEVEL_VERBOSE);
+          } else {
+            Logger(
+              `Fetched chunks could not be stored: ${chunks.map((chunk) => chunk._id).join(", ")}`,
+              LOG_LEVEL_VERBOSE
+            );
+          }
         }
       } catch (error) {
         Logger(`An error occurred while storing fetched chunks!`, LOG_LEVEL_VERBOSE);
@@ -233,23 +381,24 @@ class ChunkFetcher {
       } finally {
         for (const chunk of chunks) {
           this.chunkManager.emitEvent(EVENT_CHUNK_FETCHED, chunk);
+          this.settleClaim(chunk._id, requestClaims.get(chunk._id));
         }
-        for (const chunkID of missingIDs) {
-          this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+        for (const invalidID of this.getActiveClaimIds(invalidIds, requestClaims)) {
+          this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, invalidID);
+          this.settleClaim(invalidID, requestClaims.get(invalidID));
         }
       }
+      this.applyMissingChunkResults(missingIds, requestClaims, requestCompletionVersion);
     } catch (error) {
       Logger("An error occurred while fetching remote chunks.", LOG_LEVEL_VERBOSE);
       Logger(error, LOG_LEVEL_VERBOSE);
     } finally {
-      for (const id of requestIDs) {
-        this.settleClaim(id);
+      for (const [id, pending] of requestClaims) {
+        if (pending.inFlight) this.settleClaim(id, pending);
       }
       this.currentProcessing--;
       this.previousRequestTime = Date.now();
-      if (this.queue.length > 0) {
-        compatGlobal.setTimeout(() => void this.requestMissingChunks(), 0);
-      }
+      this.scheduleRequest();
     }
   }
 }

package/dist/managers/chunkFetcher.helper.d.ts

@@ -0,0 +1,21 @@
+import type { DocumentID, EntryLeaf } from "../common/types.js";
+type MissingChunkAction = {
+    kind: "missing";
+} | {
+    kind: "retry";
+    missingResponses: number;
+    delayMs: number;
+};
+export declare function decideMissingChunkAction({ missingResponses, finiteReplicationActive, completedDuringRequest, }: {
+    missingResponses: number;
+    finiteReplicationActive: boolean;
+    completedDuringRequest: boolean;
+}): MissingChunkAction;
+export type FetchedChunkClassification = {
+    chunks: EntryLeaf[];
+    invalidChunks: unknown[];
+    missingIds: DocumentID[];
+    invalidIds: DocumentID[];
+};
+export declare function classifyFetchedChunks(requestedIds: readonly DocumentID[], fetched: readonly unknown[]): FetchedChunkClassification;
+export {};

package/dist/managers/chunkFetcher.helper.js

@@ -0,0 +1,43 @@
+const REMOTE_MISSING_RETRY_STEP_MS = 2e3;
+const REMOTE_MISSING_RETRY_MAX_DELAY_MS = 1e4;
+function decideMissingChunkAction({
+  missingResponses,
+  finiteReplicationActive,
+  completedDuringRequest
+}) {
+  if (missingResponses > 0 && !finiteReplicationActive && !completedDuringRequest) {
+    return { kind: "missing" };
+  }
+  const nextMissingResponses = missingResponses + 1;
+  return {
+    kind: "retry",
+    missingResponses: nextMissingResponses,
+    delayMs: completedDuringRequest ? 0 : Math.min(nextMissingResponses * REMOTE_MISSING_RETRY_STEP_MS, REMOTE_MISSING_RETRY_MAX_DELAY_MS)
+  };
+}
+function isValidChunk(chunk) {
+  const candidate = chunk;
+  return !!candidate && typeof candidate._id === "string" && typeof candidate.data === "string";
+}
+function classifyFetchedChunks(requestedIds, fetched) {
+  const chunks = [];
+  const invalidChunks = [];
+  const observedIds = /* @__PURE__ */ new Set();
+  for (const chunk of fetched) {
+    const candidate = chunk;
+    if (typeof candidate?._id === "string") observedIds.add(candidate._id);
+    if (isValidChunk(chunk)) chunks.push(chunk);
+    else invalidChunks.push(chunk);
+  }
+  const validIds = new Set(chunks.map((chunk) => chunk._id));
+  return {
+    chunks,
+    invalidChunks,
+    missingIds: requestedIds.filter((id) => !observedIds.has(id)),
+    invalidIds: requestedIds.filter((id) => observedIds.has(id) && !validIds.has(id))
+  };
+}
+export {
+  classifyFetchedChunks,
+  decideMissingChunkAction
+};

package/dist/mock_and_interop/stores.d.ts

@@ -10,6 +10,10 @@ export declare const lockStats: import("octagonal-wheels/dataobject/reactive_v2"
     count: number;
 }>;
 export declare const collectingChunks: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
+export declare const chunkFetchCounts: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<{
+    initial: number;
+    retrying: number;
+}>;
 export declare const pluginScanningCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
 export declare const hiddenFilesProcessingCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;
 export declare const hiddenFilesEventCount: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<number>;

package/dist/mock_and_interop/stores.js

@@ -1,11 +1,13 @@
 import { reactiveSource } from "octagonal-wheels/dataobject/reactive";
 const lockStats = reactiveSource({ pending: [], running: [], count: 0 });
 const collectingChunks = reactiveSource(0);
+const chunkFetchCounts = reactiveSource({ initial: 0, retrying: 0 });
 const pluginScanningCount = reactiveSource(0);
 const hiddenFilesProcessingCount = reactiveSource(0);
 const hiddenFilesEventCount = reactiveSource(0);
 const logMessages = reactiveSource([]);
 export {
+  chunkFetchCounts,
   collectingChunks,
   hiddenFilesEventCount,
   hiddenFilesProcessingCount,

package/dist/services/base/SettingService.d.ts

@@ -2,6 +2,7 @@ import { type ObsidianLiveSyncSettings, type SettingsMigrationState } from "../.
 import type { IAPIService, ISettingService } from "./IService.js";
 import { ServiceBase, type ServiceContext } from "./ServiceBase.js";
 import { createInstanceLogFunction } from "../lib/logUtils.js";
+import { type PersistedSettings } from "../../common/models/setting.policy.js";
 export interface SettingServiceDependencies {
     APIService: IAPIService;
     /** Optional host hook for applying the loaded display language to its catalogue. */
@@ -17,7 +18,7 @@ export declare abstract class SettingService<T extends ServiceContext = ServiceC
     _settings: ObsidianLiveSyncSettings;
     get settings(): ObsidianLiveSyncSettings;
     set settings(value: ObsidianLiveSyncSettings);
-    protected abstract saveData(setting: ObsidianLiveSyncSettings): Promise<void>;
+    protected abstract saveData(setting: PersistedSettings): Promise<void>;
     protected abstract loadData(): Promise<ObsidianLiveSyncSettings | undefined>;
     private _lastPersistedSettings?;
     private _settingsMigrationState?;