@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/managers/LayeredChunkManager/types.d.ts

@@ -0,0 +1,39 @@
+import type { EntryDoc } from "../../common/models/db.definition.js";
+import type { DocumentID, EntryLeaf } from "../../common/models/db.type.js";
+import type { ISettingService } from "../../services/base/IService.js";
+import type { ChangeManager } from "../ChangeManager.js";
+import type { EVENT_CHUNK_FETCHED, EVENT_MISSING_CHUNK_REMOTE, EVENT_MISSING_CHUNKS } from "../ChunkFetcher.js";
+import type { ActivityCountSource } from "../ChunkDeliveryCoordinator.js";
+export type ChunkManagerOptions = {
+    database: PouchDB.Database<EntryDoc>;
+    changeManager: ChangeManager<EntryDoc>;
+    settingService: ISettingService;
+    /** Finite replication which may still deliver a requested chunk. */
+    finiteReplicationActivity?: ActivityCountSource;
+};
+export type ChunkReadOptions = {
+    skipCache?: boolean;
+    /** Wait for an already-observable finite delivery lifecycle. */
+    waitForDelivery?: boolean;
+    /** @deprecated Use `waitForDelivery`. Positive values no longer represent an arrival duration. */
+    timeout?: number;
+    preventRemoteRequest?: boolean;
+};
+export type ChunkWriteOptions = {
+    skipCache?: boolean;
+    force?: boolean;
+};
+export type WriteResult = {
+    result: boolean;
+    processed: {
+        cached: number;
+        hotPack: number;
+        written: number;
+        duplicated: number;
+    };
+};
+export type ChunkManagerEventMap = {
+    [EVENT_MISSING_CHUNK_REMOTE]: DocumentID;
+    [EVENT_MISSING_CHUNKS]: DocumentID[];
+    [EVENT_CHUNK_FETCHED]: EntryLeaf;
+};

package/dist/managers/LayeredChunkManager.d.ts

@@ -0,0 +1,53 @@
+import type { DocumentID, EntryDoc, EntryLeaf } from "../common/types.js";
+import type { ChangeManager } from "./ChangeManager.js";
+import type { ChunkManagerEventMap, ChunkManagerOptions, ChunkReadOptions, ChunkWriteOptions, WriteResult } from "./LayeredChunkManager/types.js";
+import { ChunkDeliveryCoordinator } from "./ChunkDeliveryCoordinator.js";
+/**
+ * ChunkManager class that manages chunk operations such as reading, writing, and caching.
+ * Now uses a middleware layer architecture for read and write operations.
+ */
+export declare class LayeredChunkManager {
+    protected options: ChunkManagerOptions;
+    protected eventTarget: EventTarget;
+    private cacheLayer;
+    private databaseReadLayer;
+    private readLayers;
+    private writeLayers;
+    private arrivalWaitLayer;
+    readonly deliveryCoordinator: ChunkDeliveryCoordinator;
+    get changeManager(): ChangeManager<EntryDoc>;
+    get database(): PouchDB.Database<EntryDoc>;
+    get cacheStatistics(): {
+        size: number;
+        allocCount: number;
+        derefCount: number;
+    };
+    addListener<K extends keyof ChunkManagerEventMap>(type: K, listener: (this: LayeredChunkManager, ev: ChunkManagerEventMap[K]) => void, options?: boolean | AddEventListenerOptions): () => void;
+    emitEvent<K extends keyof ChunkManagerEventMap>(type: K, detail: ChunkManagerEventMap[K]): void;
+    protected abort: AbortController;
+    protected offChangeHandler: ReturnType<typeof this.changeManager.addCallback>;
+    protected initialised: Promise<void>;
+    _initialise(): Promise<void>;
+    constructor(options: ChunkManagerOptions);
+    destroy(): void;
+    getCachedChunk(id: DocumentID): EntryLeaf | false;
+    getChunkIDFromCache(data: string): DocumentID | false;
+    cacheChunk(chunk: EntryLeaf): void;
+    clearCaches(): void;
+    read(ids: DocumentID[], options: ChunkReadOptions, preloadedChunks?: Record<DocumentID, EntryLeaf>): Promise<(EntryLeaf | false)[]>;
+    private executeReadPipeline;
+    write(chunks: EntryLeaf[], options: ChunkWriteOptions, origin: DocumentID): Promise<WriteResult>;
+    private executeWritePipeline;
+    private isChunkDoc;
+    private onChunkArrived;
+    protected onChunkArrivedHandler: (doc: EntryLeaf, deleted?: boolean) => void;
+    private onChange;
+    protected onChangeHandler: (change: PouchDB.Core.ChangesResponseChange<EntryDoc>) => void;
+    onMissingChunkRemote(id: DocumentID): void;
+    protected onMissingChunkRemoteHandler: (id: DocumentID) => void;
+    protected concurrentTransactions: number;
+    protected stabilised: Promise<void>;
+    transaction<T>(callback: () => Promise<T>): Promise<T>;
+    _stabilise(): Promise<void>;
+    __stabilise(): Promise<void>;
+}

