@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/managers/adapters/IStorageEventTypeGuardAdapter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Adapter interface for type guard operations in StorageEventManager
+ *
+ * @template TFile - Platform-specific file type
+ * @template TFolder - Platform-specific folder type
+ */
+export interface IStorageEventTypeGuardAdapter<TFile, TFolder> {
+    /**
+     * Check if the given item is a file
+     */
+    isFile(file: unknown): file is TFile;
+    /**
+     * Check if the given item is a folder
+     */
+    isFolder(item: unknown): item is TFolder;
+}

package/dist/managers/adapters/IStorageEventWatchAdapter.d.ts

@@ -0,0 +1,21 @@
+import type { FilePath } from "../../common/types.js";
+/**
+ * Event handlers for storage events
+ */
+export interface IStorageEventWatchHandlers<TFile = unknown, TCtx = unknown> {
+    onCreate: (file: TFile, ctx?: TCtx) => void;
+    onChange: (file: TFile, ctx?: TCtx) => void;
+    onDelete: (file: TFile, ctx?: TCtx) => void;
+    onRename: (file: TFile, oldPath: string, ctx?: TCtx) => void;
+    onRaw: (path: FilePath) => void;
+    onEditorChange?: <TEditor = unknown, TInfo = unknown>(editor: TEditor, info: TInfo) => void;
+}
+/**
+ * Adapter interface for watching vault/storage events
+ */
+export interface IStorageEventWatchAdapter<TFile = unknown, TCtx = unknown> {
+    /**
+     * Begin watching for storage events
+     */
+    beginWatch(handlers: IStorageEventWatchHandlers<TFile, TCtx>): Promise<void>;
+}

package/dist/managers/adapters/index.d.ts

@@ -0,0 +1,6 @@
+export type { IStorageEventTypeGuardAdapter } from "./IStorageEventTypeGuardAdapter.js";
+export type { IStorageEventPersistenceAdapter } from "./IStorageEventPersistenceAdapter.js";
+export type { IStorageEventWatchAdapter, IStorageEventWatchHandlers } from "./IStorageEventWatchAdapter.js";
+export type { IStorageEventStatusAdapter } from "./IStorageEventStatusAdapter.js";
+export type { IStorageEventConverterAdapter } from "./IStorageEventConverterAdapter.js";
+export type { IStorageEventManagerAdapter } from "./IStorageEventManagerAdapter.js";

package/dist/mock_and_interop/stores.d.ts

@@ -0,0 +1,21 @@
+import type { LOG_LEVEL } from "../common/types.js";
+export type LockStats = {
+    pending: string[];
+    running: string[];
+    count: number;
+};
+export declare const lockStats: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<{
+    pending: any[];
+    running: any[];
+    count: number;
+}>;
+export declare const collectingChunks: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<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>;
+export type LogEntry = {
+    message: string | Error;
+    level?: LOG_LEVEL;
+    key?: string;
+};
+export declare const logMessages: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<string[]>;

package/dist/mock_and_interop/stores.js

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

package/dist/mock_and_interop/wrapper.d.ts

@@ -0,0 +1,7 @@
+export declare class WrappedNotice {
+    constructor(message: string | DocumentFragment, timeout?: number);
+    setMessage(message: string | DocumentFragment): this;
+    hide(): void;
+}
+export declare function setNoticeClass(notice: typeof WrappedNotice): void;
+export declare function NewNotice(message: string | DocumentFragment, timeout?: number): WrappedNotice;

package/dist/mock_and_interop/wrapper.js

