Add Joined devices dialogue and version notices

src/common/messages/LiveSyncProvisionalMessages.ts

@@ -7,6 +7,62 @@
  * remove it from this map in the same change.
  */
 export const liveSyncProvisionalEnglishMessages = {
+    "Unknown platform": "Unknown platform",
+    "This removes only this device's record from the remote.":
+        "This removes only this device's record from the remote.",
+    "This remote is unlocked. A device that returns can register again.":
+        "This remote is unlocked. A device that returns can register again.",
+    "This remote is locked. Use the existing recovery process for devices that need to join again.":
+        "This remote is locked. Use the existing recovery process for devices that need to join again.",
+    "This remote is locked. If the device returns, use the existing recovery process to join it again.":
+        "This remote is locked. If the device returns, use the existing recovery process to join it again.",
+    "This remote does not support conditional updates, so the device record could not be removed.":
+        "This remote does not support conditional updates, so the device record could not be removed.",
+    "This remote does not currently have a record of joined devices.":
+        "This remote does not currently have a record of joined devices.",
+    "This list shows device information recorded by the remote. It does not show whether a device is online now.":
+        "This list shows device information recorded by the remote. It does not show whether a device is online now.",
+    "This device is locked out. Use the existing recovery process to join again.":
+        "This device is locked out. Use the existing recovery process to join again.",
+    "This device": "This device",
+    "This remote has been cleaned. Use the existing recovery process to join devices again as needed.":
+        "This remote has been cleaned. Use the existing recovery process to join devices again as needed.",
+    "The device record was forgotten.": "The device record was forgotten.",
+    "The device record was already absent.": "The device record was already absent.",
+    "The device list changed while you were trying to forget this device. Refresh the list before trying again.":
+        "The device list changed while you were trying to forget this device. Refresh the list before trying again.",
+    "The device information could not be loaded. Close this dialogue and open Joined devices again if the remote configuration has changed.":
+        "The device information could not be loaded. Close this dialogue and open Joined devices again if the remote configuration has changed.",
+    "Review device records for the active CouchDB or Object Storage connection.":
+        "Review device records for the active CouchDB or Object Storage connection.",
+    Refresh: "Refresh",
+    "Plug-in version": "Plug-in version",
+    Platform: "Platform",
+    "Other joined devices last reported an older plug-in version: ${versions}.":
+        "Other joined devices last reported an older plug-in version: ${versions}.",
+    "Other joined devices last reported a newer plug-in version: ${versions}.":
+        "Other joined devices last reported a newer plug-in version: ${versions}.",
+    Open: "Open",
+    "Not recorded": "Not recorded",
+    "Not accepted": "Not accepted",
+    "No joined devices are recorded on this remote.": "No joined devices are recorded on this remote.",
+    "Locked out": "Locked out",
+    "Loading joined devices…": "Loading joined devices…",
+    "Last recorded": "Last recorded",
+    "Joined devices could not be updated. Refresh the list and try again. If the remote configuration has changed, close this dialogue and open Joined devices again.":
+        "Joined devices could not be updated. Refresh the list and try again. If the remote configuration has changed, close this dialogue and open Joined devices again.",
+    "Joined devices are available after database startup with an active CouchDB or Object Storage connection.":
+        "Joined devices are available after database startup with an active CouchDB or Object Storage connection.",
+    "Joined devices": "Joined devices",
+    "Forgetting…": "Forgetting…",
+    "Forgetting the record does not delete Vault files or revoke credentials.":
+        "Forgetting the record does not delete Vault files or revoke credentials.",
+    "Forget this device record?": "Forget this device record?",
+    "Forget device": "Forget device",
+    Close: "Close",
+    Cancel: "Cancel",
+    "App version": "App version",
+    Accepted: "Accepted",
     "Preparing follow-up report…": "Preparing follow-up report…",
     "Cancelling local search. Checked ${COUNT} entries.": "Cancelling local search. Checked ${COUNT} entries.",
     "Search current Vault paths and current local Metadata only. Older history and remote-only files are not searched.":

src/common/replicatorProviders.ts

@@ -28,6 +28,8 @@ import {
     getObjectStorageReplicatorConfigurationIdentity,
 } from "./replicatorConfigurationIdentity";
 import {
+    createCouchDBJoinedDevicesResourceFactory,
+    createObjectStorageJoinedDevicesResourceFactory,
     createCouchDBConnectionProbeFactory,
     createCouchDBPreferredTweakProbeFactory,
     createCouchDBSecuritySeedResourceFactory,
@@ -115,6 +117,9 @@ export function createCentralReplicatorProviderDefinitions(
             configurationIdentity: getCouchDBReplicatorConfigurationIdentity,
             create: () => Promise.resolve(new LiveSyncCouchDBReplicator(host)),
             remoteResources: {
+                [REMOTE_RESOURCE_KINDS.JOINED_DEVICES]: supportedCapability(
+                    createCouchDBJoinedDevicesResourceFactory(host)
+                ),
                 [REMOTE_RESOURCE_KINDS.CONNECTION]: supportedCapability(createCouchDBConnectionProbeFactory(host)),
                 [REMOTE_RESOURCE_KINDS.PREFERRED_TWEAK]: supportedCapability(
                     createCouchDBPreferredTweakProbeFactory(host)
@@ -141,6 +146,9 @@ export function createCentralReplicatorProviderDefinitions(
             configurationIdentity: getObjectStorageReplicatorConfigurationIdentity,
             create: () => Promise.resolve(new LiveSyncJournalReplicator(host)),
             remoteResources: {
+                [REMOTE_RESOURCE_KINDS.JOINED_DEVICES]: supportedCapability(
+                    createObjectStorageJoinedDevicesResourceFactory(host)
+                ),
                 [REMOTE_RESOURCE_KINDS.CONNECTION]: supportedCapability(
                     createObjectStorageConnectionProbeFactory(host)
                 ),

src/common/replicatorProviders.unit.spec.ts

@@ -44,7 +44,15 @@ describe("central Replicator provider definitions", () => {
     it("keeps the retained remote-resource catalogue bounded", () => {
         expect
             .soft(Object.values(REMOTE_RESOURCE_KINDS).sort())
-            .toEqual(["connection", "preferred-tweak", "security-seed", "synchronisation-information"].sort());
+            .toEqual(
+                [
+                    "connection",
+                    "joined-devices",
+                    "preferred-tweak",
+                    "security-seed",
+                    "synchronisation-information",
+                ].sort()
+            );
     });
 
     it("lets Journal prepare its own fresh Security Seed while CouchDB uses central preparation", () => {

src/common/replicatorResources/index.ts

@@ -14,3 +14,8 @@ export {
     type SecuritySeedResourceHost,
 } from "./securitySeed";
 export { createCouchDBSynchronisationInformationResourceFactory } from "./synchronisationInformation";
+
+export {
+    createCouchDBJoinedDevicesResourceFactory,
+    createObjectStorageJoinedDevicesResourceFactory,
+} from "./joinedDevices";

src/common/replicatorResources/joinedDevices.ts

@@ -0,0 +1,40 @@
+import type { RemoteDBSettings } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import type {
+    JoinedDevicesResource,
+    JoinedDevicesResourceFactory,
+    JoinedDevicesSnapshot,
+    ForgetJoinedDeviceResult,
+} from "@vrtmrz/livesync-commonlib/replication";
+import {
+    LiveSyncCouchDBReplicator,
+    type LiveSyncCouchDBReplicatorEnv,
+} from "@vrtmrz/livesync-commonlib/compat/replication/couchdb/LiveSyncReplicator";
+import { LiveSyncJournalReplicator } from "@vrtmrz/livesync-commonlib/compat/replication/journal/LiveSyncJournalReplicator";
+import { createReplicatorDisposer, snapshotRemoteSettings, type ResourceReplicator } from "./shared";
+
+interface JoinedDevicesReplicator extends ResourceReplicator {
+    getJoinedDevices(setting: RemoteDBSettings): Promise<JoinedDevicesSnapshot>;
+    forgetJoinedDevice(setting: RemoteDBSettings, deviceId: string): Promise<ForgetJoinedDeviceResult>;
+}
+
+function createResource(replicator: JoinedDevicesReplicator, snapshot: RemoteDBSettings): JoinedDevicesResource {
+    return {
+        read: () => replicator.getJoinedDevices(snapshot),
+        forget: (deviceId) => replicator.forgetJoinedDevice(snapshot, deviceId),
+        dispose: createReplicatorDisposer(replicator),
+    };
+}
+
+export function createCouchDBJoinedDevicesResourceFactory(
+    host: LiveSyncCouchDBReplicatorEnv
+): JoinedDevicesResourceFactory {
+    return (setting) =>
+        Promise.resolve(createResource(new LiveSyncCouchDBReplicator(host), snapshotRemoteSettings(setting)));
+}
+
+export function createObjectStorageJoinedDevicesResourceFactory(
+    host: LiveSyncCouchDBReplicatorEnv
+): JoinedDevicesResourceFactory {
+    return (setting) =>
+        Promise.resolve(createResource(new LiveSyncJournalReplicator(host), snapshotRemoteSettings(setting)));
+}

src/main.ts

@@ -51,6 +51,7 @@ import { useInteractiveConflictResolutionFeature } from "./serviceFeatures/inter
 import { ConflictResolveModal } from "./modules/features/InteractiveConflictResolving/ConflictResolveModal.ts";
 import { useObsidianReplicationRibbonFeature } from "./serviceFeatures/obsidianReplicationRibbon.ts";
 import { useStartupLifecycleFeature } from "./serviceFeatures/startupLifecycle";
+import { useJoinedDevicesFeature } from "./serviceFeatures/useJoinedDevices";
 import { useDatabaseDiagnosticsFeature } from "./serviceFeatures/useDatabaseDiagnostics";
 export type LiveSyncCore = LiveSyncBaseCore<ObsidianServiceContext, LiveSyncCommands>;
 export default class ObsidianLiveSyncPlugin extends Plugin {
@@ -197,6 +198,7 @@ export default class ObsidianLiveSyncPlugin extends Plugin {
                 useP2PReplicatorUI(core, core, replicator, createInteractiveP2PReplication(replicator));
                 useObsidianReplicationRibbonFeature(core);
                 useDatabaseDiagnosticsFeature(core);
+                useJoinedDevicesFeature(core, serviceHub.context.noticeGroups);
                 useRemoteConfiguration(core);
 
                 useSetupProtocolFeature(core, setupManager);

src/modules/features/SettingDialogue/PaneRemoteConfig.ts

@@ -7,6 +7,7 @@ import {
     type ObsidianLiveSyncSettings,
     LOG_LEVEL_VERBOSE,
 } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { OPEN_JOINED_DEVICES } from "@/serviceFeatures/joinedDevicesCommand";
 import { Menu, type ButtonComponent } from "@/deps.ts";
 import { $msg } from "@/common/translation";
 import { LiveSyncSetting as Setting } from "./LiveSyncSetting.ts";
@@ -101,6 +102,22 @@ export function paneRemoteConfig(
     paneEl: HTMLElement,
     { addPanel }: PageFunctions
 ): void {
+    new Setting(paneEl)
+        .setName($msg("Joined devices"))
+        .setDesc($msg("Review device records for the active CouchDB or Object Storage connection."))
+        .addButton((button) =>
+            button.setButtonText($msg("Open")).onClick(async () => {
+                const result = await this.services.UI.commands.invoke(OPEN_JOINED_DEVICES, undefined);
+                if (result.status === "unavailable" || result.value === "unavailable") {
+                    this.services.API.addLog(
+                        $msg(
+                            "Joined devices are available after database startup with an active CouchDB or Object Storage connection."
+                        ),
+                        LOG_LEVEL_NOTICE
+                    );
+                }
+            })
+        );
     {
         /* E2EE */
         const E2EEInitialProps = {

src/modules/features/SettingDialogue/PaneRemoteConfig.unit.spec.ts

@@ -2,7 +2,7 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 
 const runtime = vi.hoisted(() => ({
     buttonClasses: [] as string[],
-    clickHandlers: [] as Array<() => Promise<void> | void>,
+    clickHandlers: [] as Array<{ setting: string; run: () => Promise<void> | void }>,
     panels: [] as Array<{ destroy: ReturnType<typeof vi.fn> }>,
     settingClasses: [] as string[],
 }));
@@ -32,7 +32,10 @@ vi.mock("./LiveSyncSetting.ts", () => ({
             },
         };
 
-        setName() {
+        settingName = "";
+
+        setName(name: string) {
+            this.settingName = name;
             return this;
         }
 
@@ -41,6 +44,7 @@ vi.mock("./LiveSyncSetting.ts", () => ({
         }
 
         addButton(callback: (button: unknown) => void) {
+            const setting = this.settingName;
             const button = {
                 buttonEl: {
                     classList: {
@@ -53,7 +57,7 @@ vi.mock("./LiveSyncSetting.ts", () => ({
                     return this;
                 },
                 onClick(callback: () => Promise<void> | void) {
-                    runtime.clickHandlers.push(callback);
+                    runtime.clickHandlers.push({ setting, run: callback });
                     return this;
                 },
                 setButtonText() {
@@ -107,6 +111,7 @@ vi.mock("./remoteConfigBuffer.ts", () => ({
     syncActivatedRemoteSettings: vi.fn(),
 }));
 
+import { OPEN_JOINED_DEVICES } from "@/serviceFeatures/joinedDevicesCommand";
 import { paneRemoteConfig } from "./PaneRemoteConfig.ts";
 
 function createPanelElement(): HTMLElement {
@@ -124,6 +129,18 @@ afterEach(() => {
 });
 
 describe("paneRemoteConfig", () => {
+    it("opens joined devices through the shared UI command", async () => {
+        const invoke = vi.fn(async () => ({ status: "handled", value: "closed" }));
+        const host = {
+            editingSettings: { remoteConfigurations: {} },
+            services: { UI: { commands: { invoke } } },
+        };
+        const addPanel = vi.fn(() => ({ then: vi.fn() }));
+        paneRemoteConfig.call(host as never, {} as HTMLElement, { addPanel } as never);
+        await runtime.clickHandlers.find((handler) => handler.setting === "Joined devices")!.run();
+        expect(invoke).toHaveBeenCalledWith(OPEN_JOINED_DEVICES, undefined);
+    });
+
     it("destroys the E2EE info panel when the settings page lifetime unloads", async () => {
         const callbacks: Array<() => unknown> = [];
         const lifetimeComponent = {
@@ -187,7 +204,7 @@ describe("paneRemoteConfig", () => {
         }));
 
         paneRemoteConfig.call(host as never, {} as HTMLElement, { addPanel } as never);
-        await runtime.clickHandlers[0]();
+        await runtime.clickHandlers.find((handler) => handler.setting === "Configure E2EE")!.run();
 
         expect(setupManager.onlyE2EEConfiguration).toHaveBeenCalledOnce();
         expect(host.editingSettings.encryptInternalMetadata).toBe(true);
@@ -233,7 +250,7 @@ describe("paneRemoteConfig", () => {
         }));
 
         paneRemoteConfig.call(host as never, {} as HTMLElement, { addPanel } as never);
-        await runtime.clickHandlers[0]();
+        await runtime.clickHandlers.find((handler) => handler.setting === "Configure E2EE")!.run();
 
         expect(host.editingSettings.idDerivationVersion).toBe(1);
         expect(host.editingSettings.idDerivationKey).toBe(nextIdKey);

src/modules/services/LiveSyncUI/dialogues/JoinedDevicesDialog.svelte

@@ -0,0 +1,391 @@
+<script lang="ts">
+    import { onDestroy, onMount } from "svelte";
+    import type { GuestDialogProps } from "@/modules/services/LiveSyncUI/svelteDialog";
+    import DialogHeader from "@/modules/services/LiveSyncUI/components/DialogHeader.svelte";
+    import { $msg as translate } from "@/common/translation";
+    import type {
+        JoinedDeviceRow,
+        JoinedDevicesDialogOptions,
+        JoinedDevicesView,
+    } from "@/serviceFeatures/joinedDevicesDialogTypes";
+
+    const { setResult, getInitialData }: GuestDialogProps<"close", JoinedDevicesDialogOptions> = $props();
+    let options = $state<JoinedDevicesDialogOptions>();
+    let view = $state<JoinedDevicesView>();
+    let isRefreshing = $state(false);
+    let confirmingId = $state<string>();
+    let forgettingId = $state<string>();
+    let statusMessage = $state("");
+    let errorMessage = $state("");
+    let disposed = false;
+    const busy = $derived(isRefreshing || forgettingId !== undefined);
+    const title = translate("Joined devices");
+
+    onMount(() => {
+        options = getInitialData?.();
+        if (!options) {
+            errorMessage = translate(
+                "The device information could not be loaded. Close this dialogue and open Joined devices again if the remote configuration has changed."
+            );
+            return;
+        }
+        void refreshView();
+    });
+
+    onDestroy(() => {
+        disposed = true;
+        options?.cancel();
+    });
+
+    async function refreshView(afterForget = false) {
+        const dialogOptions = options;
+        if (!dialogOptions || disposed || isRefreshing || (forgettingId !== undefined && !afterForget)) return;
+
+        isRefreshing = true;
+        errorMessage = "";
+        if (!afterForget) {
+            statusMessage = "";
+            confirmingId = undefined;
+        }
+        try {
+            const refreshedView = await dialogOptions.refresh();
+            if (disposed) return;
+            view = refreshedView;
+        } catch {
+            if (!disposed) {
+                errorMessage = translate(
+                    "The device information could not be loaded. Close this dialogue and open Joined devices again if the remote configuration has changed."
+                );
+            }
+        } finally {
+            if (!disposed) isRefreshing = false;
+        }
+    }
+
+    function toggleConfirmation(device: JoinedDeviceRow) {
+        if (busy || device.self) return;
+        confirmingId = confirmingId === device.id ? undefined : device.id;
+        errorMessage = "";
+        statusMessage = "";
+    }
+
+    async function forgetDevice(device: JoinedDeviceRow) {
+        const dialogOptions = options;
+        if (!dialogOptions || disposed || busy || device.self || confirmingId !== device.id) return;
+
+        forgettingId = device.id;
+        confirmingId = undefined;
+        errorMessage = "";
+        statusMessage = "";
+        try {
+            const result = await dialogOptions.forget(device.id);
+            if (disposed) return;
+
+            if (result === "forgotten") {
+                statusMessage = translate("The device record was forgotten.");
+                await refreshView(true);
+            } else if (result === "not-found") {
+                statusMessage = translate("The device record was already absent.");
+                await refreshView(true);
+            } else if (result === "conflict") {
+                errorMessage = translate(
+                    "The device list changed while you were trying to forget this device. Refresh the list before trying again."
+                );
+            } else {
+                errorMessage = translate(
+                    "This remote does not support conditional updates, so the device record could not be removed."
+                );
+            }
+        } catch {
+            if (!disposed) {
+                errorMessage = translate(
+                    "Joined devices could not be updated. Refresh the list and try again. If the remote configuration has changed, close this dialogue and open Joined devices again."
+                );
+            }
+        } finally {
+            if (!disposed) forgettingId = undefined;
+        }
+    }
+
+    function formatLastConnected(timestamp: number | undefined) {
+        if (timestamp === undefined || !Number.isFinite(timestamp) || timestamp <= 0) return translate("Not recorded");
+        const date = new Date(timestamp);
+        if (Number.isNaN(date.getTime())) return translate("Not recorded");
+        return date.toLocaleString();
+    }
+</script>
+
+<DialogHeader {title} />
+<div class="joined-devices-dialog">
+    <p>
+        {translate("This list shows device information recorded by the remote. It does not show whether a device is online now.")}
+    </p>
+
+    {#if view}
+        {#if !view.milestonePresent}
+            <p class="state-message">{translate("This remote does not currently have a record of joined devices.")}</p>
+        {/if}
+        {#if view.cleaned}
+            <p class="state-message">
+                {translate(
+                    "This remote has been cleaned. Use the existing recovery process to join devices again as needed."
+                )}
+            </p>
+        {/if}
+        {#if view.locked}
+            <p class="state-message">
+                {translate(
+                    "This remote is locked. Use the existing recovery process for devices that need to join again."
+                )}
+            </p>
+        {/if}
+    {/if}
+
+    {#if errorMessage}
+        <p class="error-message" role="alert">{errorMessage}</p>
+    {/if}
+    {#if statusMessage}
+        <p class="status-message" role="status">{statusMessage}</p>
+    {/if}
+    {#if isRefreshing && !view}
+        <p role="status">{translate("Loading joined devices…")}</p>
+    {/if}
+
+    {#if view}
+        {#if view.devices.length > 0}
+            <ul class="device-list">
+                {#each view.devices as device (device.id)}
+                    <li class="device-card">
+                        <div class="device-heading">
+                            <div class="device-identity">
+                                {#if device.self}
+                                    <span class="device-badge">{translate("This device")}</span>
+                                {/if}
+                                <code class="device-id">{device.id}</code>
+                            </div>
+                            <div class="device-badges">
+                                <span class="device-badge">
+                                    {device.accepted ? translate("Accepted") : translate("Not accepted")}
+                                </span>
+                                {#if device.lockedOut}
+                                    <span class="device-badge device-badge-warning">{translate("Locked out")}</span>
+                                {/if}
+                            </div>
+                        </div>
+
+                        {#if device.self && device.lockedOut}
+                            <p class="state-message">
+                                {translate(
+                                    "This device is locked out. Use the existing recovery process to join again."
+                                )}
+                            </p>
+                        {/if}
+
+                        <dl class="device-details">
+                            <div>
+                                <dt>{translate("Platform")}</dt>
+                                <dd>{device.platform || translate("Unknown platform")}</dd>
+                            </div>
+                            <div>
+                                <dt>{translate("Plug-in version")}</dt>
+                                <dd>{device.pluginVersion || translate("Not recorded")}</dd>
+                            </div>
+                            <div>
+                                <dt>{translate("App version")}</dt>
+                                <dd>{device.appVersion || translate("Not recorded")}</dd>
+                            </div>
+                            <div>
+                                <dt>{translate("Last recorded")}</dt>
+                                <dd>{formatLastConnected(device.lastConnected)}</dd>
+                            </div>
+                        </dl>
+
+                        {#if !device.self}
+                            {#if confirmingId === device.id}
+                                <div class="forget-confirmation">
+                                    <p><strong>{translate("Forget this device record?")}</strong></p>
+                                    <p>
+                                        {translate("This removes only this device's record from the remote.")}
+                                    </p>
+                                    <p>
+                                        {translate(
+                                            "Forgetting the record does not delete Vault files or revoke credentials."
+                                        )}
+                                    </p>
+                                    <p>
+                                        {view.locked
+                                            ? translate(
+                                                  "This remote is locked. If the device returns, use the existing recovery process to join it again."
+                                              )
+                                            : translate("This remote is unlocked. A device that returns can register again.")}
+                                    </p>
+                                    <div class="device-actions">
+                                        <button disabled={busy} onclick={() => toggleConfirmation(device)}>
+                                            {translate("Cancel")}
+                                        </button>
+                                        <button
+                                            class="mod-warning"
+                                            disabled={busy}
+                                            onclick={() => void forgetDevice(device)}
+                                        >
+                                            {translate("Forget device")}
+                                        </button>
+                                    </div>
+                                </div>
+                            {:else}
+                                <div class="device-actions">
+                                    <button disabled={busy} onclick={() => toggleConfirmation(device)}>
+                                        {forgettingId === device.id
+                                            ? translate("Forgetting…")
+                                            : translate("Forget device")}
+                                    </button>
+                                </div>
+                            {/if}
+                        {/if}
+                    </li>
+                {/each}
+            </ul>
+        {:else if !isRefreshing}
+            <p>{translate("No joined devices are recorded on this remote.")}</p>
+        {/if}
+    {/if}
+
+    <div class="dialog-controls">
+        <button disabled={busy} onclick={() => void refreshView()}>{translate("Refresh")}</button>
+        <button onclick={() => setResult("close")}>{translate("Close")}</button>
+    </div>
+</div>
+
+<style>
+    .joined-devices-dialog {
+        display: flex;
+        flex-direction: column;
+        gap: var(--size-4-2);
+        min-width: 0;
+        max-width: 100%;
+    }
+
+    p {
+        margin: 0;
+        overflow-wrap: anywhere;
+    }
+
+    .state-message,
+    .forget-confirmation {
+        border-left: 3px solid var(--interactive-accent);
+        padding: var(--size-4-2);
+        background: var(--background-secondary);
+    }
+
+    .error-message {
+        color: var(--text-error);
+    }
+
+    .device-list {
+        display: grid;
+        gap: var(--size-4-2);
+        list-style: none;
+        margin: 0;
+        min-width: 0;
+        padding: 0;
+    }
+
+    .device-card {
+        display: flex;
+        flex-direction: column;
+        gap: var(--size-4-2);
+        min-width: 0;
+        overflow-wrap: anywhere;
+        border: 1px solid var(--background-modifier-border);
+        border-radius: var(--radius-m);
+        padding: var(--size-4-3);
+    }
+
+    .device-heading {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: flex-start;
+        justify-content: space-between;
+        gap: var(--size-4-2);
+        min-width: 0;
+    }
+
+    .device-identity,
+    .device-badges {
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: var(--size-4-2);
+        min-width: 0;
+    }
+
+    .device-id {
+        display: block;
+        min-width: 0;
+        max-width: 100%;
+        overflow-wrap: anywhere;
+        white-space: normal;
+    }
+
+    .device-badge {
+        border-radius: var(--radius-s);
+        background: var(--background-secondary);
+        padding: 0 var(--size-4-2);
+        font-size: var(--font-ui-smaller);
+    }
+
+    .device-badge-warning {
+        color: var(--text-warning);
+    }
+
+    .device-details {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(min(100%, 13rem), 1fr));
+        gap: var(--size-4-2) var(--size-4-4);
+        margin: 0;
+        min-width: 0;
+    }
+
+    .device-details > div {
+        min-width: 0;
+    }
+
+    dt {
+        color: var(--text-muted);
+        font-size: var(--font-ui-smaller);
+    }
+
+    dd {
+        margin: 0;
+        overflow-wrap: anywhere;
+    }
+
+    .forget-confirmation {
+        display: flex;
+        flex-direction: column;
+        gap: var(--size-4-2);
+        min-width: 0;
+    }
+
+    .device-actions,
+    .dialog-controls {
+        display: flex;
+        flex-wrap: wrap;
+        justify-content: flex-end;
+        gap: var(--size-4-2);
+    }
+
+    button {
+        min-height: 44px;
+    }
+
+    @media (max-width: 480px) {
+        .device-card {
+            padding: var(--size-4-2);
+        }
+
+        .device-details {
+            grid-template-columns: minmax(0, 1fr);
+        }
+    }
+</style>

src/serviceFeatures/joinedDevices.ts

@@ -0,0 +1,64 @@
+import type { JoinedDevice, JoinedDevicesSnapshot } from "@vrtmrz/livesync-commonlib/replication";
+import type { JoinedDevicesView } from "./joinedDevicesDialogTypes";
+
+/** Compare recognised SemVer values; unknown development labels have no ordering. */
+export function comparePluginVersions(left: string, right: string): number | undefined {
+    const parse = (value: string) => {
+        const match =
+            /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(
+                value
+            );
+        if (!match) return undefined;
+        const prerelease = match[4]?.split(".");
+        if (prerelease?.some((part) => /^0\d+$/.test(part))) return undefined;
+        return { core: match.slice(1, 4).map(BigInt), prerelease };
+    };
+    const a = parse(left);
+    const b = parse(right);
+    if (!a || !b) return undefined;
+    for (let i = 0; i < 3; i++) {
+        if (a.core[i] !== b.core[i]) return a.core[i] > b.core[i] ? 1 : -1;
+    }
+    if (!a.prerelease || !b.prerelease) return a.prerelease ? -1 : b.prerelease ? 1 : 0;
+    for (let i = 0; i < Math.max(a.prerelease.length, b.prerelease.length); i++) {
+        const x = a.prerelease[i];
+        const y = b.prerelease[i];
+        if (x === undefined) return -1;
+        if (y === undefined) return 1;
+        if (x === y) continue;
+        const xn = /^\d+$/.test(x);
+        const yn = /^\d+$/.test(y);
+        if (xn && yn) return BigInt(x) > BigInt(y) ? 1 : -1;
+        if (xn !== yn) return xn ? -1 : 1;
+        return x > y ? 1 : -1;
+    }
+    return 0;
+}
+
+export function joinedDevicesView(
+    snapshot: JoinedDevicesSnapshot,
+    self: Omit<JoinedDevice, "accepted">
+): JoinedDevicesView {
+    const ownRecord = snapshot.devices.find((device) => device.id === self.id);
+    const ownDevice: JoinedDevice = { ...ownRecord, ...self, accepted: ownRecord?.accepted ?? false };
+    return {
+        ...snapshot,
+        devices: [ownDevice, ...snapshot.devices.filter((device) => device.id !== self.id)].map((device) => ({
+            ...device,
+            self: device.id === self.id,
+            lockedOut: snapshot.locked && !device.accepted,
+        })),
+    };
+}
+
+export function differentDeviceVersions(snapshot: JoinedDevicesSnapshot, ownId: string, ownVersion: string) {
+    const newer = new Set<string>();
+    const older = new Set<string>();
+    for (const device of snapshot.devices) {
+        if (device.id === ownId || !device.pluginVersion) continue;
+        const comparison = comparePluginVersions(device.pluginVersion, ownVersion);
+        if (comparison !== undefined && comparison > 0) newer.add(device.pluginVersion);
+        if (comparison !== undefined && comparison < 0) older.add(device.pluginVersion);
+    }
+    return { newer: [...newer].sort(), older: [...older].sort() };
+}

src/serviceFeatures/joinedDevices.unit.spec.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { comparePluginVersions, differentDeviceVersions, joinedDevicesView } from "./joinedDevices";
+import type { JoinedDevicesSnapshot } from "@vrtmrz/livesync-commonlib/replication";
+
+const empty: JoinedDevicesSnapshot = { milestonePresent: false, locked: false, cleaned: false, devices: [] };
+
+describe("joined device presentation", () => {
+    it("always shows this device first, including before its remote record exists", () => {
+        const view = joinedDevicesView(
+            { ...empty, devices: [{ id: "another", accepted: true }] },
+            { id: "self", platform: "ios", pluginVersion: "1.0.39" }
+        );
+        expect(view.devices.map((device) => device.id)).toEqual(["self", "another"]);
+        expect(view.devices[0]).toMatchObject({ self: true, accepted: false, lockedOut: false, platform: "ios" });
+    });
+    it("keeps the remote last-recorded date and acceptance while showing current local versions", () => {
+        const view = joinedDevicesView(
+            {
+                ...empty,
+                milestonePresent: true,
+                locked: true,
+                devices: [
+                    { id: "other", accepted: true },
+                    { id: "self", accepted: false, lastConnected: 123, pluginVersion: "1.0.0" },
+                ],
+            },
+            { id: "self", pluginVersion: "1.1.0" }
+        );
+        expect(view.devices[0]).toMatchObject({
+            self: true,
+            lockedOut: true,
+            lastConnected: 123,
+            pluginVersion: "1.1.0",
+        });
+        expect(view.devices[1].lockedOut).toBe(false);
+    });
+});
+
+describe("version advisories", () => {
+    it.each([
+        ["1.10.0", "1.9.9", 1],
+        ["1.0.0", "1.0.0-rc.1", 1],
+        ["1.0.0-beta.2", "1.0.0-beta.10", -1],
+        ["1.0.0-1", "1.0.0-alpha", -1],
+        ["1.0.0-alpha", "1.0.0-alpha.1", -1],
+        ["1.0.0+first", "1.0.0+second", 0],
+        ["99999999999999999.0.0", "99999999999999998.0.0", 1],
+    ])("compares %s with %s", (a, b, result) => expect(comparePluginVersions(a, b)).toBe(result));
+    it.each(["", "development", "1.0", "01.0.0", "1.0.0-01", "v1.0.0"])(
+        "does not order unknown version %s",
+        (version) => {
+            expect(comparePluginVersions(version, "1.0.0")).toBeUndefined();
+            expect(comparePluginVersions("1.0.0", version)).toBeUndefined();
+        }
+    );
+    it("excludes this device and unknown versions, and deduplicates versions", () => {
+        const snapshot = {
+            ...empty,
+            devices: [
+                { id: "self", accepted: false, pluginVersion: "9.0.0" },
+                { id: "a", accepted: true, pluginVersion: "2.0.0" },
+                { id: "b", accepted: false, pluginVersion: "2.0.0" },
+                { id: "c", accepted: false, pluginVersion: "0.9.0" },
+                { id: "d", accepted: true, pluginVersion: "custom" },
+            ],
+        };
+        expect(differentDeviceVersions(snapshot, "self", "1.0.0")).toEqual({ newer: ["2.0.0"], older: ["0.9.0"] });
+    });
+});

src/serviceFeatures/joinedDevicesCommand.ts

@@ -0,0 +1,5 @@
+import { declareUICommand } from "@vrtmrz/livesync-commonlib/ui-commands";
+
+export const OPEN_JOINED_DEVICES = declareUICommand<void, "closed" | "already-open" | "unavailable">(
+    "livesync:joined-devices"
+);

src/serviceFeatures/joinedDevicesDialogTypes.ts

@@ -0,0 +1,19 @@
+import type { ForgetJoinedDeviceResult, JoinedDevice } from "@vrtmrz/livesync-commonlib/replication";
+
+export interface JoinedDeviceRow extends JoinedDevice {
+    readonly self: boolean;
+    readonly lockedOut: boolean;
+}
+
+export interface JoinedDevicesView {
+    readonly milestonePresent: boolean;
+    readonly locked: boolean;
+    readonly cleaned: boolean;
+    readonly devices: readonly JoinedDeviceRow[];
+}
+
+export interface JoinedDevicesDialogOptions {
+    refresh(): Promise<JoinedDevicesView>;
+    forget(id: string): Promise<ForgetJoinedDeviceResult>;
+    cancel(): void;
+}

src/serviceFeatures/useJoinedDevices.ts

@@ -0,0 +1,212 @@
+import type { NecessaryServices } from "@vrtmrz/livesync-commonlib/compat/interfaces/ServiceModule";
+import {
+    NODEINFO_DOCID,
+    REMOTE_COUCHDB,
+    REMOTE_MINIO,
+    type EntryNodeInfo,
+    type RemoteDBSettings,
+} from "@vrtmrz/livesync-commonlib/compat/common/types";
+import { REMOTE_RESOURCE_KINDS, type JoinedDevicesSnapshot } from "@vrtmrz/livesync-commonlib/replication";
+import type { ObsidianNoticeGroups } from "@/modules/services/ObsidianNoticeGroups";
+import JoinedDevicesDialog from "@/modules/services/LiveSyncUI/dialogues/JoinedDevicesDialog.svelte";
+import {
+    getCouchDBReplicatorConfigurationIdentity,
+    getObjectStorageReplicatorConfigurationIdentity,
+} from "@/common/replicatorConfigurationIdentity";
+import { $msg } from "@/common/translation";
+import { OPEN_JOINED_DEVICES } from "./joinedDevicesCommand";
+import { differentDeviceVersions, joinedDevicesView } from "./joinedDevices";
+import type { JoinedDevicesDialogOptions } from "./joinedDevicesDialogTypes";
+
+type JoinedDevicesHost = NecessaryServices<
+    "API" | "UI" | "setting" | "database" | "replicator" | "replication" | "appLifecycle",
+    never
+>;
+const noticeGroup = "joined-device-versions";
+
+function remoteIdentity(settings: RemoteDBSettings): string | undefined {
+    if (settings.remoteType === REMOTE_COUCHDB && settings.couchDB_URI && settings.couchDB_DBNAME) {
+        return getCouchDBReplicatorConfigurationIdentity(settings);
+    }
+    if (settings.remoteType === REMOTE_MINIO && settings.endpoint && settings.bucket) {
+        return getObjectStorageReplicatorConfigurationIdentity(settings);
+    }
+    return undefined;
+}
+
+/** Own the dialogue, advisory Notices, and their per-session state for one host. */
+export function useJoinedDevicesFeature(host: JoinedDevicesHost, notices: ObsidianNoticeGroups): void {
+    const { services } = host;
+    let disposed = false;
+    let active: AbortController | undefined;
+    let checking = false;
+    let lastCheck: { identity: string; at: number } | undefined;
+    const notified = new Map<string, Set<string>>();
+    const available = () =>
+        !disposed &&
+        services.database.isDatabaseReady() &&
+        remoteIdentity(services.setting.currentSettings()) !== undefined;
+
+    const notify = (snapshot: JoinedDevicesSnapshot, ownId: string, identity: string) => {
+        if (disposed || identity !== remoteIdentity(services.setting.currentSettings())) return;
+        const version = services.API.getPluginVersion();
+        const differences = differentDeviceVersions(snapshot, ownId, version);
+        const seen = notified.get(identity) ?? new Set<string>();
+        notified.set(identity, seen);
+        for (const direction of ["newer", "older"] as const) {
+            const versions = differences[direction];
+            if (versions.length === 0) continue;
+            const key = JSON.stringify([version, direction, versions]);
+            if (seen.has(key)) continue;
+            seen.add(key);
+            notices.setItem(noticeGroup, direction, {
+                message:
+                    direction === "newer"
+                        ? $msg("Other joined devices last reported a newer plug-in version: ${versions}.", {
+                              versions: versions.join(", "),
+                          })
+                        : $msg("Other joined devices last reported an older plug-in version: ${versions}.", {
+                              versions: versions.join(", "),
+                          }),
+                action: {
+                    label: $msg("Joined devices"),
+                    onSelect: () => {
+                        if (!disposed && identity === remoteIdentity(services.setting.currentSettings())) {
+                            void services.UI.commands.invoke(OPEN_JOINED_DEVICES, undefined);
+                        }
+                    },
+                },
+            });
+            notices.finish(noticeGroup, { durationMs: 15000 });
+        }
+    };
+
+    const createOperations = (controller: AbortController): JoinedDevicesDialogOptions => {
+        const settings = { ...services.setting.currentSettings() };
+        const identity = remoteIdentity(settings);
+        const database = services.database.localDatabase;
+        const assertCurrent = () => {
+            if (
+                disposed ||
+                controller.signal.aborted ||
+                !identity ||
+                identity !== remoteIdentity(services.setting.currentSettings()) ||
+                !services.database.isDatabaseReady() ||
+                services.database.localDatabase !== database
+            ) {
+                throw new Error("Joined devices are no longer available for this dialogue");
+            }
+        };
+        const ownId = async () => {
+            assertCurrent();
+            const info = await database.localDatabase.get<EntryNodeInfo>(NODEINFO_DOCID);
+            assertCurrent();
+            if (typeof info.nodeid !== "string" || !info.nodeid) throw new Error("Device identity is unavailable");
+            return info.nodeid;
+        };
+        return {
+            refresh: async () => {
+                const id = await ownId();
+                const resource = await services.replicator.createRemoteResource(
+                    REMOTE_RESOURCE_KINDS.JOINED_DEVICES,
+                    settings
+                );
+                if (!resource) throw new Error("Joined devices are unavailable");
+                try {
+                    assertCurrent();
+                    const snapshot = await resource.read();
+                    assertCurrent();
+                    notify(snapshot, id, identity!);
+                    return joinedDevicesView(snapshot, {
+                        id,
+                        platform: services.API.getPlatform(),
+                        pluginVersion: services.API.getPluginVersion(),
+                        appVersion: services.API.getAppVersion(),
+                    });
+                } finally {
+                    await resource.dispose();
+                }
+            },
+            forget: async (id) => {
+                if (id === (await ownId())) throw new Error("This device cannot be forgotten");
+                const resource = await services.replicator.createRemoteResource(
+                    REMOTE_RESOURCE_KINDS.JOINED_DEVICES,
+                    settings
+                );
+                if (!resource) throw new Error("Joined devices are unavailable");
+                try {
+                    assertCurrent();
+                    const result = await resource.forget(id);
+                    assertCurrent();
+                    return result;
+                } finally {
+                    await resource.dispose();
+                }
+            },
+            cancel: () => controller.abort(),
+        };
+    };
+
+    const unregister = services.UI.commands.register(OPEN_JOINED_DEVICES, async () => {
+        if (!available()) return "unavailable";
+        if (active) return "already-open";
+        const controller = new AbortController();
+        active = controller;
+        try {
+            await services.UI.dialogManager.open<"close", JoinedDevicesDialogOptions>(
+                JoinedDevicesDialog,
+                createOperations(controller)
+            );
+        } catch {
+            // The host may close its dialogues during unload.
+        } finally {
+            controller.abort();
+            if (active === controller) active = undefined;
+        }
+        return "closed";
+    });
+
+    const checkVersions = () => {
+        if (!available() || checking) return;
+        const identity = remoteIdentity(services.setting.currentSettings())!;
+        if (lastCheck?.identity === identity && Date.now() - lastCheck.at < 60000) return;
+        lastCheck = { identity, at: Date.now() };
+        checking = true;
+        const controller = new AbortController();
+        void Promise.resolve()
+            .then(() => createOperations(controller).refresh())
+            .catch(() => {
+                // Advisory inspection never changes the outcome of synchronisation.
+            })
+            .finally(() => {
+                controller.abort();
+                checking = false;
+            });
+    };
+    const stopBeforeReplicate = services.replication.onBeforeReplicate.addHandler(() => {
+        checkVersions();
+        return Promise.resolve(true);
+    });
+    services.appLifecycle.onInitialise.addHandler(() => {
+        services.API.addCommand({
+            id: "joined-devices",
+            name: $msg("Joined devices"),
+            icon: "monitor-smartphone",
+            checkCallback: (checking) => {
+                if (!available()) return false;
+                if (!checking) void services.UI.commands.invoke(OPEN_JOINED_DEVICES, undefined);
+                return true;
+            },
+        });
+        return Promise.resolve(true);
+    });
+    services.appLifecycle.onUnload.addHandler(() => {
+        disposed = true;
+        active?.abort();
+        unregister();
+        stopBeforeReplicate();
+        notices.hide(noticeGroup);
+        notified.clear();
+        return Promise.resolve(true);
+    });
+}

src/serviceFeatures/useJoinedDevices.unit.spec.ts

@@ -0,0 +1,174 @@
+import { describe, expect, it, vi } from "vitest";
+import { UICommandRegistry } from "@vrtmrz/livesync-commonlib/ui-commands";
+import { createNewVaultSettings } from "@vrtmrz/livesync-commonlib/settings";
+import { REMOTE_COUCHDB } from "@vrtmrz/livesync-commonlib/compat/common/types";
+import type { JoinedDevicesSnapshot } from "@vrtmrz/livesync-commonlib/replication";
+import type { JoinedDevicesDialogOptions } from "./joinedDevicesDialogTypes";
+vi.mock("@/modules/services/LiveSyncUI/dialogues/JoinedDevicesDialog.svelte", () => ({ default: {} }));
+vi.mock("@/common/translation", () => ({ $msg: (message: string) => message }));
+import { useJoinedDevicesFeature } from "./useJoinedDevices";
+import { OPEN_JOINED_DEVICES } from "./joinedDevicesCommand";
+
+function fixture() {
+    const settings = {
+        ...createNewVaultSettings(),
+        remoteType: REMOTE_COUCHDB,
+        couchDB_URI: "https://example.test",
+        couchDB_DBNAME: "vault",
+    };
+    const initialise: Array<() => Promise<boolean>> = [];
+    const unload: Array<() => Promise<boolean>> = [];
+    const before: Array<() => Promise<boolean>> = [];
+    const stopBefore = vi.fn();
+    const commands = new UICommandRegistry();
+    const read = vi.fn<() => Promise<JoinedDevicesSnapshot>>(async () => ({
+        milestonePresent: true,
+        locked: false,
+        cleaned: false,
+        devices: [{ id: "other", accepted: true, pluginVersion: "2.0.0" }],
+    }));
+    const forget = vi.fn(async (_id: string) => "forgotten" as const);
+    const dispose = vi.fn(async () => {});
+    const createResource = vi.fn(async () => ({ read, forget, dispose }));
+    let close!: () => void;
+    const dialog = vi.fn(
+        (_component: unknown, _options: JoinedDevicesDialogOptions) =>
+            new Promise<void>((resolve) => {
+                close = resolve;
+            })
+    );
+    const notices = { setItem: vi.fn(), finish: vi.fn(), hide: vi.fn() };
+    const palette: Array<{ id: string; checkCallback: (checking: boolean) => boolean }> = [];
+    const database = { localDatabase: { get: vi.fn(async () => ({ nodeid: "self" })) } };
+    const host = {
+        services: {
+            API: {
+                getPluginVersion: () => "1.0.0",
+                getAppVersion: () => "1.9.0",
+                getPlatform: () => "desktop",
+                addCommand: (command: (typeof palette)[number]) => palette.push(command),
+            },
+            UI: { commands, dialogManager: { open: dialog } },
+            setting: { currentSettings: () => settings },
+            database: { isDatabaseReady: () => true, localDatabase: database },
+            replicator: { createRemoteResource: createResource },
+            replication: {
+                onBeforeReplicate: {
+                    addHandler: (handler: (typeof before)[number]) => {
+                        before.push(handler);
+                        return stopBefore;
+                    },
+                },
+            },
+            appLifecycle: {
+                onInitialise: { addHandler: (handler: (typeof initialise)[number]) => initialise.push(handler) },
+                onUnload: { addHandler: (handler: (typeof unload)[number]) => unload.push(handler) },
+            },
+        },
+        serviceModules: {},
+    } as unknown as Parameters<typeof useJoinedDevicesFeature>[0];
+    useJoinedDevicesFeature(host, notices as unknown as Parameters<typeof useJoinedDevicesFeature>[1]);
+    return {
+        settings,
+        initialise,
+        unload,
+        before,
+        stopBefore,
+        commands,
+        read,
+        forget,
+        dispose,
+        createResource,
+        dialog,
+        notices,
+        palette,
+        database,
+        close: () => close(),
+    };
+}
+
+async function open(data: ReturnType<typeof fixture>) {
+    const pending = data.commands.invoke(OPEN_JOINED_DEVICES, undefined);
+    const options = data.dialog.mock.calls[0][1];
+    return { options, pending };
+}
+
+describe("joined devices service feature", () => {
+    it("opens one dialogue through the command and disposes each completed read", async () => {
+        const data = fixture();
+        const { options, pending } = await open(data);
+        expect(await data.commands.invoke(OPEN_JOINED_DEVICES, undefined)).toEqual({
+            status: "handled",
+            value: "already-open",
+        });
+        expect((await options.refresh()).devices[0]).toMatchObject({ id: "self", self: true });
+        expect(data.dispose).toHaveBeenCalledTimes(1);
+        data.close();
+        expect(await pending).toEqual({ status: "handled", value: "closed" });
+        await expect(options.refresh()).rejects.toThrow();
+    });
+    it("prevents self removal and fences an old dialogue after a remote switch", async () => {
+        const data = fixture();
+        const { options, pending } = await open(data);
+        await expect(options.forget("self")).rejects.toThrow();
+        data.settings.couchDB_DBNAME = "new-vault";
+        await expect(options.forget("other")).rejects.toThrow();
+        expect(data.forget).not.toHaveBeenCalled();
+        expect(data.createResource).not.toHaveBeenCalled();
+        data.close();
+        await pending;
+    });
+    it("discards a stale read, releases the resource, and emits no stale Notice", async () => {
+        const data = fixture();
+        let resolve!: (value: JoinedDevicesSnapshot) => void;
+        data.read.mockReturnValueOnce(
+            new Promise((done) => {
+                resolve = done;
+            })
+        );
+        const { options, pending } = await open(data);
+        const reading = options.refresh();
+        await vi.waitFor(() => expect(data.read).toHaveBeenCalled());
+        data.settings.couchDB_DBNAME = "new-vault";
+        resolve({ milestonePresent: true, locked: false, cleaned: false, devices: [] });
+        await expect(reading).rejects.toThrow();
+        expect(data.dispose).toHaveBeenCalledOnce();
+        expect(data.notices.setItem).not.toHaveBeenCalled();
+        data.close();
+        await pending;
+    });
+    it("deduplicates advisory Notices and fences their actions after configuration changes", async () => {
+        const data = fixture();
+        const { options, pending } = await open(data);
+        await options.refresh();
+        await options.refresh();
+        expect(data.notices.setItem).toHaveBeenCalledTimes(1);
+        const action = data.notices.setItem.mock.calls[0][2].action;
+        data.close();
+        await pending;
+        data.settings.couchDB_DBNAME = "new-vault";
+        action.onSelect();
+        expect(data.dialog).toHaveBeenCalledTimes(1);
+    });
+    it("keeps inspection failures out of the replication result and unregisters on unload", async () => {
+        const data = fixture();
+        data.read.mockRejectedValue(new Error("unavailable"));
+        expect(await data.before[0]()).toBe(true);
+        await vi.waitFor(() => expect(data.dispose).toHaveBeenCalledOnce());
+        expect(await data.before[0]()).toBe(true);
+        expect(data.read).toHaveBeenCalledTimes(1);
+        for (const unload of data.unload) await unload();
+        expect(await data.commands.invoke(OPEN_JOINED_DEVICES, undefined)).toEqual({ status: "unavailable" });
+        expect(data.stopBefore).toHaveBeenCalledOnce();
+        expect(data.notices.hide).toHaveBeenCalled();
+    });
+    it("uses the same UI command from the command palette", async () => {
+        const data = fixture();
+        for (const initialise of data.initialise) await initialise();
+        expect(data.palette[0].checkCallback(true)).toBe(true);
+        expect(data.dialog).not.toHaveBeenCalled();
+        data.palette[0].checkCallback(false);
+        expect(data.dialog).toHaveBeenCalledOnce();
+        data.close();
+    });
+});