@vrtmrz/livesync-commonlib 0.2.3 → 0.3.0

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -12,7 +12,7 @@ import { MinioStorageAdapter } from "./objectstore/MinioStorageAdapter.js";
 import { LiveSyncAbstractReplicator } from "../LiveSyncAbstractReplicator.js";
 import { ensureRemoteIsCompatible } from "../../pouchdb/LiveSyncDBFunctions.js";
 import { getEffectiveTweakValues } from "../../pouchdb/LiveSyncDBFunctions.js";
-import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { assertSupportedPathNormalizationVersion, getPathNormalizationVersion } from "../../common/pathNormalization.js";
 import { JournalStorageReadStatuses } from "./objectstore/JournalStorageAdapter.js";
 import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
 import { decryptString, encryptString } from "../../encryption/stringEncryption.js";
@@ -44,8 +44,17 @@ const currentVersionRange = {
   current: 2
 };
 function journalVersionRange(setting) {
+  if (getPathNormalizationVersion(setting) === 1) return { min: 4, max: 4, current: 4 };
   return configuredIdKey(setting) && setting.encrypt && setting.usePathObfuscation ? { min: 3, max: 3, current: 3 } : currentVersionRange;
 }
+function pathIdentityFromJournalRange(range) {
+  if (range?.min === 4 && range?.max === 4) return 1;
+  if (!range) return 0;
+  if (Number.isSafeInteger(range.min) && Number.isSafeInteger(range.max) && range.min >= 0 && range.max <= 3 && range.min <= range.max) {
+    return 0;
+  }
+  throw new Error("The Journal declares an unsupported path identity range.");
+}
 class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   get client() {
     return this.setupJournalSyncClient();
@@ -66,7 +75,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return await this.setupJournalSyncClient(setting).getReplicationPBKDF2Salt(refresh);
   }
   setupJournalSyncClient(settings = this.currentSettings) {
-    this.assertLegacyPathIdentity(settings);
+    assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
     if (this._client) {
       this._client.applyNewConfig(settings, this.simpleStore, this.env);
     } else {
@@ -79,33 +88,105 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
     return this._client;
   }
-  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordTweakAssessment) {
-    const milestoneResult = await client.downloadJsonWithResult(MILSTONE_DOCID);
-    if (milestoneResult.status === JournalStorageReadStatuses.UNAVAILABLE) {
-      throw milestoneResult.error;
+  async isBucketPathIdentityCompatible(setting, milestone, client) {
+    const pathVersion = getPathNormalizationVersion(setting);
+    const ranges = milestone?.node_chunk_info ?? {};
+    const nodes = /* @__PURE__ */ new Set([...milestone?.accepted_nodes ?? [], ...Object.keys(ranges)]);
+    for (const node of nodes) {
+      const range = ranges[node];
+      const usesNFC = range?.min === 4 && range?.max === 4;
+      if (usesNFC !== (pathVersion === 1)) return false;
+    }
+    const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
+    if (preferred && getPathNormalizationVersion(preferred) !== pathVersion) return false;
+    if (nodes.size === 0 && await client.hasRemoteJournals()) {
+      throw new Error(
+        "The Journal compatibility milestone is missing. Rebuild from the authoritative Vault before synchronising."
+      );
     }
-    const downloadedMilestone = milestoneResult.status === JournalStorageReadStatuses.AVAILABLE ? milestoneResult.value : false;
+    return true;
+  }
+  async isBucketIdDerivationCompatible(setting, milestone) {
     const idKey = configuredIdKey(setting);
-    let encryptedProof;
-    const preferredTweak = downloadedMilestone && downloadedMilestone.tweak_values?.[DEVICE_ID_PREFERRED];
-    if (preferredTweak?.idDerivationVersion === 1 && preferredTweak.usePathObfuscation === true && (!idKey || !setting.encrypt || !setting.usePathObfuscation)) {
-      return "ID_KEY_MISMATCH";
+    const usesKeyedDocumentIds = !!idKey && setting.encrypt && setting.usePathObfuscation;
+    const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
+    const stored = milestone?.encrypted_id_derivation_proof;
+    if (!usesKeyedDocumentIds) {
+      return !stored && !(preferred?.idDerivationVersion === 1 && preferred.usePathObfuscation === true);
     }
-    if (idKey && setting.encrypt && setting.usePathObfuscation) {
-      const expected = await computeKeyedId(idKey, "remote-agreement", "journal-milestone-v1");
-      const stored = downloadedMilestone && downloadedMilestone.encrypted_id_derivation_proof;
-      if (stored) {
-        try {
-          if (await decryptString(stored, setting.passphrase) !== expected) return "ID_KEY_MISMATCH";
-        } catch {
-          return "ID_KEY_MISMATCH";
-        }
-      } else if (downloadedMilestone) {
-        return "ID_KEY_MISMATCH";
-      } else {
-        encryptedProof = await encryptString(expected, setting.passphrase);
-      }
+    if (!milestone) return true;
+    if (!stored) return false;
+    const expected = await computeKeyedId(idKey, "remote-agreement", "journal-milestone-v1");
+    try {
+      return await decryptString(stored, setting.passphrase) === expected;
+    } catch {
+      return false;
+    }
+  }
+  async assertBucketIdentity(setting, milestone, client) {
+    if (!await this.isBucketPathIdentityCompatible(setting, milestone, client)) {
+      throw new Error(
+        "The Journal and settings use different path identity versions. Rebuild from the authoritative Vault or Fetch with matching settings before synchronising."
+      );
     }
+    if (!await this.isBucketIdDerivationCompatible(setting, milestone)) {
+      throw new Error(
+        "The Journal and settings use different document ID derivation modes or keys. Rebuild from the authoritative Vault or Fetch with matching settings before synchronising."
+      );
+    }
+  }
+  /** Inspect identity without publishing this node, preparing a seed, or changing checkpoints. */
+  async assertRemotePathIdentity(setting) {
+    const client = this.setupJournalSyncClient(setting);
+    await this.assertBucketIdentity(setting, await readRemoteMilestone(client), client);
+  }
+  /** Read path identity for initial setup without publishing a node or preparing a seed. */
+  async inspectRemotePathIdentity(setting) {
+    const client = this.setupJournalSyncClient(setting);
+    const milestone = await readRemoteMilestone(client);
+    const versions = /* @__PURE__ */ new Set();
+    const ranges = milestone?.node_chunk_info ?? {};
+    const nodes = /* @__PURE__ */ new Set([...milestone?.accepted_nodes ?? [], ...Object.keys(ranges)]);
+    for (const node of nodes) {
+      versions.add(pathIdentityFromJournalRange(ranges[node]));
+    }
+    const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
+    if (preferred) versions.add(getPathNormalizationVersion(preferred));
+    if (versions.size > 1) throw new Error("The Journal has conflicting path identity declarations.");
+    if (nodes.size === 0 && await client.hasRemoteJournals()) {
+      throw new Error(
+        "The Journal path identity declaration is missing. Use matching settings or Rebuild from the authoritative Vault."
+      );
+    }
+    const version = [...versions][0];
+    return version === void 0 ? { status: "empty" } : { status: "configured", pathNormalizationVersion: version };
+  }
+  /** Lock existing journals for replacement without declaring the replacement's identity. */
+  async markRemoteLockedForRebuild(setting) {
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
+    const client = this.setupJournalSyncClient(setting);
+    const milestone = await readRemoteMilestone(client);
+    if (!milestone) return;
+    const previousRange = Object.values(milestone.node_chunk_info ?? {}).sort((a, b) => b.min - a.min)[0];
+    const lockedMilestone = {
+      ...milestone,
+      locked: true,
+      accepted_nodes: previousRange ? [this.nodeid] : [],
+      node_chunk_info: previousRange ? { ...milestone.node_chunk_info, [this.nodeid]: { ...previousRange } } : milestone.node_chunk_info
+    };
+    if (!await client.uploadJson(MILSTONE_DOCID, lockedMilestone)) {
+      throw new Error("Could not upload remote milestone");
+    }
+  }
+  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordTweakAssessment) {
+    const downloadedMilestone = await readRemoteMilestone(client) ?? false;
+    if (!await this.isBucketPathIdentityCompatible(setting, downloadedMilestone || void 0, client)) {
+      return "INCOMPATIBLE";
+    }
+    if (!await this.isBucketIdDerivationCompatible(setting, downloadedMilestone || void 0)) {
+      return "ID_KEY_MISMATCH";
+    }
+    const encryptedProof = downloadedMilestone ? void 0 : await this.createInitialIdDerivationProof(setting);
     const cPointInfo = await client.getCheckpointInfo();
     const progress = [...cPointInfo?.receivedFiles || []].sort().pop() || "";
     return await ensureRemoteIsCompatible(
@@ -291,7 +372,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   }
   async checkReplicationConnectivity(skipCheck, ignoreCleanLock = false, showMessage = false, setting = this.currentSettings, client, recordCompatibilityDecision) {
     recordCompatibilityDecision?.(CENTRAL_COMPATIBILITY_NOT_ASSESSED);
-    if (!this.supportsLegacyPathIdentity(setting)) return false;
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const activeClient = client ?? this.setupJournalSyncClient(setting);
     if (!await activeClient.isAvailable()) {
       return false;
@@ -388,7 +469,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     this.updateInfo();
   }
   async tryResetRemoteDatabase(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     this.closeReplication();
     try {
       if (!await this.client.resetBucket()) {
@@ -403,7 +484,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
   }
   async tryCreateRemoteDatabase(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     this.closeReplication();
     Logger("Remote Database Created or Connected", LOG_LEVEL_NOTICE);
     if (!await this.ensurePBKDF2Salt(setting, true, false)) {
@@ -418,7 +499,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return await encryptString(proof, setting.passphrase);
   }
   async markRemoteLocked(setting, locked, lockByClean) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const defInitPoint = {
       _id: MILSTONE_DOCID,
       type: "milestoneinfo",
@@ -432,6 +513,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     };
     const client = this.setupJournalSyncClient(setting);
     const existingMilestone = await readRemoteMilestone(client);
+    await this.assertBucketIdentity(setting, existingMilestone, client);
     const initialProof = existingMilestone ? void 0 : await this.createInitialIdDerivationProof(setting);
     const remoteMilestone = {
       ...defInitPoint,
@@ -452,7 +534,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
   }
   async markRemoteResolved(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const defInitPoint = {
       _id: MILSTONE_DOCID,
       type: "milestoneinfo",
@@ -465,6 +547,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     };
     const client = this.setupJournalSyncClient(setting);
     const existingMilestone = await readRemoteMilestone(client);
+    await this.assertBucketIdentity(setting, existingMilestone, client);
     const initialProof = existingMilestone ? void 0 : await this.createInitialIdDerivationProof(setting);
     const remoteMilestone = {
       ...defInitPoint,
@@ -482,7 +565,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     const endpoint = setting.endpoint;
     let testClient;
     try {
-      this.assertLegacyPathIdentity(setting);
+      assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
       testClient = new MinioStorageAdapter(setting, this.env);
       await testClient.listFiles("", 1);
       Logger(`Connected to ${endpoint} successfully!`, LOG_LEVEL_NOTICE);
@@ -497,12 +580,13 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async resetRemoteTweakSettings(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     try {
       const remoteMilestone = await this.client.downloadJson(MILSTONE_DOCID);
       if (!remoteMilestone) {
         throw new Error("Missing remote milestone");
       }
+      await this.assertBucketIdentity(setting, remoteMilestone, this.client);
       remoteMilestone.tweak_values = {};
       Logger(`tweak values on the remote database have been cleared`, LOG_LEVEL_VERBOSE);
       await this.client.uploadJson(MILSTONE_DOCID, remoteMilestone);
@@ -512,7 +596,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async setPreferredRemoteTweakSettings(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const trialClient = new JournalSyncCore(
       setting,
       this.simpleStore,
@@ -524,6 +608,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
       if (!remoteMilestone) {
         throw new Error("Missing remote milestone");
       }
+      await this.assertBucketIdentity(setting, remoteMilestone, trialClient);
       remoteMilestone.tweak_values[DEVICE_ID_PREFERRED] = getEffectiveTweakValues(setting);
       Logger(`Preferred tweak values have been registered`, LOG_LEVEL_VERBOSE);
       if (!await trialClient.uploadJson(MILSTONE_DOCID, remoteMilestone)) {
@@ -537,7 +622,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async getRemotePreferredTweakValues(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const trialClient = new JournalSyncCore(
       setting,
       this.simpleStore,
@@ -574,7 +659,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async getRemoteStatus(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const testClient = new MinioStorageAdapter(setting, this.env);
     try {
       return await testClient.getUsage();
@@ -582,14 +667,6 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
       testClient.dispose();
     }
   }
-  supportsLegacyPathIdentity(setting) {
-    return getPathNormalizationVersion(setting) === 0;
-  }
-  assertLegacyPathIdentity(setting) {
-    if (!this.supportsLegacyPathIdentity(setting)) {
-      throw new Error("Object Storage does not support NFC path identity.");
-    }
-  }
   async getOwnJoinedDeviceId() {
     const nodeInfo = await this.rawDatabase.get(NODEINFO_DOCID);
     const nodeId = nodeInfo?.nodeid;
@@ -599,7 +676,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     return nodeId;
   }
   async getJoinedDevices(setting) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const trialClient = new JournalSyncCore(
       setting,
       this.simpleStore,
@@ -616,7 +693,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     }
   }
   async forgetJoinedDevice(setting, deviceId) {
-    this.assertLegacyPathIdentity(setting);
+    assertSupportedPathNormalizationVersion(setting.pathNormalizationVersion);
     const ownDeviceId = await this.getOwnJoinedDeviceId();
     const trialClient = new JournalSyncCore(
       setting,
@@ -630,6 +707,7 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
           const result = await trialClient.downloadJsonWithResult(MILSTONE_DOCID);
           if (result.status === JournalStorageReadStatuses.NOT_FOUND) return void 0;
           if (result.status === JournalStorageReadStatuses.UNAVAILABLE) throw result.error;
+          await this.assertBucketIdentity(setting, result.value, trialClient);
           return { milestone: result.value, revision: result.revision };
         },
         write: async (milestone, revision) => await trialClient.uploadJsonIfUnchanged(MILSTONE_DOCID, milestone, revision)

package/dist/replication/trystero/P2PRoomSessionOwner.js

@@ -12,7 +12,7 @@ import { P2PRoomSession } from "./P2PRoomSession.js";
 import { P2PAutomationCoordinator } from "./P2PAutomationCoordinator.js";
 import { PEER_REPLICATION_READINESS } from "../ReplicatorProvider.js";
 import { getP2PReplicatorConfigurationIdentity } from "./p2pReplicatorConfigurationIdentity.js";
-import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { assertSupportedPathNormalizationVersion, getPathNormalizationVersion } from "../../common/pathNormalization.js";
 import {
   ACTIVE_P2P_RELAY_BINDING_CONFLICT,
   activeP2PRelayBindingCovers
@@ -58,8 +58,8 @@ class P2PRoomSessionOwner {
   /** Reconcile one long-lived reason for keeping the room available. */
   async setPersistentDemand(demand, active) {
     const settings = this.env.services.setting.currentSettings();
-    const supportsPathIdentity = getPathNormalizationVersion(settings) === 0;
-    const enabled = settings.P2P_Enabled && supportsPathIdentity;
+    assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
+    const enabled = settings.P2P_Enabled;
     if (active && enabled) {
       this.persistentDemands.add(demand);
     } else {
@@ -67,8 +67,6 @@ class P2PRoomSessionOwner {
     }
     if (active && !settings.P2P_Enabled) {
       Logger(this.env.services.context.translate("P2P.NotEnabled"), LOG_LEVEL_NOTICE);
-    } else if (active && !supportsPathIdentity) {
-      Logger("P2P does not support NFC path identity.", LOG_LEVEL_NOTICE);
     }
     await this.fencePreparationForCurrentSettings(enabled);
     await this.reconcileTransport();
@@ -81,12 +79,10 @@ class P2PRoomSessionOwner {
    */
   async runWithFiniteDemand(task) {
     const settings = this.env.services.setting.currentSettings();
+    assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
     if (!settings.P2P_Enabled) {
       throw new Error("P2P is not enabled.");
     }
-    if (getPathNormalizationVersion(settings) !== 0) {
-      throw new Error("P2P does not support NFC path identity.");
-    }
     const demand = /* @__PURE__ */ Symbol("p2p-finite-room-demand");
     this.finiteDemands.add(demand);
     try {
@@ -108,8 +104,10 @@ class P2PRoomSessionOwner {
   }
   /** Arbitrate a complete signalling probe on the room lifecycle queue. */
   runConnectionProbe(trialSettings, runOwnedTrial) {
-    if (getPathNormalizationVersion(this.env.services.setting.currentSettings()) !== 0) {
-      return Promise.reject(new Error("P2P does not support NFC path identity."));
+    try {
+      assertSupportedPathNormalizationVersion(this.env.services.setting.currentSettings().pathNormalizationVersion);
+    } catch (error) {
+      return Promise.reject(error);
     }
     return this.enqueueLifecycleOperation(async () => {
       const current = this.current;
@@ -135,7 +133,8 @@ class P2PRoomSessionOwner {
   async reconcileTransport() {
     await this.enqueueLifecycleOperation(async () => {
       const settings = this.env.services.setting.currentSettings();
-      if (!settings.P2P_Enabled || getPathNormalizationVersion(settings) !== 0) {
+      assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
+      if (!settings.P2P_Enabled) {
         this.persistentDemands.clear();
         this.finiteDemands.clear();
       }
@@ -390,17 +389,19 @@ class P2PRoomSessionOwner {
       ...this.env.services.setting.currentSettings()
     });
     const database = this.env.services.database.localDatabase.localDatabase;
+    const pathNormalizationVersion = getPathNormalizationVersion(settings);
     this.automationCoordinator.reconcileIdentity(
       JSON.stringify([
         settings.P2P_AppID || "self-hosted-livesync",
         settings.P2P_roomID,
-        settings.P2P_passphrase
+        settings.P2P_passphrase,
+        pathNormalizationVersion
       ]),
       database
     );
     return {
       database,
-      enabled: settings.P2P_Enabled && getPathNormalizationVersion(settings) === 0,
+      enabled: settings.P2P_Enabled,
       settings,
       deviceName,
       signature: JSON.stringify([getP2PReplicatorConfigurationIdentity(settings), deviceName])

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

@@ -141,6 +141,7 @@ export declare class TrysteroReplicator {
     setOnSetup(): void;
     clearOnSetup(): void;
     getTweakSettings(fromPeerId: string): Promise<{
+        pathNormalizationVersion: import("../../settings.js").PathNormalizationVersion;
         idDerivationVersion: 0 | 1;
         idDerivationProof: string;
         liveSync?: boolean;
@@ -251,7 +252,6 @@ export declare class TrysteroReplicator {
         bucketPrefix?: string;
         forcePathStyle?: boolean;
         remoteType?: import("../../common/types.js").RemoteType;
-        pathNormalizationVersion?: import("../../settings.js").PathNormalizationVersion;
         encrypt?: boolean;
         passphrase?: string;
         idDerivationKey?: string;
@@ -331,6 +331,7 @@ export declare class TrysteroReplicator {
         reqSync: (fromPeerId: string) => Promise<P2PReplicationWireResult>;
         "!reqAuth": (fromPeerId: string) => Promise<boolean>;
         getTweakSettings: (fromPeerId: string) => Promise<{
+            pathNormalizationVersion: import("../../settings.js").PathNormalizationVersion;
             idDerivationVersion: 0 | 1;
             idDerivationProof: string;
             liveSync?: boolean;
@@ -441,7 +442,6 @@ export declare class TrysteroReplicator {
             bucketPrefix?: string;
             forcePathStyle?: boolean;
             remoteType?: import("../../common/types.js").RemoteType;
-            pathNormalizationVersion?: import("../../settings.js").PathNormalizationVersion;
             encrypt?: boolean;
             passphrase?: string;
             idDerivationKey?: string;
@@ -517,15 +517,15 @@ export declare class TrysteroReplicator {
             P2P_useDiagRTC?: boolean;
         }>;
         onProgress: (fromPeerId: string) => Promise<{
-            error: import("../../rpc/index.js").RpcErrorShape;
+            error: import("../../rpc/types.js").RpcErrorShape;
         }>;
         getAllConfig: (fromPeerId: string) => Promise<string | {
-            error: import("../../rpc/index.js").RpcErrorShape;
+            error: import("../../rpc/types.js").RpcErrorShape;
         }>;
         onProgressAcknowledged: (fromPeerId: string, info: ProgressInfo) => Promise<void>;
         getIsBroadcasting: () => Promise<boolean>;
         requestBroadcasting: (peerId: string) => Promise<true | {
-            error: import("../../rpc/index.js").RpcErrorShape;
+            error: import("../../rpc/types.js").RpcErrorShape;
         }>;
     };
     requestAuthenticate(peerId: string, signal?: AbortSignal): Promise<boolean>;
@@ -553,6 +553,8 @@ export declare class TrysteroReplicator {
     acknowledgeProgress(remotePeerId: string, info?: ProgressInfo): void;
     replicateFrom(remotePeer: string, showNotice?: boolean, fromStart?: boolean, skipOrdinaryReplicationPolicy?: boolean, callerSignal?: AbortSignal): Promise<P2PReplicationResult>;
     private replicateFromWithinSession;
+    private checkPeerForReplication;
+    private transferFromPeer;
     notifyProgress(excludePeerId?: string): Promise<void>;
     requestBroadcastChanges(peerId: string): Promise<unknown>;
     getRemoteIsBroadcasting(peerId: string): Promise<unknown>;