@@ -0,0 +1,37 @@
+import { Logger } from "../common/logger.js";
+import { LOG_LEVEL_NOTICE } from "../common/types.js";
+class WrappedNotice {
+  constructor(message, timeout) {
+    let strMessage = "";
+    if (message instanceof DocumentFragment) {
+      strMessage = message.textContent ?? "";
+    } else {
+      strMessage = message;
+    }
+    Logger(strMessage, LOG_LEVEL_NOTICE);
+  }
+  setMessage(message) {
+    let strMessage = "";
+    if (message instanceof DocumentFragment) {
+      strMessage = message.textContent ?? "";
+    } else {
+      strMessage = message;
+    }
+    Logger(strMessage, LOG_LEVEL_NOTICE);
+    return this;
+  }
+  hide() {
+  }
+}
+let _notice = WrappedNotice;
+function setNoticeClass(notice) {
+  _notice = notice;
+}
+function NewNotice(message, timeout) {
+  return new _notice(message, timeout);
+}
+export {
+  NewNotice,
+  WrappedNotice,
+  setNoticeClass
+};

package/dist/mods.d.ts

@@ -0,0 +1 @@
+export declare function getWebCrypto(): Promise<Crypto>;

package/dist/mods.js

@@ -0,0 +1,18 @@
+import { compatGlobal } from "./common/coreEnvFunctions.js";
+let webcrypto;
+async function getWebCrypto() {
+  if (webcrypto) {
+    return webcrypto;
+  }
+  if (compatGlobal.crypto) {
+    webcrypto = compatGlobal.crypto;
+    return webcrypto;
+  } else {
+    const module = await import("crypto");
+    webcrypto = module.webcrypto;
+    return webcrypto;
+  }
+}
+export {
+  getWebCrypto
+};

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

@@ -0,0 +1 @@
+export { FileSystemAccessStorageAdapter, createFileSystemAccessStorage, validateStoragePath, type CreateFileSystemAccessStorageOptions, type FileSystemAccessStorageStat, } from "./storage.js";

package/dist/platform/browser/index.js

@@ -0,0 +1,10 @@
+import {
+  FileSystemAccessStorageAdapter,
+  createFileSystemAccessStorage,
+  validateStoragePath
+} from "./storage.js";
+export {
+  FileSystemAccessStorageAdapter,
+  createFileSystemAccessStorage,
+  validateStoragePath
+};

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

