@vrtmrz/livesync-commonlib 0.2.3 → 0.3.1

package/dist/common/models/setting.const.qr.js

@@ -184,6 +184,7 @@ const KeyIndexOfSettings = {
   idDerivationKey: 167,
   pathNormalizationVersion: 168,
   batchSaveInLiveSync: 169,
+  useCouchDBCacheControlHeadersOnly: 170,
   encryptedIdDerivationKey: -1
 };
 export {

package/dist/common/models/setting.policy.d.ts

@@ -441,6 +441,10 @@ export declare const SETTINGS_PROPERTY_POLICY: {
         readonly markdown: "include";
         readonly persistence: "include";
     };
+    readonly useCouchDBCacheControlHeadersOnly: {
+        readonly markdown: "include";
+        readonly persistence: "include";
+    };
     readonly accessKey: {
         readonly markdown: "credentials";
         readonly persistence: "connection";

package/dist/common/models/setting.policy.js

@@ -111,6 +111,7 @@ const SETTINGS_PROPERTY_POLICY = {
   jwtSub: SettingPolicies.ConnectionCredentials,
   jwtExpDuration: SettingPolicies.Default,
   useRequestAPI: SettingPolicies.Default,
+  useCouchDBCacheControlHeadersOnly: SettingPolicies.Default,
   accessKey: SettingPolicies.ConnectionCredentials,
   secretKey: SettingPolicies.ConnectionCredentials,
   bucket: SettingPolicies.LocalConnection,

package/dist/common/models/setting.type.d.ts

@@ -38,6 +38,8 @@ export interface CouchDBConnection {
      * Seems stable, so promoted to the normal setting.
      */
     useRequestAPI: boolean;
+    /** Control CouchDB HTTP caching through headers alone. Defaults to false. */
+    useCouchDBCacheControlHeadersOnly?: boolean;
 }
 /**
  * Interface representing the settings for periodic replication.
@@ -557,7 +559,7 @@ export interface P2PConnectionInfo {
      */
     P2P_useDiagRTC?: boolean;
 }
-export interface P2PSyncSetting extends P2PConnectionInfo {
+export interface P2PSyncSetting extends P2PConnectionInfo, Partial<PathIdentitySettings> {
     P2P_AutoAccepting: AutoAccepting;
     P2P_AutoSyncPeers: string;
     P2P_AutoWatchPeers: string;

package/dist/common/models/shared.definition.configNames.js

@@ -66,8 +66,7 @@ const configurationNames = {
   },
   pathNormalizationVersion: {
     name: "Path identity mode",
-    desc: "CouchDB only. Version 0 preserves legacy path identity; version 1 uses Unicode NFC. Physical file names stay unchanged. Update every device and stop synchronisation, then Rebuild both databases from a complete authoritative Vault and Fetch on the other devices. Resolve colliding file names first. P2P and Object Storage do not support version 1.",
-    isAdvanced: true
+    desc: "Version 0 preserves legacy path identity; version 1 uses Unicode NFC. Physical file names stay unchanged. Update every device and stop synchronisation, then Rebuild from a complete authoritative Vault and Fetch on the other devices. With P2P, Rebuild prepares only the source device's local database. Resolve colliding file names first."
   },
   doNotUseFixedRevisionForChunks: {
     name: "Content-derived chunk revisions (obsolete setting)",

package/dist/common/models/tweak.definition.d.ts

@@ -120,8 +120,8 @@ export declare const TweakValuesRecommendedTemplate: Partial<ObsidianLiveSyncSet
 export declare const TweakValuesDefault: Partial<ObsidianLiveSyncSettings>;
 export declare const TweakValuesTemplate: {
     tweakModified: number;
-    usePluginSyncV2: boolean;
     pathNormalizationVersion: import("./setting.type.js").PathNormalizationVersion;
+    usePluginSyncV2: boolean;
     encrypt: boolean;
     idDerivationVersion: 0 | 1;
     usePathObfuscation: boolean;
@@ -238,6 +238,7 @@ export declare const TweakValuesTemplate: {
     jwtSub?: string;
     jwtExpDuration?: number;
     useRequestAPI?: boolean;
+    useCouchDBCacheControlHeadersOnly?: boolean;
     accessKey?: string;
     secretKey?: string;
     bucket?: string;

package/dist/common/pathNamespace.d.ts

@@ -0,0 +1,4 @@
+import { ICHeader, ICXHeader, PSCHeader } from "./models/fileaccess.const.js";
+export type PathNamespace = "" | typeof ICHeader | typeof ICXHeader | typeof PSCHeader;
+/** Separate one recognised Metadata namespace while retaining the body's spelling. */
+export declare function splitPathNamespace(path: string): readonly [PathNamespace, string];

package/dist/common/pathNamespace.js

@@ -0,0 +1,10 @@
+import { ICHeader, ICXHeader, PSCHeader } from "./models/fileaccess.const.js";
+function splitPathNamespace(path) {
+  for (const prefix of [ICHeader, ICXHeader, PSCHeader]) {
+    if (path.startsWith(prefix)) return [prefix, path.slice(prefix.length)];
+  }
+  return ["", path];
+}
+export {
+  splitPathNamespace
+};

package/dist/common/pathNormalization.d.ts

@@ -1,4 +1,6 @@
 import type { PathNormalizationVersion } from "./models/setting.type.js";
+/** Reject unsupported path identity versions while allowing an absent legacy value. */
+export declare function assertSupportedPathNormalizationVersion(version: number | undefined): asserts version is PathNormalizationVersion | undefined;
 /** Resolve the stored path identity version, treating an absent legacy value as version zero. */
 export declare function getPathNormalizationVersion(settings: {
     pathNormalizationVersion?: number;

package/dist/common/pathNormalization.js

@@ -1,13 +1,18 @@
+function assertSupportedPathNormalizationVersion(version) {
+  if (version === void 0 || version === 0 || version === 1) return;
+  throw new Error(`Unsupported path normalisation version: ${version}`);
+}
 function getPathNormalizationVersion(settings) {
   const version = settings.pathNormalizationVersion === void 0 ? 0 : settings.pathNormalizationVersion;
-  if (version === 0 || version === 1) return version;
-  throw new Error(`Unsupported path normalisation version: ${version}`);
+  assertSupportedPathNormalizationVersion(version);
+  return version;
 }
 function normalisePathForIdentity(path, version) {
   const resolvedVersion = getPathNormalizationVersion({ pathNormalizationVersion: version });
   return resolvedVersion === 1 ? path.normalize("NFC") : path;
 }
 export {
+  assertSupportedPathNormalizationVersion,
   getPathNormalizationVersion,
   normalisePathForIdentity
 };

package/dist/common/settingConstants.d.ts

@@ -126,6 +126,7 @@ export declare const AllSettingDefault: {
     jwtSub: string;
     jwtExpDuration: number;
     useRequestAPI: boolean;
+    useCouchDBCacheControlHeadersOnly?: boolean;
     accessKey: string;
     secretKey: string;
     bucket: string;

package/dist/common/settingConstants.js

@@ -375,6 +375,10 @@ const SettingInformation = {
     name: "Use Request API to avoid `inevitable` CORS problem",
     desc: "If enabled, the request API will be used to avoid `inevitable` CORS problems. This is a workaround and may not work in all cases. PLEASE READ THE DOCUMENTATION BEFORE USING THIS OPTION. This is a less-secure option."
   },
+  useCouchDBCacheControlHeadersOnly: {
+    name: "Use headers only for HTTP cache control (compatibility)",
+    desc: "Remove the query parameter used to invalidate cached responses (the same URL behaviour as in 1.0.44 and earlier). Enable only if your CouchDB server or proxy rejects the additional cache query parameter. Older cached encrypted responses may then be reused after a remote Rebuild."
+  },
   hideFileWarningNotice: {
     name: "Show status icon instead of file warnings banner",
     desc: "If enabled, the \u26D4 icon will be shown inside the status instead of the file warnings banner. No details will be shown."

package/dist/managers/ChunkFetcher.d.ts

@@ -1,5 +1,6 @@
 import { type DocumentID } from "../common/types.js";
 import { type ChunkManager } from "./ChunkManager.js";
+import type { ChunkFetchSource } from "./chunkFetchSource.js";
 import type { IReplicatorService, ISettingService } from "../services/base/IService.js";
 export declare const EVENT_MISSING_CHUNKS = "missingChunks";
 export declare const EVENT_MISSING_CHUNK_REMOTE = "missingChunkRemote";
@@ -9,6 +10,8 @@ export type ChunkFetcherOptions = {
     chunkManager: ChunkManager;
     replicatorService: IReplicatorService;
     deliveryStallTimeoutMs?: number;
+    /** Direct hosts replace both retrieval and acceptance; the default uses the active replicator. */
+    source?: ChunkFetchSource;
 };
 export declare class ChunkFetcher {
     options: ChunkFetcherOptions;

package/dist/managers/ChunkFetcher.js

@@ -327,20 +327,25 @@ class ChunkFetcher {
       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.");
-        return;
-      }
-      if (!canFetchRemoteChunks(replicator)) {
-        Logger("The active replicator does not support fetching individual remote chunks.");
-        for (const chunkID of pendingIDs) {
-          this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+      const requestCompletionVersion = this.finiteCompletionVersion;
+      let fetched;
+      if (this.options.source) {
+        fetched = await this.options.source.fetchChunks(pendingIDs);
+      } else {
+        const replicator = this.options.replicatorService.getActiveReplicator();
+        if (!replicator) {
+          Logger("No active replicator was found to request missing chunks.");
+          return;
         }
-        return;
+        if (!canFetchRemoteChunks(replicator)) {
+          Logger("The active replicator does not support fetching individual remote chunks.");
+          for (const chunkID of pendingIDs) {
+            this.chunkManager.emitEvent(EVENT_MISSING_CHUNK_REMOTE, chunkID);
+          }
+          return;
+        }
+        fetched = await replicator.fetchRemoteChunks(pendingIDs, false);
       }
-      const requestCompletionVersion = this.finiteCompletionVersion;
-      const fetched = await replicator.fetchRemoteChunks(pendingIDs, false);
       pendingIDs = this.getActiveClaimIds(pendingIDs, requestClaims);
       this.touchClaims(pendingIDs, requestClaims);
       if (!fetched) {
@@ -354,7 +359,9 @@ class ChunkFetcher {
       this.logFetchedChunks(pendingIDs, classification);
       const { chunks, missingIds, invalidIds } = classification;
       try {
-        if (chunks.length > 0) {
+        if (chunks.length > 0 && this.options.source) {
+          await this.options.source.storeChunks(chunks);
+        } else if (chunks.length > 0) {
           Logger(`Writing fetched chunks (${chunks.length}) to the database...`);
           const result = await this.chunkManager.write(
             chunks,

package/dist/managers/LiveSyncManagers.d.ts

@@ -2,6 +2,7 @@ import { type EntryDoc } from "../common/types.js";
 import { ContentSplitter } from "../ContentSplitter/ContentSplitters.js";
 import { ChangeManager } from "./ChangeManager.js";
 import { ChunkFetcher } from "./ChunkFetcher.js";
+import type { ChunkFetchSource } from "./chunkFetchSource.js";
 import { ChunkManager } from "./ChunkManager.js";
 import { ConflictManager } from "./ConflictManager.js";
 import { EntryManager } from "./EntryManager/EntryManager.js";
@@ -15,6 +16,7 @@ export interface LiveSyncManagersOptions<TSettingService extends ISettingService
     pathService: IPathService;
     replicatorService: IReplicatorService;
     APIService: IAPIService;
+    chunkFetchSource?: ChunkFetchSource;
 }
 export declare class LiveSyncManagers {
     protected _pathService: IPathService;

package/dist/managers/LiveSyncManagers.js

@@ -76,6 +76,7 @@ class LiveSyncManagers {
     });
     const chunkFetcher = new ChunkFetcher({
       chunkManager,
+      source: this.options.chunkFetchSource,
       replicatorService: this.options.replicatorService,
       settingService: this.options.settingService
     });

package/dist/managers/chunkFetchSource.d.ts

@@ -0,0 +1,14 @@
+import type { DocumentID, EntryDoc, EntryLeaf } from "../common/types.js";
+/** IO supplied by a host whose chunk source does not use the active replicator. */
+export interface ChunkFetchSource {
+    /** Missing identifiers are omitted; false means that this request could not retrieve chunks. */
+    fetchChunks(ids: DocumentID[]): Promise<EntryLeaf[] | false>;
+    /** Accept fetched chunks before notifying waiting readers. */
+    storeChunks(chunks: EntryLeaf[]): Promise<void>;
+}
+/**
+ * Read through the prepared direct database, including its decryption transforms.
+ * The source already owns these documents, so accepting them performs no write.
+ * Construct a new source for each database lifetime.
+ */
+export declare function createDirectChunkFetchSource(database: PouchDB.Database<EntryDoc>): ChunkFetchSource;

package/dist/managers/chunkFetchSource.js

@@ -0,0 +1,12 @@
+function createDirectChunkFetchSource(database) {
+  return {
+    async fetchChunks(ids) {
+      const result = await database.allDocs({ keys: ids, include_docs: true });
+      return result.rows.flatMap((row) => "doc" in row && row.doc ? [row.doc] : []);
+    },
+    storeChunks: () => Promise.resolve()
+  };
+}
+export {
+  createDirectChunkFetchSource
+};

package/dist/platform/AmbiguousNormalisedPathError.d.ts

@@ -0,0 +1,16 @@
+/** More than one listed entry has the requested logical identity. */
+export declare class AmbiguousNormalisedPathError extends Error {
+    /** Path whose logical identity was ambiguous. */
+    readonly path: string;
+    /** Physical candidate paths copied from the listing which exposed the ambiguity. */
+    readonly candidates: readonly string[];
+    /**
+     * Describe an ambiguous request without choosing a physical candidate.
+     *
+     * @param path - Path whose logical identity matched multiple entries.
+     * @param candidates - Matching physical paths, copied into a frozen array.
+     */
+    constructor(
+    /** Path whose logical identity was ambiguous. */
+    path: string, candidates?: readonly string[]);
+}

package/dist/platform/AmbiguousNormalisedPathError.js

@@ -0,0 +1,21 @@
+class AmbiguousNormalisedPathError extends Error {
+  /**
+   * Describe an ambiguous request without choosing a physical candidate.
+   *
+   * @param path - Path whose logical identity matched multiple entries.
+   * @param candidates - Matching physical paths, copied into a frozen array.
+   */
+  constructor(path, candidates = []) {
+    const detail = candidates.length ? ` (${candidates.map((name) => JSON.stringify(name)).join(", ")})` : "";
+    super(`Ambiguous path after Unicode normalisation: ${path}${detail}`);
+    this.path = path;
+    this.name = "AmbiguousNormalisedPathError";
+    this.candidates = Object.freeze([...candidates]);
+  }
+  path;
+  /** Physical candidate paths copied from the listing which exposed the ambiguity. */
+  candidates;
+}
+export {
+  AmbiguousNormalisedPathError
+};

package/dist/platform/StoragePathResolver.d.ts

@@ -0,0 +1,15 @@
+import type { FilePath, ResolvedRename, StorageEntry, StoragePath, StoragePathResolver as ResolverContract, StoragePathResolverOptions } from "./pathTypes.js";
+/** Resolves listed names using one immutable NFC policy and no retained directory cache. */
+export declare class StoragePathResolver implements ResolverContract {
+    private readonly readDirectory;
+    private readonly policy;
+    constructor({ readDirectory, policy }: StoragePathResolverOptions);
+    resolveExisting(path: FilePath): Promise<StoragePath | null>;
+    resolveForWrite(path: FilePath): Promise<StoragePath>;
+    resolveRename(source: FilePath, target: FilePath): Promise<ResolvedRename | null>;
+    listResolvedDirectory(path: StoragePath): Promise<readonly StorageEntry[] | null>;
+    private resolve;
+    private findEntry;
+    private readEntries;
+    private key;
+}

package/dist/platform/StoragePathResolver.js

@@ -0,0 +1,113 @@
+import { getPathNormalizationVersion } from "../common/pathNormalization.js";
+import { AmbiguousNormalisedPathError } from "./AmbiguousNormalisedPathError.js";
+import { getStoragePathComparisonKey } from "./pathComparison.js";
+import { validateStoragePath } from "./storagePath.js";
+function storagePath(path) {
+  return validateStoragePath(path);
+}
+function childPath(parent, name) {
+  return storagePath(parent === "" ? name : `${parent}/${name}`);
+}
+function segments(path) {
+  validateStoragePath(path);
+  return path.split("/").filter(Boolean);
+}
+class StoragePathResolver {
+  readDirectory;
+  policy;
+  constructor({ readDirectory, policy }) {
+    if (getPathNormalizationVersion(policy) !== 1) {
+      throw new Error("Storage path resolution requires NFC path identity");
+    }
+    if (typeof policy.handleFilenameCaseSensitive !== "boolean") {
+      throw new TypeError("Filename case handling must be explicit");
+    }
+    this.readDirectory = readDirectory;
+    this.policy = Object.freeze({ ...policy });
+  }
+  async resolveExisting(path) {
+    return await this.resolve(path, false);
+  }
+  async resolveForWrite(path) {
+    const resolved = await this.resolve(path, true);
+    if (resolved === null) throw new Error(`Could not resolve storage target: ${path}`);
+    return resolved;
+  }
+  async resolveRename(source, target) {
+    validateStoragePath(source, false);
+    validateStoragePath(target, false);
+    const resolvedSource = await this.resolveExisting(source);
+    if (resolvedSource === null) return null;
+    const resolvedTarget = await this.resolveForWrite(target);
+    if (resolvedTarget !== resolvedSource || target === resolvedSource) {
+      return { source: resolvedSource, target: resolvedTarget };
+    }
+    const requestedParts = segments(target);
+    const leaf = requestedParts[requestedParts.length - 1];
+    const parent = storagePath(resolvedTarget.slice(0, Math.max(0, resolvedTarget.lastIndexOf("/"))));
+    return { source: resolvedSource, target: childPath(parent, leaf) };
+  }
+  async listResolvedDirectory(path) {
+    validateStoragePath(path);
+    const entries = await this.readEntries(path);
+    if (entries === null) return null;
+    const names = /* @__PURE__ */ new Map();
+    return entries.map((entry) => {
+      const actualPath = childPath(path, entry.name);
+      const key = this.key(entry.name);
+      const previous = names.get(key);
+      if (previous !== void 0) {
+        throw new AmbiguousNormalisedPathError(path, [previous, actualPath]);
+      }
+      names.set(key, actualPath);
+      return { path: actualPath, kind: entry.kind };
+    });
+  }
+  async resolve(path, allowMissing) {
+    const parts = segments(path);
+    let parent = storagePath("");
+    if (parts.length === 0) {
+      return allowMissing || await this.readEntries(parent) !== null ? parent : null;
+    }
+    for (let index = 0; index < parts.length; index++) {
+      const entries = await this.readEntries(parent);
+      const match = entries === null ? void 0 : this.findEntry(entries, parts[index], parent, path);
+      if (!match) {
+        return allowMissing ? childPath(parent, parts.slice(index).join("/")) : null;
+      }
+      parent = childPath(parent, match.name);
+      if (index < parts.length - 1 && match.kind !== "directory") {
+        throw new Error(`A storage path parent is not a directory: ${parent}`);
+      }
+    }
+    return parent;
+  }
+  findEntry(entries, name, parent, requestedPath) {
+    const key = this.key(name);
+    const matches = entries.filter((entry) => this.key(entry.name) === key);
+    if (matches.length > 1) {
+      throw new AmbiguousNormalisedPathError(
+        requestedPath,
+        matches.map((entry) => childPath(parent, entry.name))
+      );
+    }
+    return matches[0];
+  }
+  async readEntries(path) {
+    const entries = await this.readDirectory(path);
+    if (entries === null) return null;
+    for (const entry of entries) {
+      if (typeof entry.name !== "string" || entry.name === "" || entry.name === "." || entry.name === ".." || /[\/\\\0]/u.test(entry.name) || entry.kind !== "file" && entry.kind !== "directory") {
+        throw new TypeError(`Invalid directory entry below ${JSON.stringify(path)}`);
+      }
+      childPath(path, entry.name);
+    }
+    return entries;
+  }
+  key(name) {
+    return getStoragePathComparisonKey(name, this.policy);
+  }
+}
+export {
+  StoragePathResolver
+};

package/dist/platform/browser/UnicodeResolvingFileSystemAccessStorageAdapter.d.ts

@@ -0,0 +1,74 @@
+import type { UXDataWriteOptions } from "../../common/types.js";
+import type { IStorageAdapter } from "../../serviceModules/adapters/IStorageAdapter.js";
+import type { FilePath, StoragePath } from "../pathTypes.js";
+import { type FileSystemAccessStorageStat } from "./storage.js";
+/**
+ * Resolve NFC-equivalent logical paths against current File System Access directory names.
+ *
+ * @remarks
+ * Each operation snapshots Unicode and case settings. Version `0` delegates to
+ * the existing adapter; version `1` resolves names and rejects observed aliases
+ * before I/O. Physical spelling and the host adapter's mutation semantics remain
+ * unchanged. Resolution does not reserve paths against concurrent changes.
+ */
+export declare class UnicodeResolvingFileSystemAccessStorageAdapter implements IStorageAdapter<FileSystemAccessStorageStat> {
+    private readonly getPathNormalizationVersion;
+    private readonly isCaseInsensitive;
+    private readonly storage;
+    /**
+     * Bind a host-owned root and callbacks for each operation's comparison settings.
+     *
+     * @param rootHandle - Host-selected directory handle with the required permissions.
+     * @param getPathNormalizationVersion - Supplies `0` or `1`; defaults to Legacy `0`.
+     * @param isCaseInsensitive - Whether comparisons ignore case; defaults to false.
+     */
+    constructor(rootHandle: FileSystemDirectoryHandle, getPathNormalizationVersion?: () => number, isCaseInsensitive?: () => boolean);
+    /** Whether the current settings select NFC path resolution. */
+    get isUnicodePathNormalizationEnabled(): boolean;
+    /**
+     * Resolve a logical path under one snapshot of the current settings.
+     *
+     * @param path - Original root-relative file path.
+     * @param caseInsensitive - Override this lookup's case rule without changing settings.
+     * @param allowMissing - Keep a missing write suffix when true; defaults to true.
+     * @returns The physical target, or `null` for an absent path when `allowMissing`
+     * is false in NFC mode. Legacy mode returns the validated original path.
+     * @throws Propagates NFC ambiguity and reader failures, and rejects invalid input.
+     */
+    resolveLogicalPath(path: FilePath, caseInsensitive?: boolean, allowMissing?: boolean): Promise<StoragePath | null>;
+    /** Read metadata for a physical path without performing another logical lookup. */
+    statExact(path: StoragePath): Promise<FileSystemAccessStorageStat | null>;
+    /** List a physical directory, rejecting equivalent child names in NFC mode. */
+    listExact(path: StoragePath): Promise<{
+        files: string[];
+        folders: string[];
+    }>;
+    /** Check whether the logical path exists under the current Unicode policy. */
+    exists(path: string): Promise<boolean>;
+    /** Read logical-path metadata, retaining Legacy adapter behaviour in version `0`. */
+    trystat(path: string): Promise<FileSystemAccessStorageStat | null>;
+    /** Read logical-path metadata, retaining Legacy adapter behaviour in version `0`. */
+    stat(path: string): Promise<FileSystemAccessStorageStat | null>;
+    /** Create a directory at the resolved write target. */
+    mkdir(path: string): Promise<void>;
+    /** Remove the entry at its resolved physical path. */
+    remove(path: string): Promise<void>;
+    /** Read text from the resolved physical file. */
+    read(path: string): Promise<string>;
+    /** Read bytes from the resolved physical file. */
+    readBinary(path: string): Promise<ArrayBuffer>;
+    /** Write text at the resolved target while retaining existing physical spelling. */
+    write(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+    /** Write bytes at the resolved target while retaining existing physical spelling. */
+    writeBinary(path: string, data: ArrayBuffer, options?: UXDataWriteOptions): Promise<void>;
+    /** Append text at the resolved target using the host adapter semantics. */
+    append(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+    /** List logical directory contents, checking equivalent child names in NFC mode. */
+    list(basePath: string): Promise<{
+        files: string[];
+        folders: string[];
+    }>;
+    private snapshotPolicy;
+    private createResolver;
+    private groupStorageEntries;
+}