@vrtmrz/livesync-commonlib 0.2.2 → 0.3.0

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>;

package/dist/replication/trystero/TrysteroReplicator.js

@@ -1,3 +1,4 @@
+import { parsePeerPatterns } from "./peerPatterns.js";
 import {
   TweakValuesShouldMatchedTemplate,
   omitP2PRuntimeSettings
@@ -27,6 +28,9 @@ import { compatGlobal } from "../../common/coreEnvFunctions.js";
 import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
 import { getWebCrypto } from "../../mods.js";
 import { uint8ArrayToHexString } from "../../string_and_binary/convert.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { readLocalP2PPathIdentity, readRemoteP2PPathIdentity } from "./TrysteroReplicator.pathIdentity.js";
+import { assertDatabasePathIdentity } from "../../pouchdb/pathIdentityCompatibility.js";
 import {
   fromP2PReplicationWireResult,
   toP2PReplicationWireResult,
@@ -171,12 +175,10 @@ class TrysteroReplicator {
     }
   }
   get autoSyncPeers() {
-    const peers = this.currentSettings.P2P_AutoSyncPeers.split(",").map((e) => e.trim()).filter((e) => e.length > 0).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
-    return peers;
+    return parsePeerPatterns(this.currentSettings.P2P_AutoSyncPeers);
   }
   get autoWatchPeers() {
-    const peers = this.currentSettings.P2P_AutoWatchPeers.split(",").map((e) => e.trim()).filter((e) => e.length > 0).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
-    return peers;
+    return parsePeerPatterns(this.currentSettings.P2P_AutoWatchPeers);
   }
   async onNewPeer(peer) {
     const peerName = peer.name;
@@ -206,6 +208,11 @@ class TrysteroReplicator {
     this._onSetup = false;
   }
   async getTweakSettings(fromPeerId) {
+    const currentSettings = this.currentSettings;
+    const pathNormalizationVersion = getPathNormalizationVersion(currentSettings);
+    if (pathNormalizationVersion === 1) {
+      await assertDatabasePathIdentity(this.db, currentSettings, true);
+    }
     const allSettings = JSON.parse(JSON.stringify(this.settings));
     for (const key in allSettings) {
       if (key == "encrypt") {
@@ -224,6 +231,7 @@ class TrysteroReplicator {
     const idKey = configuredIdKey({ idDerivationVersion, idDerivationKey: idSettings.idDerivationKey ?? "" });
     return {
       ...allSettings,
+      pathNormalizationVersion,
       idDerivationVersion,
       idDerivationProof: idKey && idSettings.encrypt && idSettings.usePathObfuscation ? await computeKeyedId(idKey, "peer-agreement", fromPeerId) : ""
     };
@@ -554,6 +562,28 @@ class TrysteroReplicator {
     }
     if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
     const logLevel = showNotice ? LOG_LEVEL_NOTICE : LOG_LEVEL_INFO;
+    const rejection = await this.checkPeerForReplication(remotePeer, logLevel, signal);
+    if (rejection) return rejection;
+    Logger(`P2P Replicating from ${remotePeer}`, logLevel, "p2p-replicator");
+    if (this._replicateFromPeers.has(remotePeer)) {
+      Logger(`Replication from ${remotePeer} is already in progress`, logLevel, "p2p-replicator");
+      return p2pReplicationFailed(new Error("Replication from this peer is already in progress"));
+    }
+    this._replicateFromPeers.add(remotePeer);
+    this.dispatchStatus();
+    try {
+      return await this.transferFromPeer(remotePeer, fromStart, logLevel, signal);
+    } catch (e) {
+      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
+      Logger("Error while P2P replicating", logLevel, "p2p-replicator");
+      Logger(e, LOG_LEVEL_VERBOSE);
+      return p2pReplicationFailed(e);
+    } finally {
+      this._replicateFromPeers.delete(remotePeer);
+      this.dispatchStatus();
+    }
+  }
+  async checkPeerForReplication(remotePeer, logLevel, signal) {
     Logger(`P2P Requesting Authentication to ${remotePeer}`, logLevel, "p2p-replicator");
     const authenticated = signal ? await this.requestAuthenticate(remotePeer, signal) : await this.requestAuthenticate(remotePeer);
     if (authenticated !== true) {
@@ -573,71 +603,62 @@ class TrysteroReplicator {
       Logger("Tweak values are not matched", logLevel, "p2p-replicator");
       return p2pReplicationFailed(new Error("Tweak values are not matched"));
     }
-    Logger(`P2P Replicating from ${remotePeer}`, logLevel, "p2p-replicator");
-    if (this._replicateFromPeers.has(remotePeer)) {
-      Logger(`Replication from ${remotePeer} is already in progress`, logLevel, "p2p-replicator");
-      return p2pReplicationFailed(new Error("Replication from this peer is already in progress"));
-    }
-    this._replicateFromPeers.add(remotePeer);
-    this.dispatchStatus();
-    try {
-      if (!this.server) {
-        throw new Error("Server is not available");
-      }
-      const connection = this.server.getConnection(remotePeer);
-      const remoteDB = connection.getRemoteDB(signal);
-      Logger(`P2P replicateFrom preparing remote DB info for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      const remoteDBInfo = await remoteDB.info();
-      Logger(
-        `P2P replicateFrom remote DB info for ${remotePeer}: ${remoteDBInfo.db_name} seq=${remoteDBInfo.update_seq}`,
-        LOG_LEVEL_VERBOSE,
-        "p2p-replicator"
-      );
-      const localDBInfo = await this.db.info();
-      Logger(
-        `P2P replicateFrom local DB info for ${remotePeer}: ${localDBInfo.db_name} seq=${localDBInfo.update_seq}`,
-        LOG_LEVEL_VERBOSE,
-        "p2p-replicator"
-      );
-      Logger(`P2P replicateFrom entering replicateShim for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      const outcome = await replicateShim(
-        this.db,
-        remoteDB,
-        async (docs, info) => {
-          await this._env.processReplicatedDocs(docs);
-          void this.dispatchReplicationProgress(remotePeer, info);
-          void this.acknowledgeProgress(remotePeer, info);
-          void this.notifyProgress(remotePeer);
-          Logger(
-            `P2P Replication from ${remotePeer}
+    return void 0;
+  }
+  async transferFromPeer(remotePeer, fromStart, logLevel, signal) {
+    if (!this.server) {
+      throw new Error("Server is not available");
+    }
+    const connection = this.server.getConnection(remotePeer);
+    const remoteDB = connection.getRemoteDB(signal);
+    const pathNormalizationVersion = getPathNormalizationVersion(this.currentSettings);
+    const [localPathIdentity, remotePathIdentity] = await Promise.all([
+      readLocalP2PPathIdentity(this.db, pathNormalizationVersion),
+      readRemoteP2PPathIdentity(remoteDB, pathNormalizationVersion)
+    ]);
+    if (localPathIdentity !== pathNormalizationVersion || remotePathIdentity !== pathNormalizationVersion) {
+      const error = new Error("P2P database path identity does not match the configured path identity.");
+      Logger(error.message, logLevel, "p2p-replicator");
+      return p2pReplicationFailed(error);
+    }
+    Logger(`P2P replicateFrom preparing remote DB info for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    const remoteDBInfo = await remoteDB.info();
+    Logger(
+      `P2P replicateFrom remote DB info for ${remotePeer}: ${remoteDBInfo.db_name} seq=${remoteDBInfo.update_seq}`,
+      LOG_LEVEL_VERBOSE,
+      "p2p-replicator"
+    );
+    const localDBInfo = await this.db.info();
+    Logger(
+      `P2P replicateFrom local DB info for ${remotePeer}: ${localDBInfo.db_name} seq=${localDBInfo.update_seq}`,
+      LOG_LEVEL_VERBOSE,
+      "p2p-replicator"
+    );
+    Logger(`P2P replicateFrom entering replicateShim for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    const outcome = await replicateShim(
+      this.db,
+      remoteDB,
+      async (docs, info) => {
+        await this._env.processReplicatedDocs(docs);
+        void this.dispatchReplicationProgress(remotePeer, info);
+        void this.acknowledgeProgress(remotePeer, info);
+        void this.notifyProgress(remotePeer);
+        Logger(
+          `P2P Replication from ${remotePeer}
 ${info.lastSeq} / ${info.maxSeqInBatch})`,
-            logLevel,
-            "p2p-replicator"
-          );
-        },
-        {
-          live: false,
-          rewind: fromStart,
-          signal
-          /*, batch_size: batchSize */
-        }
-      );
-      Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-      void this.acknowledgeProgress(remotePeer, void 0);
-      if (outcome.status === "cancelled") {
-        Logger(`P2P Replication from ${remotePeer} has been cancelled`, logLevel, "p2p-replicator");
-        return P2P_REPLICATION_CANCELLED;
-      }
-      Logger(`P2P Replication from ${remotePeer} has been completed`, logLevel, "p2p-replicator");
-    } catch (e) {
-      if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
-      Logger("Error while P2P replicating", logLevel, "p2p-replicator");
-      Logger(e, LOG_LEVEL_VERBOSE);
-      return p2pReplicationFailed(e);
-    } finally {
-      this._replicateFromPeers.delete(remotePeer);
-      this.dispatchStatus();
+          logLevel,
+          "p2p-replicator"
+        );
+      },
+      { live: false, rewind: fromStart, signal }
+    );
+    Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
+    void this.acknowledgeProgress(remotePeer, void 0);
+    if (outcome.status === "cancelled") {
+      Logger(`P2P Replication from ${remotePeer} has been cancelled`, logLevel, "p2p-replicator");
+      return P2P_REPLICATION_CANCELLED;
     }
+    Logger(`P2P Replication from ${remotePeer} has been completed`, logLevel, "p2p-replicator");
     return P2P_REPLICATION_COMPLETED;
   }
   notifyProgress(excludePeerId) {
@@ -740,12 +761,6 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       Logger("Peer is not found", logLevel);
       return false;
     }
-    if (this.platform === "pseudo-replicator") {
-      return true;
-    }
-    if (peerPlatform === "pseudo-replicator") {
-      return true;
-    }
     const connection = this.server.getConnection(peerId);
     const challengeBytes = new Uint8Array(16);
     (await getWebCrypto()).getRandomValues(challengeBytes);
@@ -753,6 +768,15 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
     const tweakValues = await connection.invokeRemoteObjectFunction("getTweakSettings", [challenge], 5e3, signal);
     if (signal?.aborted) return false;
     const thisTweakValues = await this.getTweakSettings(challenge);
+    const localPathNormalizationVersion = getPathNormalizationVersion(thisTweakValues);
+    const peerPathNormalizationVersion = getPathNormalizationVersion(tweakValues);
+    if (localPathNormalizationVersion !== peerPathNormalizationVersion) {
+      Logger("Replication cancelled: The path identity mode does not match this peer.", logLevel);
+      return false;
+    }
+    if (this.platform === "pseudo-replicator" || peerPlatform === "pseudo-replicator") {
+      return true;
+    }
     if (thisTweakValues.passphrase !== tweakValues.passphrase) {
       Logger(
         "Replication cancelled: Passphrase is not matched\nCannot replicate to a remote database until the problem is resolved.",
@@ -761,7 +785,10 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
       return false;
     }
     if (thisTweakValues.encrypt !== tweakValues.encrypt || thisTweakValues.usePathObfuscation !== tweakValues.usePathObfuscation) {
-      Logger("Replication cancelled: The encryption or path obfuscation settings do not match this peer.", logLevel);
+      Logger(
+        "Replication cancelled: The encryption or path obfuscation settings do not match this peer.",
+        logLevel
+      );
       return false;
     }
     if (thisTweakValues.encrypt && thisTweakValues.usePathObfuscation && ((thisTweakValues.idDerivationVersion ?? 0) !== (tweakValues.idDerivationVersion ?? 0) || (thisTweakValues.idDerivationProof ?? "") !== (tweakValues.idDerivationProof ?? ""))) {

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

@@ -0,0 +1,11 @@
+import type { PathNormalizationVersion } from "../../common/models/setting.type.js";
+export declare function readLocalP2PPathIdentity(database: {
+    get(id: string): Promise<unknown>;
+}, configuredVersion: PathNormalizationVersion): Promise<PathNormalizationVersion>;
+export declare function readRemoteP2PPathIdentity(database: {
+    bulkGet(options: {
+        docs: {
+            id: string;
+        }[];
+    }): Promise<unknown>;
+}, configuredVersion: PathNormalizationVersion): Promise<PathNormalizationVersion>;

package/dist/replication/trystero/TrysteroReplicator.pathIdentity.js

@@ -0,0 +1,72 @@
+import { VERSIONING_DOCID } from "../../common/models/db.const.js";
+import {
+  assessRemoteFeatureDocument,
+  describeRemoteFeatureRejection,
+  NFC_PATH_IDENTITY_FEATURE
+} from "../../pouchdb/remoteFeatureCompatibility.js";
+import { isErrorOfMissingDoc } from "../../pouchdb/utils_couchdb.js";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwnField(value, key) {
+  return Object.hasOwn(value, key);
+}
+function isVersionInfoResponse(value) {
+  if (!isRecord(value) || !Array.isArray(value.results) || value.results.length !== 1) return false;
+  const [result] = value.results;
+  return isRecord(result) && result.id === VERSIONING_DOCID && Array.isArray(result.docs) && result.docs.length === 1 && isRecord(result.docs[0]);
+}
+function isMissingDocumentResult(result) {
+  if (!hasOwnField(result, "error")) return false;
+  const error = result.error;
+  const errorDetails = isRecord(error) ? error : void 0;
+  const status = errorDetails?.status ?? result.status;
+  const errorName = errorDetails?.name ?? result.name;
+  const errorCode = typeof error === "string" ? error : errorDetails?.error;
+  return status === 404 || status === void 0 && (errorName === "not_found" || errorCode === "not_found");
+}
+function parseRemotePathIdentityDocument(response) {
+  if (!isVersionInfoResponse(response)) {
+    throw new Error("P2P remote versioninfo response is malformed.");
+  }
+  const [documentResult] = response.results[0].docs;
+  if (hasOwnField(documentResult, "ok")) {
+    const document = documentResult.ok;
+    if (!isRecord(document) || document._id !== VERSIONING_DOCID) {
+      throw new Error("P2P remote versioninfo response is malformed.");
+    }
+    return { kind: "found", document };
+  }
+  if (isMissingDocumentResult(documentResult)) return { kind: "missing" };
+  throw new Error("P2P remote versioninfo could not be read.");
+}
+function resolvePathIdentity(result, configuredVersion) {
+  if (result.kind === "missing") {
+    if (configuredVersion === 0) return 0;
+    throw new Error("P2P NFC database is missing path identity version information.");
+  }
+  const assessment = assessRemoteFeatureDocument(result.document);
+  if (assessment.status === "older-generation" && configuredVersion === 0) return 0;
+  if (assessment.status !== "supported") {
+    throw new Error(describeRemoteFeatureRejection(assessment));
+  }
+  return assessment.usedFeatures.includes(NFC_PATH_IDENTITY_FEATURE) ? 1 : 0;
+}
+async function readLocalP2PPathIdentity(database, configuredVersion) {
+  let result;
+  try {
+    result = { kind: "found", document: await database.get(VERSIONING_DOCID) };
+  } catch (error) {
+    if (!isErrorOfMissingDoc(error)) throw error;
+    result = { kind: "missing" };
+  }
+  return resolvePathIdentity(result, configuredVersion);
+}
+async function readRemoteP2PPathIdentity(database, configuredVersion) {
+  const response = await database.bulkGet({ docs: [{ id: VERSIONING_DOCID }] });
+  return resolvePathIdentity(parseRemotePathIdentityDocument(response), configuredVersion);
+}
+export {
+  readLocalP2PPathIdentity,
+  readRemoteP2PPathIdentity
+};

package/dist/replication/trystero/TrysteroReplicatorP2PServer.js

@@ -1,3 +1,4 @@
+import { parsePeerPatterns } from "./peerPatterns.js";
 import { selfId, joinRoom } from "@trystero-p2p/nostr";
 import { AutoAccepting, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE } from "../../common/types.js";
 import { LOG_LEVEL_VERBOSE, Logger } from "../../common/logger.js";
@@ -281,12 +282,12 @@ You can chose as follows:
   }
   _acceptablePeers = new Computed({
     evaluation: (settings) => {
-      return `${settings?.P2P_AutoAcceptingPeers ?? ""}`.split(",").map((e) => e.trim()).filter((e) => !!e).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
+      return parsePeerPatterns(`${settings?.P2P_AutoAcceptingPeers ?? ""}`);
     }
   });
   _shouldDenyPeers = new Computed({
     evaluation: (settings) => {
-      return `${settings?.P2P_AutoDenyingPeers ?? ""}`.split(",").map((e) => e.trim()).filter((e) => !!e).map((e) => e.startsWith("~") ? new RegExp(e.substring(1), "i") : new RegExp(`^${e}$`, "i"));
+      return parsePeerPatterns(`${settings?.P2P_AutoDenyingPeers ?? ""}`);
     }
   });
   /**

package/dist/replication/trystero/p2pReplicatorConfigurationIdentity.js

@@ -7,6 +7,7 @@ import {
   splitP2PRelayUrls,
   splitP2PTurnServerUrls
 } from "../../common/models/setting.p2p.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
 function getP2PReplicatorConfigurationIdentity(settings) {
   const managedTurnSelected = hasManagedP2PTurnConfiguration(settings);
   const turnServerValue = settings.P2P_turnServers ?? "";
@@ -25,6 +26,7 @@ function getP2PReplicatorConfigurationIdentity(settings) {
     managedTurnSelected ? [settings.P2P_managedType, settings.P2P_managedId, settings.P2P_managedToken] : void 0,
     normaliseP2PMaxWirePayloadBytes(settings.P2P_maxWirePayloadBytes),
     effectivePath,
+    getPathNormalizationVersion(settings),
     settings.P2P_useDiagRTC ?? false
   ]);
 }

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

@@ -0,0 +1 @@
+export declare function parsePeerPatterns(value: string): RegExp[];

package/dist/replication/trystero/peerPatterns.js

@@ -0,0 +1,6 @@
+function parsePeerPatterns(value) {
+  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map((entry) => entry.startsWith("~") ? new RegExp(entry.substring(1), "i") : new RegExp(`^${entry}$`, "i"));
+}
+export {
+  parsePeerPatterns
+};

package/dist/replication/trystero/useP2PReplicatorFeature.js

@@ -15,7 +15,7 @@ import {
   supportedStopActiveTransfer
 } from "../index.js";
 import { getP2PReplicatorConfigurationIdentity } from "./p2pReplicatorConfigurationIdentity.js";
-import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { assertSupportedPathNormalizationVersion } from "../../common/pathNormalization.js";
 function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFactory, options = {}) {
   const service = createP2PService(
     {
@@ -63,7 +63,11 @@ function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFa
         kind: REMOTE_P2P,
         diagnosticName: "P2P",
         readiness: PEER_REPLICATION_READINESS,
-        isConfigured: (settings) => settings.remoteType === REMOTE_P2P && settings.P2P_Enabled && getPathNormalizationVersion(settings) === 0,
+        isConfigured: (settings) => {
+          if (settings.remoteType !== REMOTE_P2P || !settings.P2P_Enabled) return false;
+          assertSupportedPathNormalizationVersion(settings.pathNormalizationVersion);
+          return true;
+        },
         configurationIdentity: getP2PReplicatorConfigurationIdentity,
         create: createP2PReplicator,
         remoteResources: NO_REMOTE_RESOURCE_CAPABILITIES,

package/dist/rpc/RpcRoom.d.ts

@@ -8,7 +8,7 @@ export declare class RpcRoom {
     private sessions;
     private outgoingChunkMap;
     private incomingChunkMap;
-    private incomingChunkTimers;
+    private incomingChunkWaits;
     private peerVersion;
     private disposers;
     private closed;
@@ -32,7 +32,11 @@ export declare class RpcRoom {
     private notifyRemoteCancellation;
     private abortInboundCall;
     private sendEnvelope;
+    private sendChunk;
+    private sendErrorResponse;
     private scheduleMissingAck;
     private onWireMessage;
     private onEnvelopePayload;
+    private onRequest;
+    private runMethod;
 }