@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/trystero/LiveSyncTrysteroReplicator.d.ts

@@ -0,0 +1,90 @@
+import { type RemoteDBSettings, type EntryLeaf, type TweakValues, type LOG_LEVEL, type NodeData } from "../../common/types.js";
+import { LiveSyncAbstractReplicator, type LiveSyncReplicatorEnv, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
+import { TrysteroReplicator } from "./TrysteroReplicator.js";
+import { P2PHost, type AcceptanceDecision, type RevokeAcceptanceDecision } from "./TrysteroReplicatorP2PServer.js";
+import type { Advertisement } from "./types.js";
+export interface LiveSyncTrysteroReplicatorEnv extends LiveSyncReplicatorEnv {
+    /**
+     * Injected by the host platform (e.g. Obsidian) to show a UI for peer selection.
+     * When not set, openReplication falls back to replicateFromCommand (CLI-safe).
+     */
+    openReplicationUI?: (showResult: boolean) => Promise<boolean | void>;
+    /**
+     * Injected by the host platform to show a UI for selecting a peer to rebuild from.
+     * When not set, replicateAllFromServer falls back to the headless selectPeer dialog.
+     */
+    openRebuildUI?: (showResult: boolean) => Promise<boolean | void>;
+}
+export declare class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
+    private _p2pHost?;
+    private _replicator?;
+    get openReplicationUI(): (showResult: boolean) => Promise<boolean | void>;
+    get rawReplicator(): TrysteroReplicator;
+    get rawHost(): P2PHost;
+    get isChunkSendingSupported(): boolean;
+    getReplicationPBKDF2Salt(_setting: RemoteDBSettings, _refresh?: boolean): Promise<Uint8Array<ArrayBuffer>>;
+    terminateSync(): void;
+    private _buildEnv;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    closeReplication(): void;
+    get server(): P2PHost;
+    get knownAdvertisements(): Advertisement[];
+    enableBroadcastChanges(): void;
+    disableBroadcastChanges(): void;
+    requestStatus(): void;
+    onNewPeer(peer: Advertisement): Promise<void>;
+    onPeerLeaved(peerId: string): void;
+    replicateFromCommand(showResult?: boolean): Promise<void>;
+    replicateFrom(peerId: string, showNotice?: boolean): Promise<{
+        error: any;
+        ok?: undefined;
+    } | {
+        ok: boolean;
+        error?: undefined;
+    }>;
+    requestSynchroniseToPeer(peerId: string): Promise<{
+        error: any;
+        ok?: undefined;
+    } | {
+        ok: boolean;
+        error?: undefined;
+    }>;
+    getRemoteConfig(peerId: string): Promise<false | import("../../common/types.js").ObsidianLiveSyncSettings>;
+    watchPeer(peerId: string): void;
+    unwatchPeer(peerId: string): void;
+    sync(peerId: string, showNotice?: boolean): Promise<{
+        error: any;
+        ok?: undefined;
+    } | {
+        ok: boolean;
+        error?: undefined;
+    }>;
+    setOnSetup(): void;
+    clearOnSetup(): void;
+    makeDecision(decision: AcceptanceDecision): Promise<void>;
+    revokeDecision(decision: RevokeAcceptanceDecision): Promise<void>;
+    makeSureOpened(): Promise<void>;
+    openReplication(_setting: RemoteDBSettings, _keepAlive: boolean, showResult: boolean, _ignoreCleanLock: boolean): Promise<void | boolean>;
+    tryConnectRemote(_setting: RemoteDBSettings, _showResult?: boolean): Promise<boolean>;
+    replicateAllToServer(_setting: RemoteDBSettings, _showingNotice?: boolean, _sendChunksInBulkDisabled?: boolean): Promise<boolean>;
+    selectPeer(settingPeerName: string, r: TrysteroReplicator, logLevel: LOG_LEVEL): Promise<string | false>;
+    tryUntilSuccess<T>(func: () => Promise<T | false>, repeat: number, logLevel: LOG_LEVEL): Promise<T | false>;
+    replicateAllFromServer(setting: RemoteDBSettings, showingNotice?: boolean): Promise<boolean>;
+    tryResetRemoteDatabase(_setting: RemoteDBSettings): Promise<void>;
+    tryCreateRemoteDatabase(_setting: RemoteDBSettings): Promise<void>;
+    markRemoteLocked(_setting: RemoteDBSettings, _locked: boolean, _lockByClean: boolean): Promise<void>;
+    markRemoteResolved(_setting: RemoteDBSettings): Promise<void>;
+    resetRemoteTweakSettings(_setting: RemoteDBSettings): Promise<void>;
+    setPreferredRemoteTweakSettings(_setting: RemoteDBSettings): Promise<void>;
+    fetchRemoteChunks(_missingChunks: string[], _showResult: boolean): Promise<false | EntryLeaf[]>;
+    getRemoteStatus(_setting: RemoteDBSettings): Promise<false | RemoteDBStatus>;
+    getRemotePreferredTweakValues(_setting: RemoteDBSettings): Promise<false | TweakValues>;
+    countCompromisedChunks(): Promise<number>;
+    getConnectedDeviceList(_setting?: RemoteDBSettings): Promise<false | {
+        node_info: Record<string, NodeData>;
+        accepted_nodes: string[];
+    }>;
+    env: LiveSyncTrysteroReplicatorEnv;
+    constructor(env: LiveSyncTrysteroReplicatorEnv);
+}