@@ -0,0 +1,35 @@
+import type { UXDataWriteOptions, UXStat } from "../../common/types.js";
+import type { IStorageAdapter } from "../../serviceModules/adapters/IStorageAdapter.js";
+export type FileSystemAccessStorageStat = UXStat;
+export interface CreateFileSystemAccessStorageOptions {
+    /** A directory handle already selected and authorised by the host application. */
+    rootHandle: FileSystemDirectoryHandle;
+}
+/** Rooted storage adapter backed by the browser File System Access API. */
+export declare class FileSystemAccessStorageAdapter implements IStorageAdapter<FileSystemAccessStorageStat> {
+    private readonly rootHandle;
+    constructor(rootHandle: FileSystemDirectoryHandle);
+    private resolvePath;
+    private getFileHandle;
+    private getDirectoryHandle;
+    private resolveWritablePath;
+    exists(path: string): Promise<boolean>;
+    trystat(path: string): Promise<FileSystemAccessStorageStat | null>;
+    stat(path: string): Promise<FileSystemAccessStorageStat | null>;
+    mkdir(path: string): Promise<void>;
+    remove(path: string): Promise<void>;
+    read(path: string): Promise<string>;
+    readBinary(path: string): Promise<ArrayBuffer>;
+    write(path: string, data: string, _options?: UXDataWriteOptions): Promise<void>;
+    writeBinary(path: string, data: ArrayBuffer, _options?: UXDataWriteOptions): Promise<void>;
+    append(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+    list(basePath: string): Promise<{
+        files: string[];
+        folders: string[];
+    }>;
+    private requireFileHandle;
+    private writeValue;
+}
+/** Bind a browser storage adapter to an explicitly selected and authorised directory handle. */
+export declare function createFileSystemAccessStorage({ rootHandle, }: CreateFileSystemAccessStorageOptions): FileSystemAccessStorageAdapter;
+export { validateStoragePath } from "../storagePath.js";

package/dist/platform/browser/storage.js

@@ -0,0 +1,139 @@
+import { validateStoragePath } from "../storagePath.js";
+class FileSystemAccessStorageAdapter {
+  constructor(rootHandle) {
+    this.rootHandle = rootHandle;
+  }
+  rootHandle;
+  async resolvePath(path) {
+    validateStoragePath(path, false);
+    try {
+      const parts = path.split("/").filter((part) => part !== "");
+      let currentHandle = this.rootHandle;
+      const fileName = parts[parts.length - 1];
+      for (let index = 0; index < parts.length - 1; index++) {
+        currentHandle = await currentHandle.getDirectoryHandle(parts[index]);
+      }
+      return { dirHandle: currentHandle, fileName };
+    } catch {
+      return null;
+    }
+  }
+  async getFileHandle(path) {
+    validateStoragePath(path);
+    if (path === "") return null;
+    const resolved = await this.resolvePath(path);
+    if (!resolved) return null;
+    try {
+      return await resolved.dirHandle.getFileHandle(resolved.fileName);
+    } catch {
+      return null;
+    }
+  }
+  async getDirectoryHandle(path) {
+    validateStoragePath(path);
+    try {
+      const parts = path.split("/").filter((part) => part !== "");
+      let currentHandle = this.rootHandle;
+      for (const part of parts) currentHandle = await currentHandle.getDirectoryHandle(part);
+      return currentHandle;
+    } catch {
+      return null;
+    }
+  }
+  async resolveWritablePath(path) {
+    validateStoragePath(path, false);
+    const parts = path.split("/").filter((part) => part !== "");
+    const fileName = parts.pop();
+    const parentPath = parts.join("/");
+    await this.mkdir(parentPath);
+    const dirHandle = await this.getDirectoryHandle(parentPath);
+    return dirHandle ? { dirHandle, fileName } : null;
+  }
+  async exists(path) {
+    return await this.getFileHandle(path) !== null || await this.getDirectoryHandle(path) !== null;
+  }
+  async trystat(path) {
+    const fileHandle = await this.getFileHandle(path);
+    if (fileHandle) {
+      const file = await fileHandle.getFile();
+      return {
+        size: file.size,
+        mtime: file.lastModified,
+        ctime: file.lastModified,
+        type: "file"
+      };
+    }
+    if (await this.getDirectoryHandle(path)) {
+      return { size: 0, mtime: Date.now(), ctime: Date.now(), type: "folder" };
+    }
+    return null;
+  }
+  async stat(path) {
+    return await this.trystat(path);
+  }
+  async mkdir(path) {
+    validateStoragePath(path);
+    let currentHandle = this.rootHandle;
+    for (const part of path.split("/").filter((part2) => part2 !== "")) {
+      currentHandle = await currentHandle.getDirectoryHandle(part, { create: true });
+    }
+  }
+  async remove(path) {
+    const resolved = await this.resolvePath(path);
+    if (!resolved) return;
+    await resolved.dirHandle.removeEntry(resolved.fileName, { recursive: true });
+  }
+  async read(path) {
+    const handle = await this.requireFileHandle(path);
+    return await (await handle.getFile()).text();
+  }
+  async readBinary(path) {
+    const handle = await this.requireFileHandle(path);
+    return await (await handle.getFile()).arrayBuffer();
+  }
+  async write(path, data, _options) {
+    await this.writeValue(path, data);
+  }
+  async writeBinary(path, data, _options) {
+    await this.writeValue(path, data);
+  }
+  async append(path, data, options) {
+    await this.write(path, await this.exists(path) ? await this.read(path) + data : data, options);
+  }
+  async list(basePath) {
+    const dirHandle = await this.getDirectoryHandle(basePath);
+    if (!dirHandle) return { files: [], folders: [] };
+    const files = [];
+    const folders = [];
+    for await (const [name, entry] of dirHandle.entries()) {
+      const entryPath = basePath ? `${basePath}/${name}` : name;
+      if (entry.kind === "directory") folders.push(entryPath);
+      else if (entry.kind === "file") files.push(entryPath);
+    }
+    return { files, folders };
+  }
+  async requireFileHandle(path) {
+    const handle = await this.getFileHandle(path);
+    if (!handle) throw new Error(`File not found: ${path}`);
+    return handle;
+  }
+  async writeValue(path, data) {
+    const resolved = await this.resolveWritablePath(path);
+    if (!resolved) throw new Error(`Invalid path: ${path}`);
+    const handle = await resolved.dirHandle.getFileHandle(resolved.fileName, { create: true });
+    const writable = await handle.createWritable();
+    await writable.write(data);
+    await writable.close();
+  }
+}
+function createFileSystemAccessStorage({
+  rootHandle
+}) {
+  return new FileSystemAccessStorageAdapter(rootHandle);
+}
+import { validateStoragePath as validateStoragePath2 } from "../storagePath.js";
+export {
+  FileSystemAccessStorageAdapter,
+  createFileSystemAccessStorage,
+  validateStoragePath2 as validateStoragePath
+};

package/dist/platform/node/index.d.ts

@@ -0,0 +1,23 @@
+/** Node-only host capabilities for Commonlib headless and CLI consumers. */
+import * as nodeFs from "node:fs";
+import * as nodePath from "node:path";
+import * as nodeReadlinePromises from "node:readline/promises";
+import * as nodeOs from "node:os";
+import { isBuiltin as nodeIsBuiltin } from "node:module";
+export { fileURLToPath, pathToFileURL } from "node:url";
+export type { Stats } from "node:fs";
+/** Synchronous Node file-system API. */
+export declare const fs: typeof nodeFs;
+/** Promise-based Node file-system API. */
+export declare const fsPromises: typeof nodeFs.promises;
+/** Node path API. */
+export declare const path: nodePath.PlatformPath;
+/** Node operating-system API. */
+export declare const os: typeof nodeOs;
+/** Promise-based Node readline API. */
+export declare const readline: typeof nodeReadlinePromises;
+/** Names recognised by the current Node runtime as built-in modules. */
+export declare const builtinModules: readonly string[];
+/** Returns whether a module specifier refers to a Node built-in. */
+export declare const isBuiltin: typeof nodeIsBuiltin;
+export { NodeStorageAdapter, createNodeStorage, validateStoragePath, type CreateNodeStorageOptions, type NodeStorageStat, } from "./storage.js";

package/dist/platform/node/index.js

@@ -0,0 +1,33 @@
+import * as nodeFs from "node:fs";
+import * as nodeFsPromises from "node:fs/promises";
+import * as nodePath from "node:path";
+import * as nodeReadlinePromises from "node:readline/promises";
+import * as nodeOs from "node:os";
+import { builtinModules as nodeBuiltinModules, isBuiltin as nodeIsBuiltin } from "node:module";
+import { fileURLToPath, pathToFileURL } from "node:url";
+const fs = nodeFs;
+const fsPromises = nodeFsPromises;
+const path = nodePath;
+const os = nodeOs;
+const readline = nodeReadlinePromises;
+const builtinModules = nodeBuiltinModules;
+const isBuiltin = nodeIsBuiltin;
+import {
+  NodeStorageAdapter,
+  createNodeStorage,
+  validateStoragePath
+} from "./storage.js";
+export {
+  NodeStorageAdapter,
+  builtinModules,
+  createNodeStorage,
+  fileURLToPath,
+  fs,
+  fsPromises,
+  isBuiltin,
+  os,
+  path,
+  pathToFileURL,
+  readline,
+  validateStoragePath
+};

package/dist/platform/node/storage.d.ts

@@ -0,0 +1,31 @@
+import type { UXDataWriteOptions, UXStat } from "../../common/types.js";
+import type { IStorageAdapter } from "../../serviceModules/adapters/IStorageAdapter.js";
+export type NodeStorageStat = UXStat;
+export interface CreateNodeStorageOptions {
+    /** Absolute or process-relative directory which bounds every adapter operation. */
+    rootPath: string;
+}
+/** Rooted storage adapter backed by Node's file-system APIs. */
+export declare class NodeStorageAdapter implements IStorageAdapter<NodeStorageStat> {
+    private readonly rootPath;
+    constructor(rootPath: string);
+    private resolvePath;
+    exists(path: string): Promise<boolean>;
+    trystat(path: string): Promise<NodeStorageStat | null>;
+    stat(path: string): Promise<NodeStorageStat | null>;
+    mkdir(path: string): Promise<void>;
+    remove(path: string): Promise<void>;
+    read(path: string): Promise<string>;
+    readBinary(path: string): Promise<ArrayBuffer>;
+    write(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+    writeBinary(path: string, data: ArrayBuffer, options?: UXDataWriteOptions): Promise<void>;
+    append(path: string, data: string, options?: UXDataWriteOptions): Promise<void>;
+    list(basePath: string): Promise<{
+        files: string[];
+        folders: string[];
+    }>;
+    private applyTimes;
+}
+/** Bind a Node storage adapter to an explicitly selected root directory. */
+export declare function createNodeStorage({ rootPath }: CreateNodeStorageOptions): NodeStorageAdapter;
+export { validateStoragePath } from "../storagePath.js";

package/dist/platform/node/storage.js

@@ -0,0 +1,104 @@
+import * as nodeFsPromises from "node:fs/promises";
+import * as nodePath from "node:path";
+import { validateStoragePath } from "../storagePath.js";
+class NodeStorageAdapter {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+  }
+  rootPath;
+  resolvePath(path, allowRoot = true) {
+    return nodePath.join(this.rootPath, validateStoragePath(path, allowRoot));
+  }
+  async exists(path) {
+    const fullPath = this.resolvePath(path);
+    try {
+      await nodeFsPromises.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async trystat(path) {
+    try {
+      const stat = await nodeFsPromises.stat(this.resolvePath(path));
+      return {
+        size: stat.size,
+        mtime: Math.floor(stat.mtimeMs),
+        ctime: Math.floor(stat.ctimeMs),
+        type: stat.isDirectory() ? "folder" : "file"
+      };
+    } catch {
+      return null;
+    }
+  }
+  async stat(path) {
+    return await this.trystat(path);
+  }
+  async mkdir(path) {
+    await nodeFsPromises.mkdir(this.resolvePath(path), { recursive: true });
+  }
+  async remove(path) {
+    const fullPath = this.resolvePath(path, false);
+    const stat = await nodeFsPromises.stat(fullPath);
+    if (stat.isDirectory()) {
+      await nodeFsPromises.rm(fullPath, { recursive: true, force: true });
+    } else {
+      await nodeFsPromises.unlink(fullPath);
+    }
+  }
+  async read(path) {
+    return await nodeFsPromises.readFile(this.resolvePath(path, false), "utf-8");
+  }
+  async readBinary(path) {
+    const buffer = await nodeFsPromises.readFile(this.resolvePath(path, false));
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+  async write(path, data, options) {
+    const fullPath = this.resolvePath(path, false);
+    await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
+    await nodeFsPromises.writeFile(fullPath, data, "utf-8");
+    await this.applyTimes(fullPath, options);
+  }
+  async writeBinary(path, data, options) {
+    const fullPath = this.resolvePath(path, false);
+    await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
+    await nodeFsPromises.writeFile(fullPath, new Uint8Array(data));
+    await this.applyTimes(fullPath, options);
+  }
+  async append(path, data, options) {
+    const fullPath = this.resolvePath(path, false);
+    await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
+    await nodeFsPromises.appendFile(fullPath, data, "utf-8");
+    await this.applyTimes(fullPath, options);
+  }
+  async list(basePath) {
+    try {
+      const entries = await nodeFsPromises.readdir(this.resolvePath(basePath), { withFileTypes: true });
+      const files = [];
+      const folders = [];
+      for (const entry of entries) {
+        const entryPath = nodePath.join(basePath, entry.name).replace(/\\/g, "/");
+        if (entry.isDirectory()) folders.push(entryPath);
+        else if (entry.isFile()) files.push(entryPath);
+      }
+      return { files, folders };
+    } catch {
+      return { files: [], folders: [] };
+    }
+  }
+  async applyTimes(fullPath, options) {
+    if (!options?.mtime && !options?.ctime) return;
+    const accessTime = options.mtime ? new Date(options.mtime) : /* @__PURE__ */ new Date();
+    const modificationTime = options.mtime ? new Date(options.mtime) : /* @__PURE__ */ new Date();
+    await nodeFsPromises.utimes(fullPath, accessTime, modificationTime);
+  }
+}
+function createNodeStorage({ rootPath }) {
+  return new NodeStorageAdapter(rootPath);
+}
+import { validateStoragePath as validateStoragePath2 } from "../storagePath.js";
+export {
+  NodeStorageAdapter,
+  createNodeStorage,
+  validateStoragePath2 as validateStoragePath
+};

package/dist/platform/storagePath.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Validate the platform-neutral path vocabulary used by rooted storage adapters.
+ *
+ * Paths are slash-separated and relative to the root bound to the adapter. Root
+ * selection and authorisation happen before the adapter is constructed.
+ */
+export declare function validateStoragePath(storagePath: string, allowRoot?: boolean): string;

package/dist/platform/storagePath.js

@@ -0,0 +1,20 @@
+function validateStoragePath(storagePath, allowRoot = true) {
+  if (storagePath === "") {
+    if (allowRoot) return storagePath;
+    throw new Error("The storage root is not a valid entry path");
+  }
+  if (storagePath.startsWith("/") || storagePath.startsWith("\\") || /^[A-Za-z]:/.test(storagePath)) {
+    throw new Error(`Storage paths must be relative to the configured root: ${storagePath}`);
+  }
+  if (storagePath.includes("\\")) {
+    throw new Error(`Storage paths must use forward slashes: ${storagePath}`);
+  }
+  const segments = storagePath.split("/");
+  if (segments.some((segment) => segment === "." || segment === "..")) {
+    throw new Error(`Storage paths must not contain traversal segments: ${storagePath}`);
+  }
+  return storagePath;
+}
+export {
+  validateStoragePath
+};

package/dist/pouchdb/LiveSyncDBFunctions.d.ts

@@ -0,0 +1,14 @@
+import { type EntryDoc, type EntryMilestoneInfo, type RemoteDBSettings, type ChunkVersionRange, type TweakValues, type DeviceInfo } from "../common/types.js";
+export type ENSURE_DB_RESULT = "OK" | "INCOMPATIBLE" | "LOCKED" | "NODE_LOCKED" | "NODE_CLEANED" | ["MISMATCHED", TweakValues];
+/**
+ * Ensures that the remote database is compatible with the current device.
+ *
+ * @param infoSrc - The information about the remote database (which retrieved from the remote).
+ * @param setting - The current settings.
+ * @param deviceNodeID - The ID of the current device node.
+ * @param currentVersionRange - The current version range of the database.
+ * @param updateCallback - The callback function to update the remote milestone.
+ * @returns A promise that resolves to the result of ensuring compatibility.
+ */
+export declare function ensureRemoteIsCompatible(infoSrc: EntryMilestoneInfo | false, setting: RemoteDBSettings, deviceNodeID: string, currentVersionRange: ChunkVersionRange, nodeDeviceInfo: DeviceInfo, updateCallback: (info: EntryMilestoneInfo) => Promise<void>): Promise<ENSURE_DB_RESULT>;
+export declare function ensureDatabaseIsCompatible(db: PouchDB.Database<EntryDoc>, setting: RemoteDBSettings, deviceNodeID: string, currentVersionRange: ChunkVersionRange, nodeDeviceInfo: DeviceInfo): Promise<ENSURE_DB_RESULT>;