Keep P2P consumers on the current transport

src/features/P2PSync/P2PReplicator/P2POpenReplicationPane.svelte

@@ -23,6 +23,7 @@
     }
 
     let { onSync, onSyncAndClose, onClose, showResult, liveSyncReplicator, rebuildMode = false }: Props = $props();
+    const getLiveSyncReplicator = () => liveSyncReplicator;
 
     let serverInfo = $state<P2PServerInfo | undefined>(undefined);
     let syncingPeerId = $state<string | null>(null);
@@ -98,7 +99,7 @@
 </script>
 
 <div class="p2p-container">
-    <P2PServerStatusCard {liveSyncReplicator} showBroadcastToggle={false} />
+    <P2PServerStatusCard {getLiveSyncReplicator} showBroadcastToggle={false} />
 
     <div class="peers-section">
         <h3>Available Peers</h3>

src/features/P2PSync/P2PReplicator/P2PReplicationUI.ts

@@ -111,7 +111,7 @@ export function createOpenRebuildUI(
                     try {
                         replicator.setOnSetup();
                         Logger(`Rebuilding from peer ${peerId}`, logLevel);
-                        const result = await replicator.replicateFrom(peerId, showResult);
+                        const result = await replicator.replicateFrom(peerId, showResult, true);
                         sessionResult = result?.ok ?? false;
                     } catch (e) {
                         Logger(

src/features/P2PSync/P2PReplicator/P2PReplicationUI.unit.spec.ts

@@ -160,6 +160,7 @@ describe("createOpenRebuildUI", () => {
         await rebuild;
         await expect(session).resolves.toBe(true);
         expect(replicator.setOnSetup).toHaveBeenCalledOnce();
+        expect(replicator.replicateFrom).toHaveBeenCalledWith("peer-a", true, true);
         expect(replicator.clearOnSetup).toHaveBeenCalledOnce();
     });
 });

src/features/P2PSync/P2PReplicator/P2PReplicatorPane.svelte

@@ -23,13 +23,12 @@
     import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore";
 
     interface Props {
-        cmdSync: P2PReplicatorPaneController;
+        getCmdSync: () => P2PReplicatorPaneController;
         core: Pick<LiveSyncBaseCore, "services">;
     }
 
-    let { cmdSync, core }: Props = $props();
-    // const cmdSync = plugin.getAddOn<P2PReplicator>("P2PReplicator")!;
-    setContext("getReplicator", () => cmdSync);
+    let { getCmdSync, core }: Props = $props();
+    setContext("getReplicator", () => getCmdSync());
     const currentSettings = () => core.services.setting.currentSettings() as P2PSyncSetting;
     const initialSettings = { ...currentSettings() } as P2PSyncSetting;
 
@@ -223,16 +222,16 @@
     }
 
     async function openServer() {
-        await cmdSync.open();
+        await getCmdSync().open();
     }
     async function closeServer() {
-        await cmdSync.close();
+        await getCmdSync().close();
     }
     function startBroadcasting() {
-        void cmdSync.enableBroadcastChanges();
+        void getCmdSync().enableBroadcastChanges();
     }
     function stopBroadcasting() {
-        void cmdSync.disableBroadcastChanges();
+        void getCmdSync().disableBroadcastChanges();
     }
 
     const initialDialogStatusKey = `p2p-dialog-status`;

src/features/P2PSync/P2PReplicator/P2PReplicatorPaneView.ts

