@vrtmrz/livesync-commonlib 0.1.33 → 0.1.34

package/dist/managers/ChunkFetcher.d.ts

@@ -15,6 +15,13 @@ export declare class ChunkFetcher {
     get chunkManager(): ChunkManager;
     queue: DocumentID[];
     private readonly pendingClaims;
+    private reportedPendingCount;
+    private reportedFetchCounts;
+    private requestTimer;
+    private requestTimerDueAt;
+    private finiteActivityWasActive;
+    private finiteCompletionVersion;
+    private readonly stopObservingDelivery;
     private destroyed;
     get interval(): number;
     get concurrency(): number;
@@ -23,12 +30,20 @@ export declare class ChunkFetcher {
     destroy(): void;
     onEventHandler: (ids: DocumentID[]) => void;
     onEvent(ids: DocumentID[]): void;
+    private clearRequestTimer;
+    private scheduleRequest;
     private ensureClaims;
     private removePendingDelivery;
+    private updatePendingCount;
     private onClaimStalled;
     private settleClaim;
+    private getActiveClaimIds;
     private touchClaims;
     private waitForActivityBoundary;
+    private waitBeforeRemoteRequest;
+    private resolveLocallyAvailableRetries;
+    private logFetchedChunks;
+    private applyMissingChunkResults;
     /**
      * Processing requests
      */
@@ -40,5 +55,6 @@ export declare class ChunkFetcher {
      */
     previousRequestTime: number;
     canRequestMore(): boolean;
+    private isReady;
     requestMissingChunks(): Promise<void>;
 }

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/docs/proven-in-use.md

@@ -38,7 +38,9 @@ The equal-time scan test uses real in-memory PouchDB to verify that a missing re
 
 Commonlib's chunk-reachability tests use real PouchDB revision trees. They verify that an ordinary superseded revision releases its unique chunks, a chunk shared by current files remains reachable, live conflict branches and their nearest available shared ancestor remain protected, and losing-branch ancestry becomes eligible after resolution. They also replicate a collected chunk deletion to another PouchDB database and verify that writing the same content can recreate and replicate the content-addressed chunk. Self-hosted LiveSync owns the CouchDB-specific Garbage Collection V3 workflow, including device checks, confirmation, deletion, push-only replication, and remote compaction.
 
-Commonlib's injected CouchDB tests verify that a mixed remote chunk batch preserves available documents when another requested ID is absent. Its chunk-delivery tests separately verify that available chunks reach local storage and only absent IDs are marked unavailable. Self-hosted LiveSync supplies the real CouchDB connection and start-up composition, so device-specific replication timing remains downstream integration evidence rather than Commonlib unit coverage.
+Commonlib's injected CouchDB tests verify that a mixed remote chunk batch preserves available documents when another requested ID is absent. Its chunk-delivery tests separately verify local persistence, an autonomous two-second retry after the first successful omission, and per-identifier backoff capped at ten seconds while finite replication is active. Backoff retains bounded remote activity but releases physical concurrency. Eligible retries can share batches without resetting their individual stages. Finite completion expedites a local recheck and, if needed, a final remote probe; a pre-completion in-flight lookup cannot replace that probe. Overlapping-request tests verify that earlier requests cannot release or report unavailability for replacement claims and that concurrent fetches preserve the configured interval across retry waits. Self-hosted LiveSync supplies the real CouchDB connection and start-up composition, so device-specific replication timing remains downstream integration evidence rather than Commonlib unit coverage.
+
+The compatibility pending-Chunk counter follows those accepted identifiers, including queueing and retry delays. A separate atomic snapshot classifies them as initial or retrying without changing the total used for lifecycle deferral. Focused tests verify duplicate-request deduplication, partial completion, runner rejection, inactivity expiry, teardown, replacement claims, and independent fetcher contributions. The visible status indicators remain a downstream host responsibility.
 
 Commonlib's injected remote-service tests verify that an owning operation can abort a pending CouchDB request, that closing the flat connection interrupts a response body which is already being consumed, that repeated closure closes PouchDB once, and that a bounded request does not fall back into the non-abortable native adapter. Its one-shot replicator tests verify deadline expiry, distinct timeout reporting, cleanup before release of the shared attempt, later invocation, successful ownership transfer, and the unchanged native-request boundary. Self-hosted LiveSync still supplies the actual Obsidian fetch adapters and real CouchDB environment; confirmation on the reporter's platform remains downstream evidence rather than a Commonlib guarantee.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vrtmrz/livesync-commonlib",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "Shared data, storage, and replication primitives for Self-hosted LiveSync clients.",
   "type": "module",
   "types": "./dist/index.d.ts",