package/dist/managers/LayeredChunkManager.js

@@ -0,0 +1,240 @@
+import { LOG_LEVEL_VERBOSE, Logger } from "../common/logger.js";
+import { promiseWithResolvers } from "octagonal-wheels/promises";
+import { EVENT_MISSING_CHUNK_REMOTE, EVENT_MISSING_CHUNKS, EVENT_CHUNK_FETCHED } from "./ChunkFetcher.js";
+import { DatabaseReadLayer } from "./LayeredChunkManager/DatabaseReadLayer.js";
+import { CacheLayer } from "./LayeredChunkManager/CacheLayer.js";
+import { ArrivalWaitLayer } from "./LayeredChunkManager/ArrivalWaitLayer.js";
+import { DatabaseWriteLayer } from "./LayeredChunkManager/DatabaseWriteLayer.js";
+import { unique } from "octagonal-wheels/collection";
+import { ChunkDeliveryCoordinator } from "./ChunkDeliveryCoordinator.js";
+class LayeredChunkManager {
+  options;
+  eventTarget = new EventTarget();
+  // Middleware layers
+  cacheLayer;
+  databaseReadLayer;
+  readLayers;
+  writeLayers;
+  arrivalWaitLayer;
+  deliveryCoordinator;
+  get changeManager() {
+    return this.options.changeManager;
+  }
+  get database() {
+    return this.options.database;
+  }
+  // Expose cache statistics
+  get cacheStatistics() {
+    return this.cacheLayer.getStatistics();
+  }
+  addListener(type, listener, options) {
+    const callback = (ev) => {
+      listener.call(this, ev.detail);
+    };
+    this.eventTarget.addEventListener(type, callback, options);
+    return () => {
+      this.eventTarget.removeEventListener(type, callback, options);
+    };
+  }
+  emitEvent(type, detail) {
+    const event = new CustomEvent(type, { detail });
+    this.eventTarget.dispatchEvent(event);
+  }
+  abort = new AbortController();
+  // Change listener cleanup
+  offChangeHandler;
+  // initialisation promise to ensure the manager is ready before processing transactions
+  initialised = Promise.resolve();
+  async _initialise() {
+    Logger("ChunkManager initialised", LOG_LEVEL_VERBOSE);
+    return await Promise.resolve();
+  }
+  constructor(options) {
+    this.options = options;
+    const settings = options.settingService.currentSettings();
+    const maxCacheSize = settings.hashCacheMaxCount * 10;
+    this.cacheLayer = new CacheLayer(maxCacheSize);
+    this.databaseReadLayer = new DatabaseReadLayer(this.database);
+    this.deliveryCoordinator = new ChunkDeliveryCoordinator(options.finiteReplicationActivity);
+    this.arrivalWaitLayer = new ArrivalWaitLayer(
+      (eventName, data) => {
+        if (eventName === "missingChunks") {
+          this.emitEvent(EVENT_MISSING_CHUNKS, data);
+        }
+      },
+      this.deliveryCoordinator,
+      (ids) => this.databaseReadLayer.read(
+        [...ids],
+        { preventRemoteRequest: true, skipCache: true, waitForDelivery: false },
+        (remaining) => Promise.resolve(remaining.map(() => false))
+      )
+    );
+    this.readLayers = [this.cacheLayer, this.databaseReadLayer, this.arrivalWaitLayer];
+    this.writeLayers = [
+      // new HotPackLayer(),
+      new DatabaseWriteLayer(this.database),
+      this.cacheLayer
+    ];
+    this.offChangeHandler = this.changeManager.addCallback(this.onChangeHandler);
+    this.addListener(EVENT_CHUNK_FETCHED, this.onChunkArrivedHandler, { signal: this.abort.signal });
+    this.addListener(EVENT_MISSING_CHUNK_REMOTE, this.onMissingChunkRemoteHandler, { signal: this.abort.signal });
+    this.initialised = this._initialise();
+  }
+  destroy() {
+    const layers = unique([...this.readLayers, ...this.writeLayers]);
+    this.abort.abort();
+    this.offChangeHandler();
+    for (const layer of layers) {
+      if (layer.tearDown) {
+        layer.tearDown();
+      }
+    }
+    this.deliveryCoordinator.dispose();
+  }
+  // Cache management methods (delegated to cacheLayer)
+  getCachedChunk(id) {
+    return this.cacheLayer.getCachedChunk(id);
+  }
+  getChunkIDFromCache(data) {
+    return this.cacheLayer.getChunkIDFromCache(data);
+  }
+  cacheChunk(chunk) {
+    this.cacheLayer.cacheChunk(chunk);
+  }
+  // reorderChunk(id: DocumentID): void {
+  //     this.cacheLayer.reorderChunk(id);
+  // }
+  // deleteCachedChunk(id: DocumentID): void {
+  //     this.cacheLayer.deleteCachedChunk(id);
+  // }
+  clearCaches() {
+    this.cacheLayer.clearCaches();
+  }
+  // Read pipeline execution
+  async read(ids, options, preloadedChunks) {
+    const order = [...ids];
+    const resultMap = new Map(ids.map((id) => [id, false]));
+    const readIds = /* @__PURE__ */ new Set([...resultMap.keys()]);
+    if (preloadedChunks) {
+      for (const [id, chunk] of Object.entries(preloadedChunks)) {
+        if (this.isChunkDoc(chunk)) {
+          this.cacheLayer.cacheChunk(chunk);
+          resultMap.set(id, chunk);
+          readIds.delete(id);
+        }
+      }
+    }
+    const results = await this.executeReadPipeline([...readIds], options);
+    for (let i = 0; i < results.length; i++) {
+      if (results[i]) {
+        const chunk = results[i];
+        resultMap.set(chunk._id, chunk);
+      }
+    }
+    return order.map((id) => resultMap.get(id) || false);
+  }
+  executeReadPipeline(ids, options) {
+    let layerIndex = 0;
+    const layers = this.readLayers;
+    const executeNextLayer = (remaining) => {
+      if (layerIndex >= layers.length) {
+        return Promise.resolve(remaining.map(() => false));
+      }
+      const layer = layers[layerIndex];
+      layerIndex++;
+      return layer.read(remaining, options, executeNextLayer);
+    };
+    return executeNextLayer(ids);
+  }
+  // Write pipeline execution
+  async write(chunks, options, origin) {
+    const result = await this.executeWritePipeline(chunks, options, origin);
+    return result;
+  }
+  executeWritePipeline(chunks, options, origin) {
+    let layerIndex = 0;
+    const layers = this.writeLayers;
+    const executeNextLayer = (remaining) => {
+      if (layerIndex >= layers.length) {
+        return Promise.resolve({
+          result: true,
+          processed: {
+            cached: 0,
+            hotPack: 0,
+            written: 0,
+            duplicated: 0
+          }
+        });
+      }
+      const layer = layers[layerIndex];
+      layerIndex++;
+      return layer.write(remaining, options, origin, executeNextLayer);
+    };
+    return executeNextLayer(chunks);
+  }
+  // Helper methods
+  isChunkDoc(doc) {
+    if (typeof doc !== "object" || doc === null) {
+      return false;
+    }
+    if ("_id" in doc && "type" in doc) {
+      return doc && typeof doc._id === "string" && doc.type === "leaf";
+    }
+    return false;
+  }
+  // Event handlers
+  onChunkArrived(doc, deleted = false) {
+    this.arrivalWaitLayer.onChunkArrived(doc, deleted);
+  }
+  onChunkArrivedHandler = this.onChunkArrived.bind(this);
+  onChange(change) {
+    const doc = change.doc;
+    if (!doc || !doc._id) {
+      return;
+    }
+    if (doc.type !== "leaf") {
+      return;
+    }
+    this.onChunkArrived(doc, change.deleted);
+  }
+  onChangeHandler = this.onChange.bind(this);
+  onMissingChunkRemote(id) {
+    this.arrivalWaitLayer.onMissingChunk(id);
+  }
+  onMissingChunkRemoteHandler = this.onMissingChunkRemote.bind(this);
+  // Transaction management
+  concurrentTransactions = 0;
+  stabilised = Promise.resolve();
+  async transaction(callback) {
+    await this.initialised;
+    await this.stabilised;
+    this.concurrentTransactions++;
+    try {
+      const result = await callback();
+      return result;
+    } finally {
+      this.concurrentTransactions--;
+      if (this.concurrentTransactions === 0) {
+        Logger(`All transactions completed. Performing stabilisation.`, LOG_LEVEL_VERBOSE);
+        await this._stabilise();
+      } else {
+        Logger(`Transaction completed. Remaining: ${this.concurrentTransactions}`, LOG_LEVEL_VERBOSE);
+      }
+    }
+  }
+  async _stabilise() {
+    const pr = promiseWithResolvers();
+    this.stabilised = pr.promise;
+    try {
+      await this.__stabilise();
+    } finally {
+      pr.resolve();
+    }
+  }
+  __stabilise() {
+    return Promise.resolve();
+  }
+}
+export {
+  LayeredChunkManager
+};

