yaver-feedback-react-native 0.7.0 → 0.7.1

package/src/Discovery.ts

@@ -20,9 +20,17 @@ function getAsyncStorage(): AsyncStorageLike | null {
   }
 }
 
+import type { RemoteDevice } from './auth';
+import {
+  collapseRemoteDevices,
+  pickTargetDevice,
+  HEARTBEAT_STALE_MS,
+} from './deviceDedup';
+
 const STORAGE_KEY = 'yaver_feedback_agent';
 const DEFAULT_PORT = 18080;
-const TIMEOUT_MS = 2000;
+const PROBE_TIMEOUT_MS = 2500;
+const RELAY_PROBE_TIMEOUT_MS = 6000;
 
 export interface DiscoveryResult {
   url: string;
@@ -31,29 +39,43 @@ export interface DiscoveryResult {
   latency: number;
 }
 
-// Common LAN subnets and host suffixes to scan
-const SUBNETS = ['192.168.1', '192.168.0', '10.0.0', '10.0.1'];
-const HOST_SUFFIXES = [1, 2, 50, 100, 101, 200];
+// LAN fallback sweep used ONLY when Convex lookup fails AND the stored
+// cache probe fails. Keep tight — covers 192.168.1/0.x and 10.0.0/1.x
+// with a handful of common host suffixes. The primary path is always
+// Convex.
+const LAN_SUBNETS = ['192.168.1', '192.168.0', '10.0.0', '10.0.1'];
+const LAN_HOST_SUFFIXES = [1, 2, 50, 100, 101, 200];
 
 /**
- * Device discovery for finding Yaver agents on the local network or via Convex.
+ * Device discovery for finding Yaver agents.
+ *
+ * **Convex is the primary source of truth.** The user's Convex account
+ * has the freshest IP / port for each registered agent, updated every
+ * 2 minutes via heartbeat. The SDK should therefore:
+ *   1. On every `discover()` call, re-query Convex for the latest IP
+ *      (no local cache shortcut when `convexUrl` + `authToken` are
+ *      available).
+ *   2. Dedup the returned list (Convex can carry stale rows after
+ *      re-pair) and pick the freshest online machine.
+ *   3. Probe the machine's `quicHost:httpPort` directly.
+ *   4. If the direct probe fails (different LAN / roaming), route
+ *      through the configured relay.
+ *   5. Store the successful URL only AFTER the probe confirms it's
+ *      reachable. Stored cache is used only as a last-chance shortcut
+ *      when Convex itself is unreachable.
  *
- * Three discovery strategies (tried in order):
- * 1. **Convex cloud** — fetch agent IP from Convex `/devices/list` (for cloud machines)
- * 2. **Stored connection** — try cached URL from last successful connection
- * 3. **LAN scan** — probe common LAN IPs via `/health` endpoint
+ * Compared to the previous implementation this removes the "trust
+ * stored URL first" shortcut that caused the SDK to keep trying a dead
+ * cached IP long after the Mac's IP rotated.
  */
 export class YaverDiscovery {
-  /**
-   * Discover an agent. Tries Convex cloud first (if configured),
-   * then stored connection, then LAN scan.
-   */
   static async discover(options?: {
     convexUrl?: string;
     authToken?: string;
     preferredDeviceId?: string;
   }): Promise<DiscoveryResult | null> {
-    // Strategy 1: Convex cloud discovery (for cloud machines)
+    // Strategy 1: Convex — always tried first when credentials are
+    // available. No cache shortcut.
     if (options?.convexUrl && options?.authToken) {
       const result = await YaverDiscovery.discoverFromConvex(
         options.convexUrl,
@@ -66,41 +88,60 @@ export class YaverDiscovery {
       }
     }
 
-    // Strategy 2: Try stored connection
+    // Strategy 2: Stored URL. Only used as a fallback when Convex was
+    // unreachable. A successful probe here means either the mobile is
+    // offline or Convex is — we'll trust the stored IP.
     const stored = await YaverDiscovery.getStored();
     if (stored) {
       const result = await YaverDiscovery.probe(stored.url);
-      if (result) {
-        return result;
-      }
+      if (result) return result;
       await YaverDiscovery.clear();
     }
 
-    // Strategy 3: Scan common LAN IPs in parallel
+    // Strategy 3: LAN fallback. Small sweep of common subnets. This is
+    // only hit when the user has no Convex session (device-local mode)
+    // or both Convex + cache lookups failed.
     const candidates: string[] = [];
-    for (const subnet of SUBNETS) {
-      for (const suffix of HOST_SUFFIXES) {
+    for (const subnet of LAN_SUBNETS) {
+      for (const suffix of LAN_HOST_SUFFIXES) {
         candidates.push(`http://${subnet}.${suffix}:${DEFAULT_PORT}`);
       }
     }
-
     const results = await Promise.allSettled(
       candidates.map((url) => YaverDiscovery.probe(url)),
     );
-
     for (const r of results) {
       if (r.status === 'fulfilled' && r.value) {
         await YaverDiscovery.store(r.value);
         return r.value;
       }
     }
-
     return null;
   }
 
   /**
-   * Fetch the agent URL from Convex device list or cloud machines.
-   * No hardcoded IPs needed — Convex knows where the agent is.
+   * Re-query Convex ignoring any cached URL. Intended for the call
+   * site right after a probe/network failure — it's the "the IP
+   * probably changed, ask the source of truth again" path.
+   */
+  static async refreshFromConvex(options: {
+    convexUrl: string;
+    authToken: string;
+    preferredDeviceId?: string;
+  }): Promise<DiscoveryResult | null> {
+    await YaverDiscovery.clear();
+    const result = await YaverDiscovery.discoverFromConvex(
+      options.convexUrl,
+      options.authToken,
+      options.preferredDeviceId,
+    );
+    if (result) await YaverDiscovery.store(result);
+    return result;
+  }
+
+  /**
+   * Fetch the agent URL from Convex. Dedups rows, prefers fresh ones,
+   * falls back to relay if the direct LAN IP isn't reachable.
    */
   static async discoverFromConvex(
     convexUrl: string,
@@ -108,17 +149,17 @@ export class YaverDiscovery {
     preferredDeviceId?: string,
   ): Promise<DiscoveryResult | null> {
     const base = convexUrl.replace(/\/$/, '');
-
     try {
-      // Try cloud machines first (CPU/GPU managed machines)
+      // Try cloud machines first (CPU/GPU managed machines). These are
+      // long-lived with stable IPs so the direct probe is cheap.
       const machinesRes = await fetch(`${base}/machines`, {
         headers: { Authorization: `Bearer ${authToken}` },
       });
-
       if (machinesRes.ok) {
         const { machines } = await machinesRes.json();
         const activeMachine = (machines ?? []).find(
-          (m: { status: string; serverIp?: string }) => m.status === 'active' && m.serverIp,
+          (m: { status: string; serverIp?: string }) =>
+            m.status === 'active' && m.serverIp,
         );
         if (activeMachine?.serverIp) {
           const url = `http://${activeMachine.serverIp}:${DEFAULT_PORT}`;
@@ -127,31 +168,78 @@ export class YaverDiscovery {
         }
       }
 
-      // Fall back to device list (personal machines registered with Convex)
+      // Fall back to personal devices registered in Convex.
       const devicesRes = await fetch(`${base}/devices/list`, {
         headers: { Authorization: `Bearer ${authToken}` },
       });
-
       if (!devicesRes.ok) return null;
       const data = await devicesRes.json();
-      const devices = data.devices ?? data ?? [];
-
-      // Find preferred device or first online one
-      const target = preferredDeviceId
-        ? devices.find((d: { deviceId: string }) => d.deviceId === preferredDeviceId)
-        : devices.find((d: { isOnline: boolean }) => d.isOnline);
+      const rawList = Array.isArray(data?.devices) ? data.devices : data;
+      if (!Array.isArray(rawList) || rawList.length === 0) return null;
+
+      // Normalise Convex fields → RemoteDevice shape so dedup works the
+      // same way `listReachableDevices` does it.
+      const normalised: RemoteDevice[] = rawList.map((d: any) => ({
+        deviceId: d.deviceId ?? d.id,
+        name: d.name ?? '',
+        platform: d.platform ?? d.os ?? '',
+        isOnline: !!d.isOnline,
+        needsAuth: !!d.needsAuth,
+        runnerDown: !!d.runnerDown,
+        lastHeartbeat: d.lastHeartbeat ?? 0,
+        isGuest: !!d.isGuest,
+        hostName: d.hostName,
+        hostEmail: d.hostEmail,
+        accessScope: d.accessScope ?? 'owner',
+        quicHost: d.quicHost ?? d.host ?? '',
+        quicPort: d.quicPort ?? 0,
+        httpPort: d.httpPort ?? d.quicPort,
+        publicKey: d.publicKey,
+        hwid: d.hardwareId ?? d.hwid,
+        localIps: Array.isArray(d.localIps)
+          ? d.localIps
+          : Array.isArray(d.lanIps)
+            ? d.lanIps
+            : undefined,
+      }));
+
+      const deduped = collapseRemoteDevices(normalised);
+      const target = pickTargetDevice(deduped, preferredDeviceId);
+      if (!target) return null;
+
+      // Build the same candidate set the Yaver mobile app races on: the
+      // primary `quicHost` plus every LAN IP reported in the latest
+      // heartbeat (`localIps`). Multi-homed hosts commonly advertise
+      // en0 + utun (tailscale) + docker0 etc.; probing all of them in
+      // parallel makes the SDK "just work" on the same Wi-Fi without
+      // depending on which NIC the user's router DHCP'd them from.
+      const port = target.httpPort ?? target.quicPort ?? DEFAULT_PORT;
+      const ipSet = new Set<string>();
+      if (target.quicHost) ipSet.add(target.quicHost);
+      for (const ip of target.localIps ?? []) {
+        if (ip) ipSet.add(ip);
+      }
+      const candidates = Array.from(ipSet).map(
+        (ip) => `http://${ip}:${port}`,
+      );
 
-      if (!target?.quicHost) return null;
+      if (candidates.length > 0) {
+        const direct = await YaverDiscovery.raceProbe(candidates);
+        if (direct) return direct;
+      }
 
-      // Try direct connection first (same LAN)
-      const port = target.httpPort ?? DEFAULT_PORT;
-      const directUrl = `http://${target.quicHost}:${port}`;
-      const directResult = await YaverDiscovery.probe(directUrl);
-      if (directResult) return directResult;
+      // Warn if the chosen target looks stale — informative only; we
+      // still fell through to the relay path below.
+      const stale =
+        target.lastHeartbeat &&
+        Date.now() - target.lastHeartbeat > HEARTBEAT_STALE_MS;
+      void stale;
 
-      // Direct connection failed — try via HTTP relay (off-LAN)
+      // Direct probes all failed — route through relay.
       const relayResult = await YaverDiscovery.discoverViaRelay(
-        base, authToken, target.deviceId,
+        base,
+        authToken,
+        target.deviceId,
       );
       if (relayResult) return relayResult;
 
@@ -162,9 +250,47 @@ export class YaverDiscovery {
   }
 
   /**
-   * Discover agent via relay HTTP proxy.
-   * Fetches relay server list from Convex platformConfig, then probes
-   * `{relayHttpUrl}/d/{deviceId}/health` to reach the agent over the internet.
+   * Race `/health` probes across N URLs in parallel. First 200 wins;
+   * everything else is abandoned. Mirrors the mobile app's
+   * `raceDirectCandidates` pattern — the single most reliable thing it
+   * does on same-LAN.
+   */
+  static async raceProbe(urls: string[]): Promise<DiscoveryResult | null> {
+    if (!urls || urls.length === 0) return null;
+    const attempts = urls.map((url) =>
+      YaverDiscovery.probe(url).then((r) => {
+        if (!r) throw new Error('no-200');
+        return r;
+      }),
+    );
+    try {
+      // `Promise.any` isn't on every RN runtime yet (older Hermes).
+      // Hand-roll the same behaviour so we don't need a polyfill.
+      return await new Promise<DiscoveryResult | null>((resolve) => {
+        let remaining = attempts.length;
+        let settled = false;
+        attempts.forEach((p) => {
+          p.then((r) => {
+            if (settled) return;
+            settled = true;
+            resolve(r);
+          }).catch(() => {
+            remaining -= 1;
+            if (remaining <= 0 && !settled) {
+              settled = true;
+              resolve(null);
+            }
+          });
+        });
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Discover agent via relay HTTP proxy. Uses the user's configured
+   * relay first (from `/auth/validate`), then the platform relay list.
    */
   static async discoverViaRelay(
     convexUrl: string,
@@ -172,7 +298,6 @@ export class YaverDiscovery {
     deviceId: string,
   ): Promise<DiscoveryResult | null> {
     try {
-      // Fetch relay server list from user settings first, then platform config
       const settingsRes = await fetch(`${convexUrl}/auth/validate`, {
         headers: { Authorization: `Bearer ${authToken}` },
       });
@@ -185,134 +310,98 @@ export class YaverDiscovery {
         relayPassword = settingsData.relayPassword;
       }
 
-      // If no user-level relay, fetch platform relay servers
       if (!relayUrl) {
         const configRes = await fetch(`${convexUrl}/platform-config?key=relay_servers`);
         if (configRes.ok) {
           const configData = await configRes.json();
-          const servers = typeof configData.value === 'string'
-            ? JSON.parse(configData.value)
-            : configData.value;
+          const servers =
+            typeof configData.value === 'string'
+              ? JSON.parse(configData.value)
+              : configData.value;
           if (Array.isArray(servers) && servers.length > 0) {
-            // Pick the first (highest priority) relay with an httpUrl
             const relay = servers.find((s: { httpUrl?: string }) => s.httpUrl);
-            if (relay) {
-              relayUrl = relay.httpUrl;
-            }
+            if (relay) relayUrl = relay.httpUrl;
           }
         }
       }
-
       if (!relayUrl) return null;
 
-      // Probe agent through relay: {relayHttpUrl}/d/{deviceId}/health
       const relayBase = `${relayUrl.replace(/\/$/, '')}/d/${deviceId}`;
-      const result = await YaverDiscovery.probeWithHeaders(relayBase, {
+      return YaverDiscovery.probeWithHeaders(relayBase, {
         'X-Relay-Password': relayPassword || '',
       });
-      return result;
     } catch {
       return null;
     }
   }
 
-  /**
-   * Probe with extra headers (e.g. relay password).
-   */
   static async probeWithHeaders(
     url: string,
     headers: Record<string, string>,
   ): Promise<DiscoveryResult | null> {
     const base = url.replace(/\/$/, '');
     const start = Date.now();
-
     try {
       const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS + 3000); // relay adds latency
-
+      const timeoutId = setTimeout(() => controller.abort(), RELAY_PROBE_TIMEOUT_MS);
       const response = await fetch(`${base}/health`, {
         method: 'GET',
         headers,
         signal: controller.signal,
       });
-
       clearTimeout(timeoutId);
-
       if (!response.ok) return null;
-
       const latency = Date.now() - start;
       let hostname = 'Unknown';
       let version = 'unknown';
-
       try {
         const data = await response.json();
         hostname = data.hostname ?? data.name ?? 'Unknown';
         version = data.version ?? 'unknown';
       } catch {
-        // Health endpoint might return plain text
+        // /health may return plain text
       }
-
       return { url: base, hostname, version, latency };
     } catch {
       return null;
     }
   }
 
-  /**
-   * Probe a specific URL for a running Yaver agent.
-   * Hits the `/health` endpoint with a 2s timeout.
-   */
+  /** Probe a specific URL for a running Yaver agent (2.5 s timeout). */
   static async probe(url: string): Promise<DiscoveryResult | null> {
     const base = url.replace(/\/$/, '');
     const start = Date.now();
-
     try {
       const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS);
-
+      const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
       const response = await fetch(`${base}/health`, {
         method: 'GET',
         signal: controller.signal,
       });
-
       clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        return null;
-      }
-
+      if (!response.ok) return null;
       const latency = Date.now() - start;
-
       let hostname = 'Unknown';
       let version = 'unknown';
-
       try {
         const data = await response.json();
         hostname = data.hostname ?? data.name ?? 'Unknown';
         version = data.version ?? 'unknown';
       } catch {
-        // Health endpoint might return plain text — that's fine
+        // /health may return plain text
       }
-
       return { url: base, hostname, version, latency };
     } catch {
       return null;
     }
   }
 
-  /**
-   * Manually connect to a specific agent URL.
-   * Probes the URL and stores the connection if successful.
-   */
   static async connect(url: string): Promise<DiscoveryResult | null> {
     const result = await YaverDiscovery.probe(url);
-    if (result) {
-      await YaverDiscovery.store(result);
-    }
+    if (result) await YaverDiscovery.store(result);
     return result;
   }
 
-  /** Get the cached agent connection from storage. */
   static async getStored(): Promise<{ url: string; hostname: string } | null> {
     const storage = getAsyncStorage();
     if (!storage) return null;
@@ -329,7 +418,6 @@ export class YaverDiscovery {
     }
   }
 
-  /** Store a successful discovery result. */
   static async store(result: DiscoveryResult): Promise<void> {
     const storage = getAsyncStorage();
     if (!storage) return;
@@ -343,7 +431,6 @@ export class YaverDiscovery {
     }
   }
 
-  /** Clear the stored agent connection. */
   static async clear(): Promise<void> {
     const storage = getAsyncStorage();
     if (!storage) return;

package/src/FeedbackModal.tsx

@@ -86,17 +86,43 @@ export const FeedbackModal: React.FC = () => {
     setAction('idle');
   }, []);
 
+  // Helper: run a P2P call; on network failure, ask YaverFeedback to
+  // re-query Convex for the fresh IP and retry once. Solves the common
+  // case where the Mac's LAN IP rotated while the SDK held a stale URL.
+  const runWithReconnect = useCallback(
+    async (fn: (client: NonNullable<ReturnType<typeof YaverFeedback.getP2PClient>>) => Promise<void>) => {
+      let client = YaverFeedback.getP2PClient();
+      if (!client) {
+        const ok = await YaverFeedback.reconnect();
+        if (ok) client = YaverFeedback.getP2PClient();
+      }
+      if (!client) {
+        throw new Error('Not connected to the agent yet.');
+      }
+      try {
+        await fn(client);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const transient = /Network request failed|timeout|ECONNREFUSED|Failed to fetch|fetch failed|aborted/i.test(msg);
+        if (!transient) throw err;
+        const ok = await YaverFeedback.reconnect();
+        if (!ok) throw err;
+        const fresh = YaverFeedback.getP2PClient();
+        if (!fresh) throw err;
+        await fn(fresh);
+      }
+    },
+    [],
+  );
+
   // ─── 1. Hot reload ─────────────────────────────────────────────────
   const handleHotReload = useCallback(async () => {
-    const client = YaverFeedback.getP2PClient();
-    if (!client) {
-      setError('Not connected to the agent yet.');
-      return;
-    }
     setAction('hot-reloading');
     setError(null);
     try {
-      await client.reloadApp('dev');
+      await runWithReconnect(async (client) => {
+        await client.reloadApp('dev');
+      });
       setToast('Reload sent');
       closeSoon(800);
     } catch (err: unknown) {
@@ -104,7 +130,7 @@ export const FeedbackModal: React.FC = () => {
     } finally {
       if (mountedRef.current) setAction('idle');
     }
-  }, [closeSoon]);
+  }, [closeSoon, runWithReconnect]);
 
   // ─── 2. Screenshot + Fix ───────────────────────────────────────────
   //

package/src/MachinePickerScreen.tsx

@@ -72,7 +72,12 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
 
   const renderDevice = (device: RemoteDevice) => {
     const selected = device.deviceId === currentDeviceId;
-    const stale = Date.now() - device.lastHeartbeat > 60_000;
+    // Match the Yaver mobile app: HEARTBEAT_STALE_MS is 90 s. Using
+    // 60 s here flashed yellow on a single missed agent beat even
+    // though the Mac was up.
+    const stale =
+      device.lastHeartbeat > 0 &&
+      Date.now() - device.lastHeartbeat > 90_000;
     const healthColor = !device.isOnline
       ? '#ef4444'
       : device.needsAuth || device.runnerDown || stale

package/src/YaverFeedback.ts

@@ -201,6 +201,33 @@ export class YaverFeedback {
     }
   }
 
+  /**
+   * Force a fresh Convex lookup for the agent URL — ignoring any
+   * cached URL. Callers use this after a P2P request fails
+   * (connection refused / timeout) because the most common cause is
+   * the Mac's LAN IP rotating. Convex has the fresh one, so we
+   * re-query and probe `[quicHost, ...localIps]` in parallel.
+   *
+   * Returns true when a new URL was adopted.
+   */
+  static async reconnect(): Promise<boolean> {
+    if (!config || !enabled) return false;
+    if (!config.authToken || !config.convexUrl) return false;
+    try {
+      const result = await YaverDiscovery.refreshFromConvex({
+        convexUrl: config.convexUrl,
+        authToken: config.authToken,
+        preferredDeviceId: config.preferredDeviceId,
+      });
+      if (!result) return false;
+      config.agentUrl = result.url;
+      p2pClient = new P2PClient(result.url, config.authToken ?? '');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Pull a cached session token + selected device from AsyncStorage (populated
    * by the in-SDK login + machine-picker screens). When present the SDK can

package/src/auth.ts

@@ -409,7 +409,17 @@ export interface RemoteDevice {
   accessScope: 'owner' | 'shared-scoped' | 'shared-legacy';
   quicHost: string;
   quicPort: number;
+  /** Agent HTTP port — preferred over quicPort when present. */
+  httpPort?: number;
   publicKey?: string;
+  /** Hardware identifier — used for dedup across re-pair events. */
+  hwid?: string;
+  /**
+   * Every LAN IP the agent reported in its last heartbeat. Useful on
+   * multi-homed hosts — probing all of them in parallel is the same
+   * trick the Yaver mobile app uses to "just work" on the same Wi-Fi.
+   */
+  localIps?: string[];
 }
 
 export interface DeviceList {
@@ -420,6 +430,10 @@ export interface DeviceList {
 /**
  * Fetch the set of remote dev machines this user can reach. Splits into
  * owned (user is the host) vs shared (host invited them as a guest).
+ *
+ * Collapses duplicate rows before splitting — Convex can return multiple
+ * rows per physical machine after a re-pair or hostname change, and the
+ * raw list used to render as "Kvancs-MacBook-Air.local ×3" in the picker.
  */
 export async function listReachableDevices(
   token: string,
@@ -430,10 +444,39 @@ export async function listReachableDevices(
     });
     if (!res.ok) return { owned: [], shared: [] };
     const data = await res.json();
-    const all = (data.devices ?? []) as RemoteDevice[];
+    const raw = (data.devices ?? []) as any[];
+    // Normalise Convex field names → SDK's RemoteDevice shape. The
+    // backend returns `localIps`, sometimes the mobile-side mapping
+    // surfaces `lanIps` — accept either so the field survives.
+    const normalised: RemoteDevice[] = raw.map((d) => ({
+      deviceId: d.deviceId ?? d.id,
+      name: d.name ?? '',
+      platform: d.platform ?? d.os ?? '',
+      isOnline: !!d.isOnline,
+      needsAuth: !!d.needsAuth,
+      runnerDown: !!d.runnerDown,
+      lastHeartbeat: d.lastHeartbeat ?? 0,
+      isGuest: !!d.isGuest,
+      hostName: d.hostName,
+      hostEmail: d.hostEmail,
+      accessScope: d.accessScope ?? 'owner',
+      quicHost: d.quicHost ?? d.host ?? '',
+      quicPort: d.quicPort ?? 0,
+      httpPort: d.httpPort ?? d.quicPort,
+      publicKey: d.publicKey,
+      hwid: d.hardwareId ?? d.hwid,
+      localIps: Array.isArray(d.localIps)
+        ? d.localIps
+        : Array.isArray(d.lanIps)
+          ? d.lanIps
+          : undefined,
+    }));
+    // Lazy require so Jest + tree-shakers don't choke on a circular import.
+    const { collapseRemoteDevices } = require('./deviceDedup') as typeof import('./deviceDedup');
+    const deduped = collapseRemoteDevices(normalised);
     return {
-      owned: all.filter((d) => !d.isGuest),
-      shared: all.filter((d) => d.isGuest),
+      owned: deduped.filter((d) => !d.isGuest),
+      shared: deduped.filter((d) => d.isGuest),
     };
   } catch {
     return { owned: [], shared: [] };