@@ -187,7 +187,7 @@ And you can also drop the local database to rebuild from the remote device.`,
         return mount(ReplicatorPaneComponent, {
             target: target,
             props: {
-                cmdSync: this._p2pResult.replicator,
+                getCmdSync: () => this._p2pResult.replicator,
                 core: this.core,
             },
         });

src/features/P2PSync/P2PReplicator/P2PServerStatusCard.svelte

@@ -15,12 +15,12 @@
     import type { LiveSyncBaseCore } from "@/LiveSyncBaseCore";
 
     interface Props {
-        liveSyncReplicator: LiveSyncTrysteroReplicator;
+        getLiveSyncReplicator: () => LiveSyncTrysteroReplicator;
         showBroadcastToggle?: boolean;
         core?: LiveSyncBaseCore;
     }
 
-    let { liveSyncReplicator, showBroadcastToggle = true, core }: Props = $props();
+    let { getLiveSyncReplicator, showBroadcastToggle = true, core }: Props = $props();
     let serverInfo = $state<P2PServerInfo | undefined>(undefined);
     let replicatorStatus = $state<P2PReplicatorStatus | undefined>(undefined);
     // Later setting changes arrive through EVENT_SETTING_SAVED; these values only seed local state at mount time.
@@ -30,25 +30,25 @@
     let useDiagRTC = $state<boolean>(initialSettings?.P2P_useDiagRTC ?? false);
 
     async function requestServerStatus() {
-        await Promise.resolve(liveSyncReplicator.requestStatus());
+        await Promise.resolve(getLiveSyncReplicator().requestStatus());
         eventHub.emitEvent(EVENT_REQUEST_STATUS);
     }
 
     async function onOpenConnection() {
-        await liveSyncReplicator.makeSureOpened();
+        await getLiveSyncReplicator().makeSureOpened();
         await requestServerStatus();
     }
 
     async function onDisconnect() {
-        await liveSyncReplicator.close();
+        await getLiveSyncReplicator().close();
         await requestServerStatus();
     }
 
     function toggleBroadcast() {
         if (replicatorStatus?.isBroadcasting) {
-            liveSyncReplicator.disableBroadcastChanges();
+            getLiveSyncReplicator().disableBroadcastChanges();
         } else {
-            liveSyncReplicator.enableBroadcastChanges();
+            getLiveSyncReplicator().enableBroadcastChanges();
         }
     }
 

src/features/P2PSync/P2PReplicator/P2PServerStatusPane.svelte

@@ -26,11 +26,11 @@
     import SetupRemoteP2P from "@/modules/features/SetupWizard/dialogs/SetupRemoteP2P.svelte";
 
     interface Props {
-        liveSyncReplicator: LiveSyncTrysteroReplicator;
+        getLiveSyncReplicator: () => LiveSyncTrysteroReplicator;
         core: LiveSyncBaseCore;
     }
 
-    let { liveSyncReplicator, core }: Props = $props();
+    let { getLiveSyncReplicator, core }: Props = $props();
     let serverInfo = $state<P2PServerInfo | undefined>(undefined);
     let replicatorInfo = $state<P2PReplicatorStatus | undefined>(undefined);
     let decidingPeerId = $state<string | null>(null);
@@ -129,7 +129,7 @@
     }
 
     async function requestServerStatus() {
-        await liveSyncReplicator.requestStatus();
+        await getLiveSyncReplicator().requestStatus();
         eventHub.emitEvent(EVENT_REQUEST_STATUS);
     }
 
@@ -309,7 +309,7 @@
     ) {
         decidingPeerId = peer.peerId;
         try {
-            await liveSyncReplicator.makeDecision({
+            await getLiveSyncReplicator().makeDecision({
                 peerId: peer.peerId,
                 name: peer.name,
                 decision,
@@ -324,7 +324,7 @@
     async function revokeDecision(peer: P2PServerInfo["knownAdvertisements"][number]) {
         decidingPeerId = peer.peerId;
         try {
-            await liveSyncReplicator.revokeDecision({
+            await getLiveSyncReplicator().revokeDecision({
                 peerId: peer.peerId,
                 name: peer.name,
             });
@@ -337,9 +337,9 @@
     async function startReplication(peer: P2PServerInfo["knownAdvertisements"][number]) {
         replicatingPeerId = peer.peerId;
         try {
-            const pullResult = await liveSyncReplicator.replicateFrom(peer.peerId, true);
+            const pullResult = await getLiveSyncReplicator().replicateFrom(peer.peerId, true);
             if (pullResult?.ok) {
-                await liveSyncReplicator.requestSynchroniseToPeer(peer.peerId);
+                await getLiveSyncReplicator().requestSynchroniseToPeer(peer.peerId);
             }
             await requestServerStatus();
         } finally {
@@ -360,9 +360,9 @@
             return;
         }
         if (isWatching(peerId)) {
-            liveSyncReplicator.unwatchPeer(peerId);
+            getLiveSyncReplicator().unwatchPeer(peerId);
         } else {
-            liveSyncReplicator.watchPeer(peerId);
+            getLiveSyncReplicator().watchPeer(peerId);
         }
     }
 
@@ -440,7 +440,7 @@
         <p class="warning-line">Please select an active P2P remote configuration to change P2P sync targets.</p>
     {/if}
 
-    <P2PServerStatusCard {liveSyncReplicator} {core} />
+    <P2PServerStatusCard {getLiveSyncReplicator} {core} />
 
     <div class="peers-section">
         <div class="peers-header">

src/features/P2PSync/P2PReplicator/P2PServerStatusPaneView.ts

@@ -35,7 +35,7 @@ export class P2PServerStatusPaneView extends SvelteItemView {
         return mount(P2PServerStatusPane, {
             target,
             props: {
-                liveSyncReplicator: this._p2pResult.replicator,
+                getLiveSyncReplicator: () => this._p2pResult.replicator,
                 core: this.core,
             },
         });

src/features/P2PSync/P2PReplicator/PeerStatusRow.svelte

@@ -57,7 +57,7 @@
     let isNew = $derived.by(() => peer.accepted === AcceptedStatus.UNKNOWN);
 
     function makeDecision(isAccepted: boolean, isTemporary: boolean) {
-        replicator.makeDecision({
+        getReplicator().makeDecision({
             peerId: peer.peerId,
             name: peer.name,
             decision: isAccepted,
@@ -65,12 +65,12 @@
         });
     }
     function revokeDecision() {
-        replicator.revokeDecision({
+        getReplicator().revokeDecision({
             peerId: peer.peerId,
             name: peer.name,
         });
     }
-    const replicator = getContext<() => P2PReplicatorPaneController>("getReplicator")();
+    const getReplicator = getContext<() => P2PReplicatorPaneController>("getReplicator");
 
     const peerAttrLabels = $derived.by(() => {
         const attrs = [];
@@ -86,14 +86,14 @@
         return attrs;
     });
     function startWatching() {
-        replicator?.watchPeer(peer.peerId);
+        getReplicator().watchPeer(peer.peerId);
     }
     function stopWatching() {
-        replicator?.unwatchPeer(peer.peerId);
+        getReplicator().unwatchPeer(peer.peerId);
     }
 
     function sync() {
-        void replicator?.sync(peer.peerId, false);
+        void getReplicator().sync(peer.peerId, false);
     }
 
     function moreMenu(evt: MouseEvent) {