package/dist/managers/LiveSyncManagers.d.ts

@@ -0,0 +1,48 @@
+import { type EntryDoc } from "../common/types.js";
+import { ContentSplitter } from "../ContentSplitter/ContentSplitters.js";
+import { ChangeManager } from "./ChangeManager.js";
+import { ChunkFetcher } from "./ChunkFetcher.js";
+import { ChunkManager } from "./ChunkManager.js";
+import { ConflictManager } from "./ConflictManager.js";
+import { EntryManager } from "./EntryManager/EntryManager.js";
+import { HashManager } from "./HashManager/HashManager.js";
+import type { IAPIService, IDatabaseService, IPathService, IReplicatorService, ISettingService } from "../services/base/IService.js";
+import { type LogFunction } from "../services/lib/logUtils.js";
+export interface LiveSyncManagersOptions<TSettingService extends ISettingService = ISettingService> {
+    database: PouchDB.Database<EntryDoc>;
+    databaseService: IDatabaseService;
+    settingService: TSettingService;
+    pathService: IPathService;
+    replicatorService: IReplicatorService;
+    APIService: IAPIService;
+}
+export declare class LiveSyncManagers {
+    protected _pathService: IPathService;
+    protected _replicatorService: IReplicatorService;
+    protected _settingService: ISettingService;
+    protected _APIService: IAPIService;
+    hashManager: HashManager;
+    chunkFetcher: ChunkFetcher;
+    changeManager: ChangeManager<EntryDoc>;
+    chunkManager: ChunkManager;
+    splitter: ContentSplitter;
+    entryManager: EntryManager;
+    conflictManager: ConflictManager;
+    protected options: LiveSyncManagersOptions;
+    protected log: LogFunction;
+    constructor(options: LiveSyncManagersOptions);
+    teardownManagers(): Promise<void>;
+    protected getManagerMembers(): {
+        changeManager: ChangeManager<EntryDoc>;
+        hashManager: HashManager;
+        splitter: ContentSplitter;
+        chunkManager: ChunkManager;
+        chunkFetcher: ChunkFetcher;
+        entryManager: EntryManager;
+        conflictManager: ConflictManager;
+    };
+    initialise(): Promise<void>;
+    reinitialise(): Promise<void>;
+    clearCaches(): void;
+    prepareHashFunction(): Promise<void>;
+}

