@vrtmrz/livesync-commonlib 0.1.0-rc.1 → 0.1.0-rc.11

package/dist/common/settingConstants.js

@@ -1,4 +1,4 @@
-import { $t } from "./i18n.js";
+import { englishMessageTranslator } from "../services/base/MessageTranslator.js";
 import {
   DEFAULT_SETTINGS,
   configurationNames
@@ -324,12 +324,12 @@ const SettingInformation = {
     desc: "If this enabled, All files are handled as case-Sensitive (Previous behaviour)."
   },
   doNotUseFixedRevisionForChunks: {
-    name: "Compute revisions for chunks",
-    desc: "If this enabled, all chunks will be stored with the revision made from its content."
+    name: "Content-derived chunk revisions (obsolete setting)",
+    desc: "Chunk revisions are always derived from their content. This stored key is retained only for compatibility."
   },
   sendChunksBulkMaxSize: {
-    name: "Maximum size of chunks to send in one request",
-    desc: "MB"
+    name: "Maximum request size for manually resending chunks",
+    desc: "MB per request"
   },
   useAdvancedMode: {
     name: "Enable advanced features"
@@ -399,7 +399,7 @@ const SettingInformation = {
     desc: "Files with modification times greater than this value (in seconds since the Unix epoch) will not have their events reflected. Set to 0 to disable this limit."
   }
 };
-function translateInfo(infoSrc, translate = (message) => $t(message)) {
+function translateInfo(infoSrc, translate = englishMessageTranslator) {
   if (!infoSrc) return false;
   const info = { ...infoSrc };
   info.name = translate(info.name);

package/dist/common/types.d.ts

@@ -10,7 +10,8 @@ import { IDPrefixes, LEAF_WAIT_ONLY_REMOTE, LEAF_WAIT_TIMEOUT, LEAF_WAIT_TIMEOUT
 import { AutoAccepting, type BucketSyncSetting, type ChunkSplitterVersion, type ConfigPassphraseStore, type CouchDBConnection, type E2EEAlgorithm, type EncryptionSettings, type HashAlgorithm, type HasSettings, type LocalDBSettings, type ObsidianLiveSyncSettings, type P2PConnectionInfo, type P2PSyncSetting, type PluginSyncSettingEntry, type RemoteDBSettings, type RemoteType, type RemoteTypeSettings, type SYNC_MODE } from "./models/setting.type.js";
 import { ChunkAlgorithmNames, ChunkAlgorithms, CURRENT_SETTING_VERSION, E2EEAlgorithmNames, E2EEAlgorithms, HashAlgorithms, REMOTE_COUCHDB, REMOTE_MINIO, REMOTE_P2P, RemoteTypes, SETTING_VERSION_INITIAL, SETTING_VERSION_SUPPORT_CASE_INSENSITIVE, MODE_AUTOMATIC, MODE_PAUSED, MODE_SELECTIVE, MODE_SHINY } from "./models/setting.const.js";
 import { PREFERRED_BASE, PREFERRED_JOURNAL_SYNC, PREFERRED_SETTING_CLOUDANT, PREFERRED_SETTING_SELF_HOSTED } from "./models/setting.const.preferred.js";
-import { P2P_DEFAULT_SETTINGS, DEFAULT_SETTINGS } from "./models/setting.const.defaults.js";
+import { P2P_DEFAULT_SETTINGS, DEFAULT_SETTINGS, NEW_VAULT_SETTINGS, SETTINGS_SCHEMA_DEFAULTS, createNewVaultSettings } from "./models/setting.const.defaults.js";
+import { prepareSettingsForLoad, SettingsMigrationReviewCodes, type PreparedSettings, type SettingsMigrationReviewCode, type SettingsMigrationReviewReason, type SettingsMigrationState } from "./models/setting.lifecycle.js";
 import { KeyIndexOfSettings } from "./models/setting.const.qr.js";
 import type { DeviceInfo, EntryBody, EntryDoc, EntryDocResponse, EntryMilestoneInfo, EntryNodeInfo, NodeData, NodeKey } from "./models/db.definition.js";
 import { isMetaEntry } from "./models/db.definition.js";
@@ -42,7 +43,8 @@ export type { EncryptionSettings };
 export { HashAlgorithms, type HashAlgorithm, ChunkAlgorithmNames, ChunkAlgorithms, type ChunkSplitterVersion };
 export type { RemoteDBSettings };
 export type { ObsidianLiveSyncSettings };
-export { DEFAULT_SETTINGS };
+export { DEFAULT_SETTINGS, NEW_VAULT_SETTINGS, SETTINGS_SCHEMA_DEFAULTS, createNewVaultSettings };
+export { prepareSettingsForLoad, SettingsMigrationReviewCodes, type PreparedSettings, type SettingsMigrationReviewCode, type SettingsMigrationReviewReason, type SettingsMigrationState, };
 export { KeyIndexOfSettings };
 export { type HasSettings };
 export { PREFERRED_BASE, PREFERRED_SETTING_CLOUDANT, PREFERRED_SETTING_SELF_HOSTED, PREFERRED_JOURNAL_SYNC };

package/dist/common/types.js

@@ -67,7 +67,17 @@ import {
   PREFERRED_SETTING_CLOUDANT,
   PREFERRED_SETTING_SELF_HOSTED
 } from "./models/setting.const.preferred.js";
-import { P2P_DEFAULT_SETTINGS, DEFAULT_SETTINGS } from "./models/setting.const.defaults.js";
+import {
+  P2P_DEFAULT_SETTINGS,
+  DEFAULT_SETTINGS,
+  NEW_VAULT_SETTINGS,
+  SETTINGS_SCHEMA_DEFAULTS,
+  createNewVaultSettings
+} from "./models/setting.const.defaults.js";
+import {
+  prepareSettingsForLoad,
+  SettingsMigrationReviewCodes
+} from "./models/setting.lifecycle.js";
 import { KeyIndexOfSettings } from "./models/setting.const.qr.js";
 import { isMetaEntry } from "./models/db.definition.js";
 import {
@@ -165,6 +175,7 @@ export {
   MODE_PAUSED,
   MODE_SELECTIVE,
   MODE_SHINY,
+  NEW_VAULT_SETTINGS,
   NODEINFO_DOCID,
   NOT_CONFLICTED,
   NoteTypes,
@@ -190,10 +201,12 @@ export {
   SALT_OF_ID,
   SALT_OF_PASSPHRASE,
   SEED_MURMURHASH,
+  SETTINGS_SCHEMA_DEFAULTS,
   SETTING_KEY_P2P_DEVICE_NAME,
   SETTING_VERSION_INITIAL,
   SETTING_VERSION_SUPPORT_CASE_INSENSITIVE,
   SYNCINFO_ID,
+  SettingsMigrationReviewCodes,
   SuffixDatabaseName,
   TIME_ARGUMENT_INFINITY,
   TweakValuesDefault,
@@ -207,6 +220,8 @@ export {
   configURIBase,
   configURIBaseQR,
   configurationNames,
+  createNewVaultSettings,
   isMetaEntry,
+  prepareSettingsForLoad,
   statusDisplay
 };

package/dist/context.d.ts

@@ -5,5 +5,6 @@
  */
 export { ServiceContext, createServiceContext, type ServiceContextContract, type ServiceContextOptions, } from "./services/base/ServiceBase.js";
 export { createLiveSyncEventHub, type LiveSyncEventHub } from "./hub/hub.js";
-export { passthroughMessageTranslator, type MessageTranslator, type TranslationParameters, } from "./services/base/MessageTranslator.js";
+export { englishMessageTranslator, passthroughMessageTranslator, type MessageTranslator, type TranslationParameters, } from "./services/base/MessageTranslator.js";
+export { commonlibEnglishMessages, type CommonlibMessageKey } from "./services/base/CommonlibMessages.js";
 export type { StandardIo, StandardIoChunk } from "./platform/standardIo.js";

package/dist/context.js

@@ -4,11 +4,15 @@ import {
 } from "./services/base/ServiceBase.js";
 import { createLiveSyncEventHub } from "./hub/hub.js";
 import {
+  englishMessageTranslator,
   passthroughMessageTranslator
 } from "./services/base/MessageTranslator.js";
+import { commonlibEnglishMessages } from "./services/base/CommonlibMessages.js";
 export {
   ServiceContext,
+  commonlibEnglishMessages,
   createLiveSyncEventHub,
   createServiceContext,
+  englishMessageTranslator,
   passthroughMessageTranslator
 };

package/dist/interfaces/Confirm.d.ts

@@ -1,3 +1,4 @@
+export type ConfirmActionLayout = "auto" | "vertical";
 export interface Confirm {
     askYesNo(message: string): Promise<"yes" | "no">;
     askString(title: string, key: string, placeholder: string, isPassword?: boolean): Promise<string | false>;
@@ -12,6 +13,13 @@ export interface Confirm {
         defaultAction: T[number];
         timeout?: number;
     }): Promise<T[number] | false>;
-    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void): void;
-    confirmWithMessage(title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number): Promise<(typeof buttons)[number] | false>;
+    /**
+     * Shows a non-blocking message containing one host-rendered action link.
+     *
+     * Hosts which can display transient UI should keep the message visible for
+     * `durationMs`. Headless hosts may report the message without presenting an
+     * interactive action.
+     */
+    askInPopup(key: string, dialogText: string, anchorCallback: (anchor: HTMLAnchorElement) => void, durationMs?: number): void;
+    confirmWithMessage(title: string, contentMd: string, buttons: string[], defaultAction: (typeof buttons)[number], timeout?: number, actionLayout?: ConfirmActionLayout): Promise<(typeof buttons)[number] | false>;
 }

package/dist/interfaces/DatabaseFileAccess.d.ts

@@ -2,10 +2,18 @@ import type { FilePathWithPrefix, LoadedEntry, MetaEntry, UXFileInfo, UXFileInfo
 export interface DatabaseFileAccess {
     delete: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string) => Promise<boolean>;
     store: (file: UXFileInfo, force?: boolean, skipCheck?: boolean) => Promise<boolean>;
+    /** Store a file as a child of an exact revision and return the created revision. */
+    storeWithBaseRevision: (file: UXFileInfo, baseRevision: string | undefined, skipCheck?: boolean) => Promise<string | false>;
     storeAsConflictedRevision: (file: UXFileInfo, currentRev: string, skipCheck?: boolean) => Promise<boolean>;
+    /** Preserve unknown storage content as a conflict and return its exact revision. */
+    storeAsConflictedRevisionWithResult: (file: UXFileInfo, currentRev: string, skipCheck?: boolean) => Promise<string | false>;
+    /** Store a user deletion as a visible logical-deletion child of an exact revision. */
+    storeDeletionWithBaseRevision: (file: UXFileInfoStub | FilePathWithPrefix, baseRevision: string) => Promise<string | false>;
     storeContent(path: FilePathWithPrefix, content: string): Promise<boolean>;
     createChunks: (file: UXFileInfo, force?: boolean, skipCheck?: boolean) => Promise<boolean>;
     hasContentInRevisionHistory: (file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string) => Promise<boolean>;
+    /** Return every available revision whose content exactly matches the supplied bytes. */
+    findContentRevisions: (file: UXFileInfoStub | FilePathWithPrefix, content: string | string[] | Blob | ArrayBuffer, currentRev?: string) => Promise<string[]>;
     fetch: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string, waitForReady?: boolean, skipCheck?: boolean) => Promise<UXFileInfo | false>;
     fetchEntryFromMeta: (meta: MetaEntry, waitForReady?: boolean, skipCheck?: boolean) => Promise<LoadedEntry | false>;
     fetchEntryMeta: (file: UXFileInfoStub | FilePathWithPrefix, rev?: string, skipCheck?: boolean) => Promise<MetaEntry | false>;

package/dist/interfaces/DatabaseRebuilder.d.ts

@@ -4,8 +4,18 @@ export interface Rebuilder {
     $rebuildEverything(): Promise<void>;
     $fetchLocal(makeLocalChunkBeforeSync?: boolean, preventMakeLocalFilesBeforeSync?: boolean): Promise<void>;
     $fetchLocalDBFast(autoResume: boolean): Promise<void>;
-    scheduleRebuild(): Promise<void>;
-    scheduleFetch(): Promise<void>;
+    /**
+     * Writes the Rebuild flag, suspends the current runtime, optionally prepares
+     * persisted state, and requests a restart, in that order.
+     *
+     * The preparation callback runs only after the flag exists. If it fails,
+     * the flag is removed, the current runtime is resumed, and the error is
+     * rethrown. A false result means that the flag could not be written and no
+     * restart was requested.
+     */
+    scheduleRebuild(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
+    /** See {@link scheduleRebuild}; this variant writes the Fetch flag. */
+    scheduleFetch(prepareBeforeRestart?: () => Promise<void>): Promise<boolean>;
     /**
      * Declares the finish of the rebuild process and unlock remote, resume reflecting the changes.
      */

package/dist/interfaces/FileReflectionProvenance.d.ts

@@ -0,0 +1,32 @@
+import type { FilePathWithPrefix } from "../common/types.js";
+import type { SimpleStore } from "../common/utils.js";
+export type FileReflectionProvenanceRecord = {
+    /** Exact database revision which most recently produced the storage state. */
+    revision: string;
+    /** Raw modification time observed from this device's storage after reflection. */
+    observedStorageMtime?: number;
+};
+export interface FileReflectionProvenance {
+    get(path: FilePathWithPrefix): Promise<FileReflectionProvenanceRecord | undefined>;
+    set(path: FilePathWithPrefix, record: FileReflectionProvenanceRecord): Promise<void>;
+    delete(path: FilePathWithPrefix): Promise<void>;
+    move(from: FilePathWithPrefix, to: FilePathWithPrefix): Promise<void>;
+}
+/**
+ * Device-local provenance backed by an existing host-owned key-value store.
+ *
+ * The revision is authoritative. The raw storage mtime is diagnostic and may
+ * be used as a fast change hint, but it never proves content or branch identity.
+ * The host may construct this object before opening its store, but it must not
+ * invoke provenance operations until its normal storage lifecycle is ready.
+ * Store failures are reported to the caller rather than hidden by readiness
+ * waits, so lifecycle violations and reset races cannot hang file processing.
+ */
+export declare class StoredFileReflectionProvenance implements FileReflectionProvenance {
+    private readonly store;
+    constructor(store: SimpleStore<FileReflectionProvenanceRecord>);
+    get(path: FilePathWithPrefix): Promise<FileReflectionProvenanceRecord | undefined>;
+    set(path: FilePathWithPrefix, record: FileReflectionProvenanceRecord): Promise<void>;
+    delete(path: FilePathWithPrefix): Promise<void>;
+    move(from: FilePathWithPrefix, to: FilePathWithPrefix): Promise<void>;
+}

package/dist/interfaces/FileReflectionProvenance.js

@@ -0,0 +1,25 @@
+class StoredFileReflectionProvenance {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async get(path) {
+    return await this.store.get(path) ?? void 0;
+  }
+  async set(path, record) {
+    await this.store.set(path, record);
+  }
+  async delete(path) {
+    await this.store.delete(path);
+  }
+  async move(from, to) {
+    const record = await this.get(from);
+    if (record) {
+      await this.set(to, record);
+    }
+    await this.delete(from);
+  }
+}
+export {
+  StoredFileReflectionProvenance
+};

package/dist/managers/ConflictManager.js

@@ -15,6 +15,21 @@ import {
   isObjectMargeApplicable
 } from "../common/utils.js";
 import { isErrorOfMissingDoc } from "../pouchdb/utils_couchdb.js";
+function revisionGeneration(revision) {
+  const generation = Number(revision.split("-", 1)[0]);
+  return Number.isFinite(generation) ? generation : Number.MAX_SAFE_INTEGER;
+}
+function compareConflictCandidates(left, right) {
+  const generationDifference = revisionGeneration(left.revision) - revisionGeneration(right.revision);
+  if (generationDifference !== 0) return generationDifference;
+  const leftMtime = left.leaf === false || !Number.isFinite(left.leaf.mtime) ? Number.NEGATIVE_INFINITY : left.leaf.mtime;
+  const rightMtime = right.leaf === false || !Number.isFinite(right.leaf.mtime) ? Number.NEGATIVE_INFINITY : right.leaf.mtime;
+  const mtimeDifference = leftMtime - rightMtime;
+  if (mtimeDifference !== 0) return mtimeDifference;
+  if (left.revision < right.revision) return -1;
+  if (left.revision > right.revision) return 1;
+  return 0;
+}
 class ConflictManager {
   options;
   constructor(options) {
@@ -258,13 +273,22 @@ class ConflictManager {
   }
   async tryAutoMergeSensibly(path, test, conflicts) {
     const conflictedRev = conflicts[0];
-    const conflictedRevNo = Number(conflictedRev.split("-")[0]);
-    const revFrom = await this.database.get(await this.options.pathService.path2id(path), {
-      revs_info: true
-    });
-    const commonBase = (revFrom._revs_info || []).filter(
-      (e) => e.status == "available" && Number(e.rev.split("-")[0]) < conflictedRevNo
-    )?.[0]?.rev ?? "";
+    let commonBase = "";
+    try {
+      const documentId = await this.options.pathService.path2id(path);
+      const [currentBranch, conflictedBranch] = await Promise.all([
+        this.database.get(documentId, { rev: test._rev, revs_info: true }),
+        this.database.get(documentId, { rev: conflictedRev, revs_info: true })
+      ]);
+      const currentAvailable = new Set(
+        (currentBranch._revs_info || []).filter((revision) => revision.status === "available").map((revision) => revision.rev)
+      );
+      commonBase = (conflictedBranch._revs_info || []).filter((revision) => revision.status === "available" && currentAvailable.has(revision.rev)).sort((left, right) => Number(right.rev.split("-")[0]) - Number(left.rev.split("-")[0]))[0]?.rev ?? "";
+    } catch (ex) {
+      Logger(`Could not determine the common revision for ${path}`, LOG_LEVEL_VERBOSE);
+      Logger(ex, LOG_LEVEL_VERBOSE);
+      return false;
+    }
     let p = void 0;
     if (commonBase) {
       if (isSensibleMargeApplicable(path)) {
@@ -302,9 +326,18 @@ class ConflictManager {
     if (test == null) return { ok: MISSING_OR_ERROR };
     if (!test._conflicts) return { ok: NOT_CONFLICTED };
     if (test._conflicts.length == 0) return { ok: NOT_CONFLICTED };
-    const conflicts = test._conflicts.sort((a, b) => Number(a.split("-")[0]) - Number(b.split("-")[0]));
+    const conflictCandidates = await Promise.all(
+      test._conflicts.map(
+        async (revision) => ({
+          revision,
+          leaf: await this.getConflictedDoc(path, revision)
+        })
+      )
+    );
+    conflictCandidates.sort(compareConflictCandidates);
+    const conflicts = conflictCandidates.map(({ revision }) => revision);
     const leftLeaf = await this.getConflictedDoc(path, test._rev);
-    const rightLeaf = await this.getConflictedDoc(path, conflicts[0]);
+    const rightLeaf = conflictCandidates[0].leaf;
     if (leftLeaf !== false && rightLeaf !== false && leftLeaf.data == rightLeaf.data && leftLeaf.deleted == rightLeaf.deleted) {
       return { leftRev: test._rev, rightRev: conflicts[0], leftLeaf, rightLeaf };
     }

package/dist/managers/EntryManager/EntryManager.d.ts

@@ -33,5 +33,6 @@ export declare class EntryManager {
     getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | LoadedEntry>;
     getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | LoadedEntry>;
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
+    storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
 }

package/dist/managers/EntryManager/EntryManager.js

@@ -8,7 +8,8 @@ import {
   getDBEntryMetaByPath,
   isTargetFile,
   prepareChunk,
-  putDBEntry
+  putDBEntry,
+  storeDeletionByPathAtRevision
 } from "./EntryManagerImpls.js";
 class EntryManager {
   options;
@@ -64,6 +65,9 @@ class EntryManager {
   async deleteDBEntry(path, opt) {
     return await deleteDBEntryByPath(this.serviceHost, this, path, opt);
   }
+  async storeDeletionAtRevision(path, baseRevision) {
+    return await storeDeletionByPathAtRevision(this.serviceHost, this, path, baseRevision);
+  }
   async putDBEntry(note, onlyChunks, conflictBaseRev) {
     return await putDBEntry(this.serviceHost, this, note, onlyChunks, conflictBaseRev);
   }

package/dist/managers/EntryManager/EntryManagerImpls.d.ts

@@ -71,4 +71,5 @@ export declare function getDBEntryByPath(host: NecessaryServicesInterfaces<"path
     datatype: import("../../common/types.js").EntryTypeNotes;
 } & PouchDB.Core.IdMeta)>;
 export declare function deleteDBEntryByPath(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase }: NecessaryManagers<"localDatabase">, path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
+export declare function storeDeletionByPathAtRevision(host: NecessaryServicesInterfaces<"path" | "setting", never>, { localDatabase }: NecessaryManagers<"localDatabase">, path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<PouchDB.Core.Response | false>;
 export {};

package/dist/managers/EntryManager/EntryManagerImpls.js

@@ -484,6 +484,33 @@ async function deleteDBEntryByPath(host, { localDatabase }, path, opt) {
     throw ex;
   }
 }
+async function storeDeletionByPathAtRevision(host, { localDatabase }, path, baseRevision) {
+  if (!isTargetFile(host, path)) {
+    return false;
+  }
+  const id = await host.services.path.path2id(path);
+  try {
+    return await serialized("file:" + path, async () => {
+      const obj = await localDatabase.get(id, {
+        rev: baseRevision
+      });
+      if (obj.type === "leaf") {
+        return false;
+      }
+      delete obj._deleted;
+      obj.deleted = true;
+      obj.mtime = Date.now();
+      const result = await localDatabase.put(obj, { force: true });
+      Logger(`Entry soft-deleted from revision: ${path} (${obj._id.substring(0, 8)}-${result.rev})`);
+      return result;
+    }) ?? false;
+  } catch (ex) {
+    if (isErrorOfMissingDoc(ex)) {
+      return false;
+    }
+    throw ex;
+  }
+}
 export {
   canUseOnDemandChunking,
   computeChunkRetrievalMethod,
@@ -495,5 +522,6 @@ export {
   isLegacyNote,
   isTargetFile,
   prepareChunk,
-  putDBEntry
+  putDBEntry,
+  storeDeletionByPathAtRevision
 };

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

@@ -2,7 +2,12 @@ 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. */
+    /**
+     * Host-selected root directory. Adapter paths are resolved relative to this root.
+     *
+     * The host owns this trust boundary. The adapter is not a filesystem sandbox against
+     * an untrusted local process which can replace path components concurrently.
+     */
     rootPath: string;
 }
 /** Rooted storage adapter backed by Node's file-system APIs. */
@@ -10,6 +15,7 @@ export declare class NodeStorageAdapter implements IStorageAdapter<NodeStorageSt
     private readonly rootPath;
     constructor(rootPath: string);
     private resolvePath;
+    private assertNoSymbolicLinks;
     exists(path: string): Promise<boolean>;
     trystat(path: string): Promise<NodeStorageStat | null>;
     stat(path: string): Promise<NodeStorageStat | null>;
@@ -20,10 +26,13 @@ export declare class NodeStorageAdapter implements IStorageAdapter<NodeStorageSt
     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>;
+    /** Atomically rename or move an entry without leaving the injected root. */
+    rename(sourcePath: string, targetPath: string): Promise<void>;
     list(basePath: string): Promise<{
         files: string[];
         folders: string[];
     }>;
+    private writeFile;
     private applyTimes;
 }
 /** Bind a Node storage adapter to an explicitly selected root directory. */

package/dist/platform/node/storage.js

@@ -1,16 +1,40 @@
+import { constants as nodeFsConstants } from "node:fs";
 import * as nodeFsPromises from "node:fs/promises";
 import * as nodePath from "node:path";
 import { validateStoragePath } from "../storagePath.js";
+const NO_FOLLOW = nodeFsConstants.O_NOFOLLOW ?? 0;
+class SymbolicLinkStoragePathError extends Error {
+  constructor(path) {
+    super(`Storage paths must not contain symbolic links: ${path}`);
+    this.name = "SymbolicLinkStoragePathError";
+  }
+}
 class NodeStorageAdapter {
+  rootPath;
   constructor(rootPath) {
-    this.rootPath = rootPath;
+    this.rootPath = nodePath.resolve(rootPath);
   }
-  rootPath;
-  resolvePath(path, allowRoot = true) {
-    return nodePath.join(this.rootPath, validateStoragePath(path, allowRoot));
+  async resolvePath(path, allowRoot = true) {
+    const fullPath = nodePath.join(this.rootPath, validateStoragePath(path, allowRoot));
+    await this.assertNoSymbolicLinks(fullPath);
+    return fullPath;
+  }
+  async assertNoSymbolicLinks(fullPath) {
+    const relativePath = nodePath.relative(this.rootPath, fullPath);
+    let currentPath = this.rootPath;
+    for (const segment of relativePath.split(nodePath.sep).filter(Boolean)) {
+      currentPath = nodePath.join(currentPath, segment);
+      try {
+        const stat = await nodeFsPromises.lstat(currentPath);
+        if (stat.isSymbolicLink()) throw new SymbolicLinkStoragePathError(currentPath);
+      } catch (error) {
+        if (error.code === "ENOENT") return;
+        throw error;
+      }
+    }
   }
   async exists(path) {
-    const fullPath = this.resolvePath(path);
+    const fullPath = await this.resolvePath(path);
     try {
       await nodeFsPromises.access(fullPath);
       return true;
@@ -20,14 +44,15 @@ class NodeStorageAdapter {
   }
   async trystat(path) {
     try {
-      const stat = await nodeFsPromises.stat(this.resolvePath(path));
+      const stat = await nodeFsPromises.stat(await this.resolvePath(path));
       return {
         size: stat.size,
         mtime: Math.floor(stat.mtimeMs),
         ctime: Math.floor(stat.ctimeMs),
         type: stat.isDirectory() ? "folder" : "file"
       };
-    } catch {
+    } catch (error) {
+      if (error instanceof SymbolicLinkStoragePathError) throw error;
       return null;
     }
   }
@@ -35,10 +60,12 @@ class NodeStorageAdapter {
     return await this.trystat(path);
   }
   async mkdir(path) {
-    await nodeFsPromises.mkdir(this.resolvePath(path), { recursive: true });
+    const fullPath = await this.resolvePath(path);
+    await nodeFsPromises.mkdir(fullPath, { recursive: true });
+    await this.assertNoSymbolicLinks(fullPath);
   }
   async remove(path) {
-    const fullPath = this.resolvePath(path, false);
+    const fullPath = await this.resolvePath(path, false);
     const stat = await nodeFsPromises.stat(fullPath);
     if (stat.isDirectory()) {
       await nodeFsPromises.rm(fullPath, { recursive: true, force: true });
@@ -47,33 +74,55 @@ class NodeStorageAdapter {
     }
   }
   async read(path) {
-    return await nodeFsPromises.readFile(this.resolvePath(path, false), "utf-8");
+    const handle = await nodeFsPromises.open(
+      await this.resolvePath(path, false),
+      nodeFsConstants.O_RDONLY | NO_FOLLOW
+    );
+    try {
+      return await handle.readFile("utf-8");
+    } finally {
+      await handle.close();
+    }
   }
   async readBinary(path) {
-    const buffer = await nodeFsPromises.readFile(this.resolvePath(path, false));
-    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    const handle = await nodeFsPromises.open(
+      await this.resolvePath(path, false),
+      nodeFsConstants.O_RDONLY | NO_FOLLOW
+    );
+    try {
+      const buffer = await handle.readFile();
+      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    } finally {
+      await handle.close();
+    }
   }
   async write(path, data, options) {
-    const fullPath = this.resolvePath(path, false);
+    const fullPath = await this.resolvePath(path, false);
     await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
-    await nodeFsPromises.writeFile(fullPath, data, "utf-8");
-    await this.applyTimes(fullPath, options);
+    await this.writeFile(fullPath, data, options, false);
   }
   async writeBinary(path, data, options) {
-    const fullPath = this.resolvePath(path, false);
+    const fullPath = await this.resolvePath(path, false);
     await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
-    await nodeFsPromises.writeFile(fullPath, new Uint8Array(data));
-    await this.applyTimes(fullPath, options);
+    await this.writeFile(fullPath, new Uint8Array(data), options, false);
   }
   async append(path, data, options) {
-    const fullPath = this.resolvePath(path, false);
+    const fullPath = await this.resolvePath(path, false);
     await nodeFsPromises.mkdir(nodePath.dirname(fullPath), { recursive: true });
-    await nodeFsPromises.appendFile(fullPath, data, "utf-8");
-    await this.applyTimes(fullPath, options);
+    await this.writeFile(fullPath, data, options, true);
+  }
+  /** Atomically rename or move an entry without leaving the injected root. */
+  async rename(sourcePath, targetPath) {
+    const fullSourcePath = await this.resolvePath(sourcePath, false);
+    const fullTargetPath = await this.resolvePath(targetPath, false);
+    await nodeFsPromises.mkdir(nodePath.dirname(fullTargetPath), { recursive: true });
+    await this.assertNoSymbolicLinks(fullSourcePath);
+    await this.assertNoSymbolicLinks(fullTargetPath);
+    await nodeFsPromises.rename(fullSourcePath, fullTargetPath);
   }
   async list(basePath) {
     try {
-      const entries = await nodeFsPromises.readdir(this.resolvePath(basePath), { withFileTypes: true });
+      const entries = await nodeFsPromises.readdir(await this.resolvePath(basePath), { withFileTypes: true });
       const files = [];
       const folders = [];
       for (const entry of entries) {
@@ -82,15 +131,27 @@ class NodeStorageAdapter {
         else if (entry.isFile()) files.push(entryPath);
       }
       return { files, folders };
-    } catch {
+    } catch (error) {
+      if (error instanceof SymbolicLinkStoragePathError) throw error;
       return { files: [], folders: [] };
     }
   }
-  async applyTimes(fullPath, options) {
+  async writeFile(fullPath, data, options, append) {
+    await this.assertNoSymbolicLinks(fullPath);
+    const flags = nodeFsConstants.O_WRONLY | nodeFsConstants.O_CREAT | NO_FOLLOW | (append ? nodeFsConstants.O_APPEND : nodeFsConstants.O_TRUNC);
+    const handle = await nodeFsPromises.open(fullPath, flags, 438);
+    try {
+      await handle.writeFile(data, typeof data === "string" ? "utf-8" : void 0);
+      await this.applyTimes(handle, options);
+    } finally {
+      await handle.close();
+    }
+  }
+  async applyTimes(handle, 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);
+    await handle.utimes(accessTime, modificationTime);
   }
 }
 function createNodeStorage({ rootPath }) {

package/dist/pouchdb/LiveSyncLocalDB.d.ts

@@ -190,6 +190,7 @@ export declare class LiveSyncLocalDB {
     getDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions, dump?: boolean, waitForReady?: boolean, includeDeleted?: boolean): Promise<false | LoadedEntry>;
     getDBEntryFromMeta(meta: LoadedEntry | MetaEntry, dump?: boolean, waitForReady?: boolean): Promise<false | LoadedEntry>;
     deleteDBEntry(path: FilePathWithPrefix | FilePath, opt?: PouchDB.Core.GetOptions): Promise<boolean>;
+    storeDeletionAtRevision(path: FilePathWithPrefix | FilePath, baseRevision: string): Promise<false | PouchDB.Core.Response>;
     putDBEntry(note: SavingEntry, onlyChunks?: boolean, conflictBaseRev?: string): Promise<false | PouchDB.Core.Response>;
     getConflictedDoc(path: FilePathWithPrefix, rev: string): Promise<false | diff_result_leaf>;
     tryAutoMerge(path: FilePathWithPrefix, enableMarkdownAutoMerge: boolean): AutoMergeResult;

package/dist/pouchdb/LiveSyncLocalDB.js

@@ -364,6 +364,9 @@ class LiveSyncLocalDB {
   async deleteDBEntry(path, opt) {
     return await this.managers.entryManager.deleteDBEntry(path, opt);
   }
+  async storeDeletionAtRevision(path, baseRevision) {
+    return await this.managers.entryManager.storeDeletionAtRevision(path, baseRevision);
+  }
   async putDBEntry(note, onlyChunks, conflictBaseRev) {
     return await this.managers.entryManager.putDBEntry(note, onlyChunks, conflictBaseRev);
   }

package/dist/remoteConfigurations.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Focused public primitives for storing and selecting multiple remote connection profiles.
+ *
+ * The compatibility fields remain available to existing hosts, but new profile-management code
+ * should use this entry point instead of importing the wider service feature module.
+ */
+export { activateP2PRemoteConfiguration, activateRemoteConfiguration, createRemoteConfigurationId, suggestRemoteConfigurationName, upsertRemoteConfigurationInPlace, } from "./serviceFeatures/remoteConfig.js";
+export type { SerializableRemoteConfigurationType, UpsertRemoteConfigurationOptions, } from "./serviceFeatures/remoteConfig.js";
+export type { RemoteConfiguration } from "./common/models/setting.type.js";