yaver-feedback-react-native 0.7.8 → 0.7.10

package/dist/_core/device.js

@@ -0,0 +1,310 @@
+"use strict";
+// AUTO-SYNCED from shared/client-core/src/device.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceIdentityKey = deviceIdentityKey;
+exports.deviceAliasKey = deviceAliasKey;
+exports.deviceEndpointKey = deviceEndpointKey;
+exports.mergeDeviceEntries = mergeDeviceEntries;
+exports.collapseDevices = collapseDevices;
+exports.isDeviceFresh = isDeviceFresh;
+exports.pickTargetDevice = pickTargetDevice;
+exports.buildProbeCandidates = buildProbeCandidates;
+exports.raceHealthProbes = raceHealthProbes;
+/**
+ * Device dedup, merging, freshness, and target-picking.
+ *
+ * Phase-2 extract of the Yaver-mobile logic that lives at
+ * mobile/src/context/DeviceContext.tsx:193-413. Ported faithfully —
+ * mobile's collapseAliasDevices has been battle-tested through
+ * multiple Convex schema changes and the re-pair edge cases; this
+ * file is byte-identical in behaviour, only renamed for the shared
+ * RemoteDevice shape. The Feedback SDK used to carry its own copy
+ * (sdk/feedback/react-native/src/deviceDedup.ts) that drifted on
+ * `hwid` strong-identity and `runners`/`local` field preservation.
+ *
+ * Canonical device shape shared across every surface:
+ *   - Mobile app:  mobile/src/context/DeviceContext.tsx::Device (adapts
+ *                  into this shape at the Convex /devices/list fetch
+ *                  site).
+ *   - Feedback SDK: src/auth.ts::RemoteDevice re-exports this type.
+ *   - Web / Desktop: same.
+ *
+ * The mobile app may have extra view-model fields it wants to keep on
+ * its own Device interface (edgeProfile, sessionBinding, etc.) — those
+ * stay as local extensions; the core operates only on the fields
+ * declared here.
+ */
+const constants_1 = require("./constants");
+// ── Normalisers ───────────────────────────────────────────────────────
+function normName(name) {
+    return String(name || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+function normHost(host) {
+    return String(host || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+// ── Keys ──────────────────────────────────────────────────────────────
+function deviceIdentityKey(d) {
+    if (d.hwid)
+        return `hwid:${d.hwid}`;
+    if (d.publicKey)
+        return `pub:${d.publicKey}`;
+    if (d.isGuest) {
+        const scope = d.hostEmail || d.hostName || 'guest';
+        return `guest:${scope}:${d.deviceId || d.name}`;
+    }
+    const n = normName(d.name);
+    const os = String(d.platform || '').trim().toLowerCase();
+    if (n && os)
+        return `host:${os}:${n}`;
+    if (d.deviceId)
+        return `id:${d.deviceId}`;
+    return `name:${d.name}`;
+}
+function deviceAliasKey(d) {
+    if (d.isGuest)
+        return null;
+    const n = normName(d.name);
+    const os = String(d.platform || '').trim().toLowerCase();
+    if (!n || !os)
+        return null;
+    return `${os}:${n}`;
+}
+function deviceEndpointKey(d) {
+    if (d.isGuest)
+        return null;
+    const h = normHost(d.quicHost);
+    if (!h)
+        return null;
+    return `${h}:${d.quicPort || 0}`;
+}
+// ── Merge rules ───────────────────────────────────────────────────────
+function mergeDeviceEntries(a, b) {
+    const incomingWins = (!!a.needsAuth && !b.needsAuth) ||
+        (b.lastHeartbeat || 0) > (a.lastHeartbeat || 0) ||
+        (!!b.isOnline && !a.isOnline);
+    const base = incomingWins ? b : a;
+    const other = incomingWins ? a : b;
+    return {
+        ...other,
+        ...base,
+        quicHost: base.quicHost || other.quicHost,
+        quicPort: base.quicPort || other.quicPort,
+        httpPort: base.httpPort || other.httpPort,
+        isOnline: base.isOnline || other.isOnline,
+        runnerDown: base.runnerDown && other.runnerDown,
+        publicKey: base.publicKey || other.publicKey,
+        hwid: base.hwid || other.hwid,
+        lastHeartbeat: Math.max(a.lastHeartbeat || 0, b.lastHeartbeat || 0),
+        localIps: (() => {
+            const set = new Set();
+            for (const ip of a.localIps || [])
+                if (ip)
+                    set.add(ip);
+            for (const ip of b.localIps || [])
+                if (ip)
+                    set.add(ip);
+            return set.size > 0 ? [...set] : undefined;
+        })(),
+    };
+}
+// When two rows share the same alias (hostname + OS) but differ on
+// hwid / publicKey, prefer the authenticated + online row over a
+// stale "needsAuth + offline" leftover. That leftover pattern is
+// what re-pair / wipe-and-reinstall produces on Convex.
+function pickActiveOverStaleNeedsAuth(a, b) {
+    const aDead = a.needsAuth && !a.isOnline;
+    const bDead = b.needsAuth && !b.isOnline;
+    const aLive = !a.needsAuth && a.isOnline;
+    const bLive = !b.needsAuth && b.isOnline;
+    if (aDead && bLive)
+        return b;
+    if (bDead && aLive)
+        return a;
+    return null;
+}
+// ── Collapse (three-pass dedup) ───────────────────────────────────────
+/**
+ * Collapse duplicate Convex rows so each physical machine appears
+ * exactly once. Three passes — identity key → alias key → endpoint key.
+ * Safe on empty lists; idempotent on already-deduped input.
+ */
+function collapseDevices(devices) {
+    if (!Array.isArray(devices) || devices.length === 0)
+        return [];
+    // Pass 1: identity key (hwid / publicKey / name+os).
+    const byIdentity = new Map();
+    for (const d of devices) {
+        const k = deviceIdentityKey(d);
+        const prev = byIdentity.get(k);
+        byIdentity.set(k, prev ? mergeDeviceEntries(prev, d) : d);
+    }
+    // Pass 2: alias key (os + normalised hostname), with strong-identity
+    // conflict resolution so two genuinely-different machines sharing a
+    // hostname don't silently merge.
+    const byAlias = new Map();
+    for (const d of byIdentity.values()) {
+        const k = deviceAliasKey(d);
+        if (!k) {
+            byAlias.set(`id:${d.deviceId}`, d);
+            continue;
+        }
+        const prev = byAlias.get(k);
+        if (!prev) {
+            byAlias.set(k, d);
+            continue;
+        }
+        const strongConflict = (!!prev.hwid && !!d.hwid && prev.hwid !== d.hwid) ||
+            (!!prev.publicKey && !!d.publicKey && prev.publicKey !== d.publicKey);
+        if (strongConflict) {
+            const winner = pickActiveOverStaleNeedsAuth(prev, d);
+            if (winner) {
+                byAlias.set(k, winner);
+                continue;
+            }
+        }
+        byAlias.set(k, mergeDeviceEntries(prev, d));
+    }
+    // Pass 3: endpoint key (host:port) — last-chance dedup for rows
+    // that share a LAN address but slipped through identity + alias.
+    const byEndpoint = new Map();
+    for (const d of byAlias.values()) {
+        const k = deviceEndpointKey(d);
+        if (!k) {
+            byEndpoint.set(`id:${d.deviceId}`, d);
+            continue;
+        }
+        const prev = byEndpoint.get(k);
+        byEndpoint.set(k, prev ? mergeDeviceEntries(prev, d) : d);
+    }
+    return [...byEndpoint.values()];
+}
+// ── Freshness + target pick ───────────────────────────────────────────
+/**
+ * "Fresh" matches the mobile app: online + heartbeat < 90 s. Clients
+ * read Convex's `isOnline` first (backend already applies its own 90 s
+ * gate from the server clock), then use this helper when they need the
+ * phone-side freshness opinion too — e.g. for auto-connect picks.
+ */
+function isDeviceFresh(d, now = Date.now()) {
+    if (!d.isOnline)
+        return false;
+    if (!d.lastHeartbeat)
+        return true;
+    return now - d.lastHeartbeat < constants_1.HEARTBEAT_STALE_MS;
+}
+/**
+ * Choose the best candidate for an auto-connect attempt. Preference:
+ *   1. explicit `preferredDeviceId` that's still fresh
+ *   2. fresh (online + recent heartbeat) + has a quicHost
+ *   3. online + has a quicHost
+ *   4. first with a quicHost
+ */
+function pickTargetDevice(devices, preferredDeviceId) {
+    if (!devices.length)
+        return null;
+    if (preferredDeviceId) {
+        const preferred = devices.find((d) => d.deviceId === preferredDeviceId && d.quicHost);
+        if (preferred && isDeviceFresh(preferred))
+            return preferred;
+        if (preferred)
+            return preferred;
+    }
+    const fresh = devices.find((d) => isDeviceFresh(d) && d.quicHost);
+    if (fresh)
+        return fresh;
+    const online = devices.find((d) => d.isOnline && d.quicHost);
+    if (online)
+        return online;
+    return devices.find((d) => d.quicHost) || devices[0] || null;
+}
+// ── Probe candidate assembly ──────────────────────────────────────────
+/**
+ * Build the set of `/health` candidate URLs for a target device —
+ * `quicHost` plus every LAN IP the agent reported in `localIps`,
+ * uniqued and formatted. This is the thing that makes direct LAN
+ * reloads "just work" on multi-homed hosts (en0 + utun tailscale +
+ * docker0 etc.) — the mobile app races them in parallel via
+ * Promise.any.
+ */
+function buildProbeCandidates(target, defaultHttpPort = 18080) {
+    const port = target.httpPort ?? target.quicPort ?? defaultHttpPort;
+    const ips = new Set();
+    if (target.quicHost)
+        ips.add(target.quicHost);
+    for (const ip of target.localIps ?? []) {
+        if (ip)
+            ips.add(ip);
+    }
+    return [...ips].map((ip) => `http://${ip}:${port}`);
+}
+/**
+ * Race `/health` probes across N URLs. First 200 wins; everything else
+ * is abandoned. Older Hermes doesn't have Promise.any, so we hand-roll
+ * the same semantic.
+ */
+async function raceHealthProbes(urls, opts = {}) {
+    if (!urls || urls.length === 0)
+        return null;
+    const timeoutMs = opts.timeoutMs ?? 2500;
+    const probeOne = async (url) => {
+        const base = url.replace(/\/$/, '');
+        const start = Date.now();
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            const res = await fetch(`${base}/health`, {
+                method: 'GET',
+                headers: opts.headers,
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (!res.ok)
+                return null;
+            const latency = Date.now() - start;
+            let hostname;
+            let version;
+            try {
+                const data = await res.json();
+                hostname = data?.hostname ?? data?.name;
+                version = data?.version;
+            }
+            catch {
+                // /health may return plain text
+            }
+            return { url: base, hostname, version, latency };
+        }
+        catch {
+            return null;
+        }
+    };
+    return new Promise((resolve) => {
+        let remaining = urls.length;
+        let settled = false;
+        for (const url of urls) {
+            probeOne(url)
+                .then((r) => {
+                if (settled)
+                    return;
+                if (r) {
+                    settled = true;
+                    resolve(r);
+                    return;
+                }
+                remaining -= 1;
+                if (remaining <= 0 && !settled) {
+                    settled = true;
+                    resolve(null);
+                }
+            })
+                .catch(() => {
+                remaining -= 1;
+                if (remaining <= 0 && !settled) {
+                    settled = true;
+                    resolve(null);
+                }
+            });
+        }
+    });
+}

package/dist/_core/index.d.ts

@@ -12,3 +12,4 @@
  */
 export * from './constants';
 export * from './endpoints';
+export * from './device';

package/dist/_core/index.js

@@ -31,3 +31,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 __exportStar(require("./constants"), exports);
 __exportStar(require("./endpoints"), exports);
+__exportStar(require("./device"), exports);

package/dist/deviceDedup.d.ts

@@ -1,45 +1,21 @@
 /**
- * Device deduplication + online-signal merging, ported from the Yaver
- * mobile app's DeviceContext.collapseAliasDevices.
+ * Re-export the canonical dedup / freshness / race-probe helpers from
+ * @yaver/client-core (mirrored into `./_core/`).
  *
- * Convex stores one row per pair (device, re-install). After a re-pair
- * or hostname change the list can contain 2-3 rows for the same
- * physical machine, with different hwid/publicKey values. The picker
- * then shows duplicates and the user can't tell which one is live.
+ * The SDK previously carried its own ~180-line copy of
+ * `collapseAliasDevices` ported by hand from mobile's
+ * DeviceContext.tsx. The copies drifted on `hwid` strong-identity,
+ * `runners` / `local` field preservation, and a few other subtle
+ * merge rules. Canonicalising via client-core eliminates that drift
+ * class — mobile's test case automatically covers the SDK's dedup
+ * behaviour too.
  *
- * This file collapses rows in three passes:
- *   1. Identity key (hwid → publicKey → "host:os:name" → id → name)
- *   2. Alias key (os + normalized-hostname) — catches re-pairs that
- *      mint a new hwid
- *   3. Endpoint key (host:port)
- *
- * When collapsing, `mergeDeviceEntries` prefers: authenticated over
- * needsAuth, online over offline, freshest lastHeartbeat.
+ * The shared module operates on a `CoreDevice` shape. The SDK's
+ * `RemoteDevice` is structurally compatible (same field names, same
+ * types), so the casts here are a no-op at runtime.
  */
 import type { RemoteDevice } from './auth';
-/**
- * Collapse a Convex device list so each physical machine appears once.
- * Safe on an empty list; idempotent on an already-deduped list.
- */
+export { HEARTBEAT_STALE_MS } from './_core/constants';
 export declare function collapseRemoteDevices(devices: RemoteDevice[]): RemoteDevice[];
-/**
- * Threshold for "online" based on heartbeat age, in milliseconds.
- * Re-exported from `@yaver/client-core` so mobile + SDK + backend
- * agree on one number at all times.
- */
-import { HEARTBEAT_STALE_MS } from './_core/constants';
-export { HEARTBEAT_STALE_MS };
-/**
- * Returns a freshness flag consistent with the mobile app. A device is
- * "fresh" when it was online per Convex AND its heartbeat is within
- * `HEARTBEAT_STALE_MS`.
- */
 export declare function isDeviceFresh(d: RemoteDevice): boolean;
-/**
- * Pick the best candidate for an auto-connect attempt. Preference:
- *   1. matches the preferred deviceId when supplied + still fresh
- *   2. fresh (online + recent heartbeat) + has a quicHost
- *   3. online + has a quicHost
- *   4. first with a quicHost
- */
 export declare function pickTargetDevice(devices: RemoteDevice[], preferredDeviceId?: string): RemoteDevice | null;

package/dist/deviceDedup.js

@@ -1,185 +1,35 @@
 "use strict";
 /**
- * Device deduplication + online-signal merging, ported from the Yaver
- * mobile app's DeviceContext.collapseAliasDevices.
+ * Re-export the canonical dedup / freshness / race-probe helpers from
+ * @yaver/client-core (mirrored into `./_core/`).
  *
- * Convex stores one row per pair (device, re-install). After a re-pair
- * or hostname change the list can contain 2-3 rows for the same
- * physical machine, with different hwid/publicKey values. The picker
- * then shows duplicates and the user can't tell which one is live.
+ * The SDK previously carried its own ~180-line copy of
+ * `collapseAliasDevices` ported by hand from mobile's
+ * DeviceContext.tsx. The copies drifted on `hwid` strong-identity,
+ * `runners` / `local` field preservation, and a few other subtle
+ * merge rules. Canonicalising via client-core eliminates that drift
+ * class — mobile's test case automatically covers the SDK's dedup
+ * behaviour too.
  *
- * This file collapses rows in three passes:
- *   1. Identity key (hwid → publicKey → "host:os:name" → id → name)
- *   2. Alias key (os + normalized-hostname) — catches re-pairs that
- *      mint a new hwid
- *   3. Endpoint key (host:port)
- *
- * When collapsing, `mergeDeviceEntries` prefers: authenticated over
- * needsAuth, online over offline, freshest lastHeartbeat.
+ * The shared module operates on a `CoreDevice` shape. The SDK's
+ * `RemoteDevice` is structurally compatible (same field names, same
+ * types), so the casts here are a no-op at runtime.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HEARTBEAT_STALE_MS = void 0;
 exports.collapseRemoteDevices = collapseRemoteDevices;
 exports.isDeviceFresh = isDeviceFresh;
 exports.pickTargetDevice = pickTargetDevice;
-function normalizedName(name) {
-    return String(name || '').trim().toLowerCase().replace(/\.local$/i, '');
-}
-function normalizedHost(host) {
-    return String(host || '').trim().toLowerCase().replace(/\.local$/i, '');
-}
-function identityKey(d) {
-    if (d.hwid)
-        return `hwid:${d.hwid}`;
-    if (d.publicKey)
-        return `pub:${d.publicKey}`;
-    if (d.isGuest) {
-        const scope = d.hostEmail || d.hostName || 'guest';
-        return `guest:${scope}:${d.deviceId || d.name}`;
-    }
-    const n = normalizedName(d.name);
-    const os = String(d.platform || '').trim().toLowerCase();
-    if (n && os)
-        return `host:${os}:${n}`;
-    if (d.deviceId)
-        return `id:${d.deviceId}`;
-    return `name:${d.name}`;
-}
-function aliasKey(d) {
-    if (d.isGuest)
-        return null;
-    const n = normalizedName(d.name);
-    const os = String(d.platform || '').trim().toLowerCase();
-    if (!n || !os)
-        return null;
-    return `${os}:${n}`;
-}
-function endpointKey(d) {
-    if (d.isGuest)
-        return null;
-    const h = normalizedHost(d.quicHost);
-    if (!h)
-        return null;
-    return `${h}:${d.quicPort || 0}`;
-}
-function mergeEntries(existing, incoming) {
-    const incomingWins = (!!existing.needsAuth && !incoming.needsAuth) ||
-        (incoming.lastHeartbeat || 0) > (existing.lastHeartbeat || 0) ||
-        (!!incoming.isOnline && !existing.isOnline);
-    const base = incomingWins ? incoming : existing;
-    const other = incomingWins ? existing : incoming;
-    return {
-        ...other,
-        ...base,
-        quicHost: base.quicHost || other.quicHost,
-        quicPort: base.quicPort || other.quicPort,
-        isOnline: base.isOnline || other.isOnline,
-        runnerDown: base.runnerDown && other.runnerDown,
-        publicKey: base.publicKey || other.publicKey,
-        lastHeartbeat: Math.max(existing.lastHeartbeat || 0, incoming.lastHeartbeat || 0),
-    };
-}
-// When two rows share the same alias key (hostname + OS) but differ on
-// hwid/publicKey, pick the active one over the stale needs-auth leftover.
-function pickActiveOverStaleNeedsAuth(a, b) {
-    const aDead = a.needsAuth && !a.isOnline;
-    const bDead = b.needsAuth && !b.isOnline;
-    const aLive = !a.needsAuth && a.isOnline;
-    const bLive = !b.needsAuth && b.isOnline;
-    if (aDead && bLive)
-        return b;
-    if (bDead && aLive)
-        return a;
-    return null;
-}
-/**
- * Collapse a Convex device list so each physical machine appears once.
- * Safe on an empty list; idempotent on an already-deduped list.
- */
+const device_1 = require("./_core/device");
+var constants_1 = require("./_core/constants");
+Object.defineProperty(exports, "HEARTBEAT_STALE_MS", { enumerable: true, get: function () { return constants_1.HEARTBEAT_STALE_MS; } });
 function collapseRemoteDevices(devices) {
-    if (!Array.isArray(devices) || devices.length === 0)
-        return [];
-    const byIdentity = new Map();
-    for (const d of devices) {
-        const k = identityKey(d);
-        const prev = byIdentity.get(k);
-        byIdentity.set(k, prev ? mergeEntries(prev, d) : d);
-    }
-    const byAlias = new Map();
-    for (const d of byIdentity.values()) {
-        const k = aliasKey(d);
-        if (!k) {
-            byAlias.set(`id:${d.deviceId}`, d);
-            continue;
-        }
-        const prev = byAlias.get(k);
-        if (!prev) {
-            byAlias.set(k, d);
-            continue;
-        }
-        const strongIdentityConflict = !!prev.publicKey && !!d.publicKey && prev.publicKey !== d.publicKey;
-        if (strongIdentityConflict) {
-            const winner = pickActiveOverStaleNeedsAuth(prev, d);
-            if (winner) {
-                byAlias.set(k, winner);
-                continue;
-            }
-        }
-        byAlias.set(k, mergeEntries(prev, d));
-    }
-    const byEndpoint = new Map();
-    for (const d of byAlias.values()) {
-        const k = endpointKey(d);
-        if (!k) {
-            byEndpoint.set(`id:${d.deviceId}`, d);
-            continue;
-        }
-        const prev = byEndpoint.get(k);
-        byEndpoint.set(k, prev ? mergeEntries(prev, d) : d);
-    }
-    return [...byEndpoint.values()];
+    return (0, device_1.collapseDevices)(devices);
 }
-/**
- * Threshold for "online" based on heartbeat age, in milliseconds.
- * Re-exported from `@yaver/client-core` so mobile + SDK + backend
- * agree on one number at all times.
- */
-const constants_1 = require("./_core/constants");
-Object.defineProperty(exports, "HEARTBEAT_STALE_MS", { enumerable: true, get: function () { return constants_1.HEARTBEAT_STALE_MS; } });
-/**
- * Returns a freshness flag consistent with the mobile app. A device is
- * "fresh" when it was online per Convex AND its heartbeat is within
- * `HEARTBEAT_STALE_MS`.
- */
 function isDeviceFresh(d) {
-    if (!d.isOnline)
-        return false;
-    if (!d.lastHeartbeat)
-        return true;
-    return Date.now() - d.lastHeartbeat < constants_1.HEARTBEAT_STALE_MS;
+    return (0, device_1.isDeviceFresh)(d);
 }
-/**
- * Pick the best candidate for an auto-connect attempt. Preference:
- *   1. matches the preferred deviceId when supplied + still fresh
- *   2. fresh (online + recent heartbeat) + has a quicHost
- *   3. online + has a quicHost
- *   4. first with a quicHost
- */
 function pickTargetDevice(devices, preferredDeviceId) {
-    if (!devices.length)
-        return null;
-    if (preferredDeviceId) {
-        const preferred = devices.find((d) => d.deviceId === preferredDeviceId && d.quicHost);
-        if (preferred && isDeviceFresh(preferred))
-            return preferred;
-        if (preferred)
-            return preferred;
-    }
-    const fresh = devices.find((d) => isDeviceFresh(d) && d.quicHost);
-    if (fresh)
-        return fresh;
-    const online = devices.find((d) => d.isOnline && d.quicHost);
-    if (online)
-        return online;
-    return devices.find((d) => d.quicHost) || devices[0] || null;
+    const pick = (0, device_1.pickTargetDevice)(devices, preferredDeviceId);
+    return (pick ?? null);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.7.8",
+  "version": "0.7.10",
   "description": "Visual feedback SDK for Yaver — bug reports, screen recording, voice annotations, and local-first developer workflows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/Discovery.ts

@@ -256,36 +256,19 @@ export class YaverDiscovery {
    * 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;
-    }
+    // Delegate to the canonical client-core implementation so mobile +
+    // SDK run the same race logic. Returned shape is `ProbeResult` —
+    // structurally compatible with DiscoveryResult minus the required
+    // hostname/version fields, which we backfill with sane defaults.
+    const { raceHealthProbes } = await import('./_core/device');
+    const res = await raceHealthProbes(urls, { timeoutMs: PROBE_TIMEOUT_MS });
+    if (!res) return null;
+    return {
+      url: res.url,
+      hostname: res.hostname ?? 'Unknown',
+      version: res.version ?? 'unknown',
+      latency: res.latency ?? 0,
+    };
   }
 
   /**