package/dist/managers/LiveSyncManagers.js

@@ -0,0 +1,136 @@
+import { LOG_LEVEL_VERBOSE } from "../common/types.js";
+import { ContentSplitter } from "../ContentSplitter/ContentSplitters.js";
+import { ChangeManager } from "./ChangeManager.js";
+import { ChunkFetcher } from "./ChunkFetcher.js";
+import { ChunkManager } from "./ChunkManager.js";
+import { ConflictManager } from "./ConflictManager.js";
+import { EntryManager } from "./EntryManager/EntryManager.js";
+import { HashManager } from "./HashManager/HashManager.js";
+import { createInstanceLogFunction } from "../services/lib/logUtils.js";
+class LiveSyncManagers {
+  _pathService;
+  _replicatorService;
+  _settingService;
+  _APIService;
+  hashManager;
+  chunkFetcher;
+  changeManager;
+  chunkManager;
+  splitter;
+  entryManager;
+  conflictManager;
+  options;
+  log;
+  constructor(options) {
+    this.options = options;
+    this._APIService = options.APIService;
+    this._pathService = options.pathService;
+    this._replicatorService = options.replicatorService;
+    this._settingService = options.settingService;
+    this.log = createInstanceLogFunction("LiveSyncManagers", this._APIService);
+    const { changeManager, hashManager, splitter, chunkManager, chunkFetcher, entryManager, conflictManager } = this.getManagerMembers();
+    this.changeManager = changeManager;
+    this.hashManager = hashManager;
+    this.splitter = splitter;
+    this.chunkManager = chunkManager;
+    this.chunkFetcher = chunkFetcher;
+    this.entryManager = entryManager;
+    this.conflictManager = conflictManager;
+  }
+  async teardownManagers() {
+    this.log("Teardown LiveSync Managers...", LOG_LEVEL_VERBOSE);
+    if (this.changeManager) {
+      this.changeManager.teardown();
+      this.changeManager = void 0;
+    }
+    if (this.chunkFetcher) {
+      this.chunkFetcher.destroy();
+      this.chunkFetcher = void 0;
+    }
+    if (this.chunkManager) {
+      this.chunkManager.destroy();
+      this.chunkManager = void 0;
+    }
+    this.log("Teardown LiveSync Managers... Done");
+    return await Promise.resolve();
+  }
+  getManagerMembers() {
+    this.log("Creating LiveSync Managers...");
+    const database = this.options.databaseService.localDatabase.localDatabase;
+    const changeManager = new ChangeManager({
+      database
+    });
+    const hashManager = new HashManager({
+      settingService: this.options.settingService
+    });
+    const splitter = new ContentSplitter({
+      settingService: this.options.settingService
+    });
+    const chunkManager = new ChunkManager({
+      changeManager,
+      database,
+      settingService: this.options.settingService,
+      finiteReplicationActivity: this.options.replicatorService.finiteReplicationActivityCount
+    });
+    const chunkFetcher = new ChunkFetcher({
+      chunkManager,
+      replicatorService: this.options.replicatorService,
+      settingService: this.options.settingService
+    });
+    const entryManager = new EntryManager({
+      database,
+      hashManager,
+      chunkManager,
+      splitter,
+      pathService: this._pathService,
+      settingService: this.options.settingService
+    });
+    const conflictManager = new ConflictManager({
+      entryManager,
+      database,
+      pathService: this._pathService
+    });
+    this.log("LiveSync Managers have been created");
+    return {
+      changeManager,
+      hashManager,
+      splitter,
+      chunkManager,
+      chunkFetcher,
+      entryManager,
+      conflictManager
+    };
+  }
+  async initialise() {
+    this.log("Initialising LiveSync Managers...", LOG_LEVEL_VERBOSE);
+    await this.splitter.initialise({
+      settingService: this.options.settingService
+    });
+    await this.hashManager.initialise();
+    this.log("LiveSync Manager has been initialised");
+  }
+  async reinitialise() {
+    await this.teardownManagers();
+    const { changeManager, hashManager, splitter, chunkManager, chunkFetcher, entryManager, conflictManager } = this.getManagerMembers();
+    this.changeManager = changeManager;
+    this.hashManager = hashManager;
+    this.splitter = splitter;
+    this.chunkManager = chunkManager;
+    this.chunkFetcher = chunkFetcher;
+    this.entryManager = entryManager;
+    this.conflictManager = conflictManager;
+    await this.initialise();
+  }
+  clearCaches() {
+    this.chunkManager?.clearCaches();
+  }
+  async prepareHashFunction() {
+    this.hashManager = new HashManager({
+      settingService: this.options.settingService
+    });
+    await this.hashManager.initialise();
+  }
+}
+export {
+  LiveSyncManagers
+};