package/dist/replication/trystero/LiveSyncTrysteroReplicator.js

@@ -0,0 +1,380 @@
+import { Logger } from "../../common/logger.js";
+import {
+  LOG_LEVEL_NOTICE,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_VERBOSE,
+  SETTING_KEY_P2P_DEVICE_NAME
+} from "../../common/types.js";
+import {
+  LiveSyncAbstractReplicator
+} from "../LiveSyncAbstractReplicator.js";
+import { TrysteroReplicator } from "./TrysteroReplicator.js";
+import {
+  EVENT_ADVERTISEMENT_RECEIVED,
+  EVENT_P2P_CONNECTED,
+  P2PHost
+} from "./TrysteroReplicatorP2PServer.js";
+import { delay } from "octagonal-wheels/promises";
+class LiveSyncTrysteroReplicator extends LiveSyncAbstractReplicator {
+  _p2pHost;
+  _replicator;
+  get openReplicationUI() {
+    return this.env.openReplicationUI;
+  }
+  get rawReplicator() {
+    return this._replicator;
+  }
+  get rawHost() {
+    return this._p2pHost;
+  }
+  get isChunkSendingSupported() {
+    return false;
+  }
+  getReplicationPBKDF2Salt(_setting, _refresh) {
+    return Promise.resolve(new Uint8Array(32));
+  }
+  terminateSync() {
+  }
+  _buildEnv() {
+    const services = this.env.services;
+    return {
+      events: services.context.events,
+      translate: services.context.translate,
+      get settings() {
+        return services.setting.currentSettings();
+      },
+      get db() {
+        return services.database.localDatabase.localDatabase;
+      },
+      get simpleStore() {
+        return services.keyValueDB.openSimpleStore("p2p-sync");
+      },
+      get deviceName() {
+        return services.config.getSmallConfig(SETTING_KEY_P2P_DEVICE_NAME) || services.vault.getVaultName();
+      },
+      get platform() {
+        return services.API.getPlatform();
+      },
+      get confirm() {
+        return services.API.confirm;
+      },
+      runFiniteReplicationActivity: (task, options) => services.replicator.runFiniteReplicationActivity(task, options),
+      processReplicatedDocs: async (docs) => {
+        const settings = services.setting.currentSettings();
+        if (settings.suspendParseReplicationResult) {
+          const docLength = docs.length;
+          if (docLength > 0) {
+            Logger(
+              `P2P sync, but parseReplicationResult is suspended. Ignoring ${docLength} documents.`,
+              LOG_LEVEL_VERBOSE
+            );
+          }
+          return;
+        }
+        await services.replication.parseSynchroniseResult(docs);
+      }
+    };
+  }
+  async open() {
+    if (!this.env.services.setting.currentSettings().P2P_Enabled) {
+      Logger(this.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
+      return;
+    }
+    if (this._replicator && this._p2pHost?.isServing) {
+      Logger("P2P replicator is already open.");
+      return;
+    }
+    try {
+      const env = this._buildEnv();
+      const host = new P2PHost(env);
+      const replicator = new TrysteroReplicator(env, host);
+      this._p2pHost = host;
+      this._replicator = replicator;
+      await replicator.open();
+    } catch (e) {
+      Logger(e instanceof Error ? e.message : "Error while opening P2P connection", LOG_LEVEL_NOTICE);
+      Logger(e, LOG_LEVEL_VERBOSE);
+      this._p2pHost = void 0;
+      this._replicator = void 0;
+    }
+  }
+  async close() {
+    if (this._replicator) {
+      this._replicator.disableBroadcastChanges();
+      await this._replicator.close();
+      this._replicator = void 0;
+    }
+    this._p2pHost = void 0;
+  }
+  closeReplication() {
+    this._replicator?.disconnectFromServer();
+  }
+  get server() {
+    return this._replicator?.server;
+  }
+  get knownAdvertisements() {
+    return this._replicator?.knownAdvertisements ?? [];
+  }
+  enableBroadcastChanges() {
+    this._replicator?.enableBroadcastChanges();
+  }
+  disableBroadcastChanges() {
+    this._replicator?.disableBroadcastChanges();
+  }
+  requestStatus() {
+    this._replicator?.requestStatus();
+  }
+  onNewPeer(peer) {
+    return this._replicator?.onNewPeer(peer);
+  }
+  onPeerLeaved(peerId) {
+    this._replicator?.onPeerLeaved(peerId);
+  }
+  async replicateFromCommand(showResult = false) {
+    const replicator = this._replicator;
+    if (!replicator) return;
+    await this.env.services.replicator.runFiniteReplicationActivity(
+      () => replicator.replicateFromCommand(showResult),
+      { label: "replication" }
+    );
+  }
+  async replicateFrom(peerId, showNotice = false) {
+    const replicator = this._replicator;
+    if (!replicator) throw new Error("P2P replicator is not open");
+    return await this.env.services.replicator.runFiniteReplicationActivity(
+      () => replicator.replicateFrom(peerId, showNotice),
+      { label: "replication" }
+    );
+  }
+  async requestSynchroniseToPeer(peerId) {
+    const replicator = this._replicator;
+    if (!replicator) throw new Error("P2P replicator is not open");
+    return await this.env.services.replicator.runBoundedRemoteActivity(
+      () => replicator.requestSynchroniseToPeer(peerId),
+      { label: "replication" }
+    );
+  }
+  async getRemoteConfig(peerId) {
+    if (!this._replicator) throw new Error("P2P replicator is not open");
+    return await this._replicator.getRemoteConfig(peerId);
+  }
+  watchPeer(peerId) {
+    this._replicator?.watchPeer(peerId);
+  }
+  unwatchPeer(peerId) {
+    this._replicator?.unwatchPeer(peerId);
+  }
+  async sync(peerId, showNotice = false) {
+    if (!this._replicator) throw new Error("P2P replicator is not open");
+    return await this._replicator.sync(peerId, showNotice);
+  }
+  setOnSetup() {
+    this._replicator?.setOnSetup();
+  }
+  clearOnSetup() {
+    this._replicator?.clearOnSetup();
+  }
+  async makeDecision(decision) {
+    await this._replicator?.server?.makeDecision(decision);
+  }
+  async revokeDecision(decision) {
+    await this._replicator?.server?.revokeDecision(decision);
+  }
+  async makeSureOpened() {
+    if (!this._replicator || !this._p2pHost?.isServing) {
+      await this.open();
+    }
+  }
+  async openReplication(_setting, _keepAlive, showResult, _ignoreCleanLock) {
+    if (this.openReplicationUI) {
+      return this.openReplicationUI(showResult);
+    }
+    const logLevel = showResult ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    await this.makeSureOpened();
+    if (!this._replicator) {
+      Logger(this.translate("P2P.ReplicatorInstanceMissing"), logLevel);
+      return false;
+    }
+    await this._replicator.replicateFromCommand(showResult);
+  }
+  tryConnectRemote(_setting, _showResult) {
+    return Promise.resolve(false);
+  }
+  replicateAllToServer(_setting, _showingNotice, _sendChunksInBulkDisabled) {
+    return Promise.resolve(false);
+  }
+  async selectPeer(settingPeerName, r, logLevel) {
+    const knownPeersOrg = r.server?.knownAdvertisements ?? [];
+    let knownPeers;
+    if (knownPeersOrg.length != 0) {
+      knownPeers = knownPeersOrg;
+    } else {
+      Logger(this.translate("P2P.NoKnownPeers"), logLevel);
+      await Promise.race([delay(5e3), this.env.services.context.events.waitFor(EVENT_ADVERTISEMENT_RECEIVED)]);
+      knownPeers = r.server?.knownAdvertisements ?? [];
+    }
+    const message = "Rebuild from which peer?" + (settingPeerName ? "\n [*] indicates the peer you have selected before." : "");
+    const confirm = this.env.services.UI.confirm;
+    const markedPeerNames = knownPeers.map(
+      (e) => e.name + "\u2001" + (e.name == settingPeerName ? "[*]" : "") + " (" + e.peerId + ")"
+    );
+    const options = [...markedPeerNames, "Refresh List", "Cancel"];
+    const selected = await confirm.askSelectStringDialogue(message, options, {
+      title: "Select a peer to fetch from",
+      defaultAction: "Refresh List"
+    });
+    if (!selected || selected == "Cancel") {
+      return false;
+    }
+    if (selected == "Refresh List") {
+      await Promise.race([delay(1e3), this.env.services.context.events.waitFor(EVENT_ADVERTISEMENT_RECEIVED)]);
+      return this.selectPeer(settingPeerName, r, logLevel);
+    }
+    const selectedPeerName = selected.split("\u2001")[0];
+    const peerId = knownPeers.find((e) => e.name == selectedPeerName)?.peerId;
+    if (!peerId) {
+      Logger("Failed to find peerId for " + selectedPeerName, logLevel);
+      return false;
+    }
+    return peerId;
+  }
+  async tryUntilSuccess(func, repeat, logLevel) {
+    const confirm = this.env.services.UI.confirm;
+    if (!confirm) {
+      Logger("Cannot find confirm instance.", logLevel);
+      return Promise.reject(new Error("Cannot find confirm instance."));
+    }
+    let result;
+    while (!result) {
+      for (let i = 0; i < repeat; i++) {
+        try {
+          result = await func();
+          if (result) break;
+        } catch (e) {
+          Logger(`Error: ${e instanceof Error ? e.message : String(e)}`, logLevel);
+          result = false;
+        }
+        await delay(1e3);
+      }
+    }
+    return result;
+  }
+  async replicateAllFromServer(setting, showingNotice) {
+    const logLevel = showingNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    if (setting.P2P_Enabled == false) {
+      const confirm = this.env.services.UI.confirm;
+      if (await confirm.askYesNoDialog(this.translate("P2P.DisabledButNeed"), {}) != "yes") {
+        Logger(this.translate("P2P.NotEnabled"), logLevel);
+      }
+      setting.P2P_Enabled = true;
+      this.env.services.setting.currentSettings().P2P_Enabled = true;
+      await this.env.services.setting.saveSettingData();
+      await delay(100);
+      return this.replicateAllFromServer(setting, showingNotice);
+    }
+    await this.open();
+    if (!this._replicator) {
+      Logger("Failed to get replicator instance.", logLevel);
+      return false;
+    }
+    if (this.env.openRebuildUI) {
+      return await this.env.openRebuildUI(showingNotice ?? false) !== false;
+    }
+    await this.env.services.context.events.waitFor(EVENT_P2P_CONNECTED);
+    const peerFrom = setting.P2P_RebuildFrom;
+    this._replicator.setOnSetup();
+    try {
+      const r = await this.tryUntilSuccess(
+        async () => {
+          await this.makeSureOpened();
+          return this._replicator ?? false;
+        },
+        10,
+        logLevel
+      );
+      if (r === false) {
+        Logger("Failed to open P2P connection.", logLevel);
+        return false;
+      }
+      const peerId = await this.selectPeer(peerFrom, r, logLevel);
+      if (peerId === false) {
+        Logger("Failed to connect peer.", logLevel);
+        return false;
+      }
+      this.env.services.setting.currentSettings().P2P_RebuildFrom = "";
+      Logger("Fetching from peer " + peerId + ".", logLevel);
+      const rep = await r.replicateFrom(peerId, showingNotice);
+      if (rep.ok) {
+        Logger("P2P Fetching has been succeed from " + peerId + ".", logLevel);
+        return true;
+      } else {
+        Logger("Failed to fetch from peer " + peerId + ".", logLevel);
+        Logger(rep.error, LOG_LEVEL_VERBOSE);
+        return false;
+      }
+    } finally {
+      this._replicator?.clearOnSetup();
+    }
+  }
+  tryResetRemoteDatabase(_setting) {
+    throw new Error("P2P replication does not support database reset.");
+  }
+  tryCreateRemoteDatabase(_setting) {
+    throw new Error("P2P replication does not support database reset.");
+  }
+  markRemoteLocked(_setting, _locked, _lockByClean) {
+    throw new Error("P2P replication does not support database lock.");
+  }
+  markRemoteResolved(_setting) {
+    Logger(
+      "Trying resolving remote-database-lock but P2P replication does not support database lock. This operation has been ignored",
+      LOG_LEVEL_INFO
+    );
+    return Promise.resolve();
+  }
+  resetRemoteTweakSettings(_setting) {
+    throw new Error("P2P replication does not support resetting tweaks.");
+  }
+  setPreferredRemoteTweakSettings(_setting) {
+    Logger(
+      "Trying setting tweak values but P2P replication does not support to do this. This operation has been ignored",
+      LOG_LEVEL_INFO
+    );
+    return Promise.resolve();
+  }
+  fetchRemoteChunks(_missingChunks, _showResult) {
+    return Promise.resolve(false);
+  }
+  getRemoteStatus(_setting) {
+    Logger(
+      "Trying to get remote status but P2P replication does not support to do this. This operation has been ignored",
+      LOG_LEVEL_INFO
+    );
+    return Promise.resolve(false);
+  }
+  getRemotePreferredTweakValues(_setting) {
+    Logger(
+      "Trying to get tweak values but P2P replication does not support to do this. This operation has been ignored",
+      LOG_LEVEL_INFO
+    );
+    return Promise.resolve(false);
+  }
+  countCompromisedChunks() {
+    Logger("P2P Replicator cannot count compromised chunks", LOG_LEVEL_VERBOSE);
+    return Promise.resolve(0);
+  }
+  getConnectedDeviceList(_setting) {
+    Logger(
+      "Trying to get connected device list but P2P replication does not support to do this. This operation has been ignored",
+      LOG_LEVEL_INFO
+    );
+    return Promise.resolve(false);
+  }
+  constructor(env) {
+    super(env);
+    this.env = env;
+  }
+}
+export {
+  LiveSyncTrysteroReplicator
+};

package/dist/replication/trystero/P2PLogCollector.d.ts

@@ -0,0 +1,8 @@
+import type { LiveSyncEventHub } from "../../hub/hub.js";
+import type { P2PReplicationProgress } from "./TrysteroReplicator.js";
+export declare class P2PLogCollector {
+    constructor(events: LiveSyncEventHub);
+    p2pReplicationResult: Map<string, P2PReplicationProgress>;
+    updateP2PReplicationLine(): void;
+    p2pReplicationLine: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<string>;
+}

package/dist/replication/trystero/P2PLogCollector.js

@@ -0,0 +1,91 @@
+import { reactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
+import {
+  EVENT_ADVERTISEMENT_RECEIVED,
+  EVENT_P2P_CONNECTED,
+  EVENT_P2P_DISCONNECTED,
+  EVENT_DEVICE_LEAVED,
+  EVENT_P2P_REPLICATOR_PROGRESS
+} from "./TrysteroReplicatorP2PServer.js";
+class P2PLogCollector {
+  constructor(events) {
+    events.onEvent(EVENT_ADVERTISEMENT_RECEIVED, (data) => {
+      this.p2pReplicationResult.set(data.peerId, {
+        peerId: data.peerId,
+        peerName: data.name,
+        fetching: {
+          current: 0,
+          max: 0,
+          isActive: false
+        },
+        sending: {
+          current: 0,
+          max: 0,
+          isActive: false
+        }
+      });
+      this.updateP2PReplicationLine();
+    });
+    events.onEvent(EVENT_P2P_CONNECTED, () => {
+      this.p2pReplicationResult.clear();
+      this.updateP2PReplicationLine();
+    });
+    events.onEvent(EVENT_P2P_DISCONNECTED, () => {
+      this.p2pReplicationResult.clear();
+      this.updateP2PReplicationLine();
+    });
+    events.onEvent(EVENT_DEVICE_LEAVED, (peerId) => {
+      this.p2pReplicationResult.delete(peerId);
+      this.updateP2PReplicationLine();
+    });
+    events.onEvent(EVENT_P2P_REPLICATOR_PROGRESS, (data) => {
+      const prev = this.p2pReplicationResult.get(data.peerId) || {
+        peerId: data.peerId,
+        peerName: data.peerName,
+        fetching: {
+          current: 0,
+          max: 0,
+          isActive: false
+        },
+        sending: {
+          current: 0,
+          max: 0,
+          isActive: false
+        }
+      };
+      if ("fetching" in data) {
+        if (data.fetching.isActive) {
+          prev.fetching = data.fetching;
+        } else {
+          prev.fetching.isActive = false;
+        }
+      }
+      if ("sending" in data) {
+        if (data.sending.isActive) {
+          prev.sending = data.sending;
+        } else {
+          prev.sending.isActive = false;
+        }
+      }
+      this.p2pReplicationResult.set(data.peerId, prev);
+      this.updateP2PReplicationLine();
+    });
+  }
+  p2pReplicationResult = /* @__PURE__ */ new Map();
+  updateP2PReplicationLine() {
+    const p2pReplicationResultX = [...this.p2pReplicationResult.values()].sort(
+      (a, b) => a.peerId.localeCompare(b.peerId)
+    );
+    const renderProgress = (current, max) => {
+      if (current == max) return `${current}`;
+      return `${current} (${max})`;
+    };
+    const line = p2pReplicationResultX.map(
+      (e) => `${e.fetching.isActive || e.sending.isActive ? "\u26A1" : "\u{1F4A4}"} ${e.peerName} \u2191 ${renderProgress(e.sending.current, e.sending.max)} \u2193 ${renderProgress(e.fetching.current, e.fetching.max)} `
+    ).join("\n");
+    this.p2pReplicationLine.value = line;
+  }
+  p2pReplicationLine = reactiveSource("");
+}
+export {
+  P2PLogCollector
+};

package/dist/replication/trystero/P2PReplicatorBase.d.ts

@@ -0,0 +1,19 @@
+import type { LOG_LEVEL } from "octagonal-wheels/common/logger";
+import type { SimpleStore } from "octagonal-wheels/databases/SimpleStoreBase";
+import type { ReactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
+import type { P2PSyncSetting, EntryDoc } from "../../common/types.js";
+import type { Confirm } from "../../interfaces/Confirm.js";
+import type { InjectableServiceHub } from "../../services/InjectableServices.js";
+export interface P2PReplicatorBase {
+    storeP2PStatusLine: ReactiveSource<string>;
+    settings: P2PSyncSetting;
+    _log(msg: unknown, level?: LOG_LEVEL): void;
+    _notice(msg: unknown, key?: string): void;
+    getSettings(): P2PSyncSetting;
+    getDB: () => PouchDB.Database<EntryDoc>;
+    confirm: Confirm;
+    simpleStore(): SimpleStore<unknown>;
+    handleReplicatedDocuments(docs: EntryDoc[]): Promise<boolean>;
+    init(): Promise<this>;
+    services: InjectableServiceHub;
+}

package/dist/replication/trystero/P2PReplicatorCore.d.ts

@@ -0,0 +1,12 @@
+import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
+import type { P2PPaneParams } from "./UseP2PReplicatorResult.js";
+export type P2PViewFactory = (leaf: unknown) => unknown;
+/**
+ * ServiceFeature: P2P Replicator lifecycle management.
+ * Binds a LiveSyncTrysteroReplicator to the host's lifecycle events,
+ * following the same middleware style as useOfflineScanner.
+ *
+ * @param viewTypeAndFactory  Optional [viewType, factory] pair for registering the P2P pane view.
+ *                            When provided, also registers commands and ribbon icon via services.API.
+ */
+export declare function useP2PReplicator(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "database" | "databaseEvents" | "keyValueDB" | "replication" | "config" | "UI" | "replicator" | "remote", never>, viewTypeAndFactory?: [viewType: string, factory: P2PViewFactory]): P2PPaneParams;