package/dist/managers/StorageEventManager.d.ts

@@ -0,0 +1,135 @@
+import { type FileEventType, type FilePath, type UXFileInfoStub, type UXFolderInfo, type UXInternalFileInfoStub } from "../common/types.js";
+import { type FileEventItem } from "../common/types.js";
+import type { IStorageAccessManager } from "../interfaces/StorageAccess.js";
+import { type PromiseWithResolvers } from "octagonal-wheels/promises";
+import { StorageEventManager, type FileEvent } from "../interfaces/StorageEventManager.js";
+import type { IAPIService, IVaultService } from "../services/base/IService.js";
+import type { SettingService } from "../services/base/SettingService.js";
+import type { FileProcessingService } from "../services/base/FileProcessingService.js";
+import { createInstanceLogFunction } from "../services/lib/logUtils.js";
+import type { IStorageEventManagerAdapter } from "./adapters/index.js";
+import { type CompatTimeoutHandle } from "../common/coreEnvFunctions.js";
+type WaitInfo = {
+    since: number;
+    type: FileEventType;
+    canProceed: PromiseWithResolvers<boolean>;
+    timerHandler: CompatTimeoutHandle;
+    event: FileEventItem;
+};
+declare const TYPE_SENTINEL_FLUSH = "SENTINEL_FLUSH";
+type FileEventItemSentinelFlush = {
+    type: typeof TYPE_SENTINEL_FLUSH;
+};
+export type FileEventItemSentinel = FileEventItemSentinelFlush;
+export interface StorageEventManagerBaseDependencies {
+    setting: SettingService;
+    vaultService: IVaultService;
+    fileProcessing: FileProcessingService;
+    storageAccessManager: IStorageAccessManager;
+    APIService: IAPIService;
+}
+/**
+ * Type helper to extract the file type from a storage event manager adapter
+ */
+export type ExtractFile<T> = T extends IStorageEventManagerAdapter<infer F, any> ? F : never;
+/**
+ * Type helper to extract the folder type from a storage event manager adapter
+ */
+export type ExtractFolder<T> = T extends IStorageEventManagerAdapter<any, infer D> ? D : never;
+/**
+ * Base class for storage event management
+ * Uses adapter pattern for platform-specific implementations
+ *
+ * @template TAdapter - The storage event manager adapter type
+ */
+export declare abstract class StorageEventManagerBase<TAdapter extends IStorageEventManagerAdapter<any, any>> extends StorageEventManager {
+    _log: ReturnType<typeof createInstanceLogFunction>;
+    protected setting: SettingService;
+    protected vaultService: IVaultService;
+    protected fileProcessing: FileProcessingService;
+    protected storageAccess: IStorageAccessManager;
+    protected adapter: TAdapter;
+    protected get shouldBatchSave(): boolean;
+    protected get batchSaveMinimumDelay(): number;
+    protected get batchSaveMaximumDelay(): number;
+    get settings(): import("../common/types.js").ObsidianLiveSyncSettings;
+    constructor(adapter: TAdapter, dependencies: StorageEventManagerBaseDependencies);
+    _saveSnapshot(snapshot: (FileEventItem | FileEventItemSentinel)[]): Promise<void>;
+    _loadSnapshot(): Promise<(FileEventItem | FileEventItemSentinel)[] | null>;
+    isFolder(file: UXFileInfoStub | UXInternalFileInfoStub | UXFolderInfo | ExtractFolder<TAdapter> | ExtractFile<TAdapter>): boolean;
+    isFile(file: UXFileInfoStub | UXInternalFileInfoStub | UXFolderInfo | ExtractFolder<TAdapter> | ExtractFile<TAdapter>): boolean;
+    protected updateStatus(): void;
+    /**
+     * Snapshot restoration promise.
+     * Snapshot will be restored before starting to watch vault changes.
+     * In designed time, this has been called from Initialisation process, which has been implemented on `ModuleInitializerFile.ts`.
+     */
+    snapShotRestored: Promise<void> | null;
+    /**
+     * Restore the previous snapshot if exists.
+     * @returns
+     */
+    restoreState(): Promise<void>;
+    appendQueue(params: FileEvent[], ctx?: unknown): Promise<void>;
+    protected bufferedQueuedItems: (FileEventItem | FileEventItemSentinel)[];
+    enqueue(newItem: FileEventItem): void;
+    /**
+     * Immediately take snapshot.
+     */
+    private _triggerTakeSnapshot;
+    /**
+     * Trigger taking snapshot after throttled period.
+     */
+    triggerTakeSnapshot: import("octagonal-wheels/function").ThrottledFunction<() => void>;
+    protected concurrentProcessing: import("octagonal-wheels/concurrency/semaphore_v2").SemaphoreObject;
+    protected _waitingMap: Map<string, WaitInfo>;
+    private _waitForIdle;
+    /**
+     * Wait until all queued events are processed.
+     * Subsequent new events will not be waited, but new events will not be added.
+     * @returns
+     */
+    waitForIdle(): Promise<void>;
+    /**
+     * Proceed waiting for the given key immediately.
+     */
+    private _proceedWaiting;
+    /**
+     * Cancel waiting for the given key.
+     */
+    private _cancelWaiting;
+    /**
+     * Add waiting for the given key.
+     * @param key
+     * @param event
+     * @param waitedSince Optional waited since timestamp to calculate the remaining delay.
+     */
+    private _addWaiting;
+    /**
+     * Process the given file event.
+     */
+    processFileEvent(fei: FileEventItem): Promise<void>;
+    _takeSnapshot(): Promise<void>;
+    _restoreFromSnapshot(): Promise<void>;
+    protected runQueuedEvents(): Promise<void>;
+    protected processingCount: number;
+    protected requestProcessQueue(fei: FileEventItem): Promise<void>;
+    isWaiting(filename: FilePath): boolean;
+    protected handleFileEvent(queue: FileEventItem): Promise<void>;
+    protected cancelRelativeEvent(item: FileEventItem): void;
+    /**
+     * Begin watching for storage events
+     */
+    beginWatch(): Promise<void>;
+    /**
+     * Platform-agnostic event handlers
+     */
+    protected watchEditorChange<TEditor = unknown, TInfo = unknown>(editor: TEditor, info: TInfo): void;
+    protected watchVaultCreate<TFile = unknown, TCtx = unknown>(file: TFile, ctx?: TCtx): void;
+    protected watchVaultChange<TFile = unknown, TCtx = unknown>(file: TFile, ctx?: TCtx): void;
+    protected watchVaultDelete<TFile = unknown, TCtx = unknown>(file: TFile, ctx?: TCtx): void;
+    protected watchVaultRename<TFile = unknown, TCtx = unknown>(file: TFile, oldPath: string, ctx?: TCtx): void;
+    protected watchVaultRawEvents(path: FilePath): void;
+    protected _watchVaultRawEvents(path: FilePath): Promise<void>;
+}
+export {};