@mentra/engine 3.2.0-dev.116 → 3.2.0-dev.121

package/src/services/PhoneStreamCoordinator.ts

@@ -26,6 +26,18 @@
  * streams. We use a `phone-` prefix so they're trivially distinguishable from
  * cloud-minted IDs in logs and from cloud-SDK app streams that flow through
  * the legacy path.
+ *
+ * BLE link loss is a SUSPENDED state, not a failure:
+ *   The glasses publisher keeps pushing over Wi-Fi when the phone's Bluetooth
+ *   link drops; only our keep-alives stop reaching it. While the store says
+ *   the glasses are disconnected we pause the heartbeat (so we don't count
+ *   misses we caused ourselves), fan out `suspended`, and give the link
+ *   `glassesGraceMs` to come back. On reconnect we resume, heartbeat at once,
+ *   and fan out `resumed` with the SAME streamId — no re-provision. The grace
+ *   ends early when Cloudflare reports the publisher gone for two probes in
+ *   a row (glasses powered off, not a BLE hiccup). If the grace expires the
+ *   stream is torn down with reason `glasses_disconnected`, and the BLE stop
+ *   the glasses never received is sent on the next reconnect.
  */
 
 import BluetoothSdk from "@mentra/bluetooth-sdk/internal"
@@ -65,11 +77,40 @@ const DEFAULT_TIMINGS = {
   hlsReadinessInitialDelayMs: 5_000,
   hlsReadinessPollMs: 2_000,
   hlsReadinessMaxAttempts: 30,
+  // How long a stream survives a BLE link drop before we give up on it. Must
+  // stay under the glasses publisher's own 60s no-keep-alive watchdog with
+  // margin for the resume heartbeat's round trip.
+  glassesGraceMs: 45_000,
+  // Consecutive Cloudflare "publisher disconnected" probes while suspended
+  // before we conclude the glasses are off (not just out of BLE range).
+  suspendedPublisherGoneProbes: 2,
 } as const
 
 type TimingConfig = {[K in keyof typeof DEFAULT_TIMINGS]: number}
 export type CoordinatorTimings = Partial<TimingConfig>
 
+/**
+ * Where the coordinator learns whether the phone↔glasses BLE link is up.
+ * Injected so tests can drive link transitions without the zustand store.
+ */
+export interface GlassesLinkSource {
+  isConnected(): boolean
+  /** Fires on every connected↔disconnected transition. */
+  subscribe(listener: (connected: boolean) => void): () => void
+}
+
+const storeLinkSource: GlassesLinkSource = {
+  isConnected: () => isGlassesConnected(useGlassesStore.getState().connection),
+  subscribe: (listener) => useGlassesStore.subscribe((s) => isGlassesConnected(s.connection), listener),
+}
+
+/** Reasons carried on coordinator-sourced `stream_status` fanouts for link events. */
+export const LINK_STATUS = {
+  suspended: "suspended",
+  resumed: "resumed",
+  reason: "glasses_disconnected",
+} as const
+
 // Console-backed minimal logger; replaces pino on the phone.
 const consoleLogger: LifecycleLogger = {
   child: (bindings) => ({
@@ -90,6 +131,7 @@ export interface StartUnmanagedOptions {
   sound?: boolean
   /** Optional Bearer token for WHIP Authorization (custom authenticated endpoints). */
   authToken?: string
+  captureAudio?: boolean
 }
 
 export interface StartManagedOptions {
@@ -108,6 +150,8 @@ export interface StartManagedOptions {
    *     that drop WHIP/SRT UDP.
    */
   ingest?: "srt" | "whip" | "rtmp"
+  /** When false, glasses skip encoding their mic for this WHIP session. */
+  captureAudio?: boolean
 }
 
 export interface StreamPublisherStartResult {
@@ -184,20 +228,11 @@ export class StreamConflictError extends Error {
   }
 }
 
-/**
- * Fail fast if glasses aren't connected — BEFORE provisioning. Without this a
- * managed start would create a provider live input, fail the BLE command, and
- * tear the input down again: a slow, billable no-op with a confusing error.
- */
-function assertGlassesConnected(): void {
-  if (!isGlassesConnected(useGlassesStore.getState().connection)) {
-    throw new StreamConflictError(
-      "GLASSES_NOT_CONNECTED",
-      "Glasses are not connected",
-      "command",
-      "ble",
-    )
-  }
+interface SuspendedState {
+  since: number
+  graceTimer: ReturnType<typeof setTimeout>
+  /** Consecutive Cloudflare probes that saw no publisher during this suspension. */
+  publisherGoneProbes: number
 }
 
 export class PhoneStreamCoordinator {
@@ -206,6 +241,16 @@ export class PhoneStreamCoordinator {
   private statusSubscriber: StatusSubscriber | null = null
   private idCounter = 0
   private readonly timings: TimingConfig
+  private readonly linkSource: GlassesLinkSource
+  private unsubscribeLink: (() => void) | null = null
+  private suspended: SuspendedState | null = null
+  /**
+   * A stream was torn down while the BLE link was down, so the glasses never
+   * got `stopStream`. Sent on the next reconnect (if no new stream has claimed
+   * the slot) so a publisher that outlived its input does not keep pushing
+   * until its own watchdog fires.
+   */
+  private pendingBleStop: {streamId: string} | null = null
   /**
    * Serializes state transitions (start, stop, teardown). Without it, a
    * second `start*` racing with the first can pass the `this.current === null`
@@ -220,8 +265,30 @@ export class PhoneStreamCoordinator {
   /** Send full resolvedConfig only once per stream session. */
   private resolvedConfigForwarded = false
 
-  constructor(timings: CoordinatorTimings = {}) {
+  constructor(timings: CoordinatorTimings = {}, deps: {linkSource?: GlassesLinkSource} = {}) {
     this.timings = {...DEFAULT_TIMINGS, ...timings}
+    this.linkSource = deps.linkSource ?? storeLinkSource
+  }
+
+  /**
+   * Fail fast if glasses aren't connected — BEFORE provisioning. Without this a
+   * managed start would create a provider live input, fail the BLE command, and
+   * tear the input down again: a slow, billable no-op with a confusing error.
+   */
+  private assertGlassesConnected(): void {
+    if (!this.linkSource.isConnected()) {
+      throw new StreamConflictError(
+        "GLASSES_NOT_CONNECTED",
+        "Glasses are not connected",
+        "command",
+        "ble",
+      )
+    }
+  }
+
+  /** True while the active stream is parked on a dropped BLE link. */
+  isSuspended(): boolean {
+    return this.suspended !== null
   }
 
   /**
@@ -261,7 +328,11 @@ export class PhoneStreamCoordinator {
 
   /** Report-safe stream ownership snapshot for incident diagnostics. */
   getDiagnosticSnapshot(): Record<string, unknown> {
-    if (!this.current) return {active: false}
+    if (!this.current) return {active: false, pendingBleStop: this.pendingBleStop?.streamId ?? null}
+    const link = {
+      suspended: this.suspended !== null,
+      ...(this.suspended ? {suspendedForMs: Date.now() - this.suspended.since} : {}),
+    }
     return this.current.kind === "managed"
       ? {
           active: true,
@@ -270,12 +341,14 @@ export class PhoneStreamCoordinator {
           subscribers: [...this.current.subscribers].sort(),
           mode: this.current.mode,
           playbackReady: this.current.hlsReady,
+          ...link,
         }
       : {
           active: true,
           kind: this.current.kind,
           streamId: this.current.streamId,
           ownerPackageName: this.current.packageName,
+          ...link,
         }
   }
 
@@ -288,7 +361,7 @@ export class PhoneStreamCoordinator {
     if (!opts.streamUrl || typeof opts.streamUrl !== "string") {
       throw new StreamConflictError("STREAM_URL_REQUIRED", "streamUrl is required")
     }
-    assertGlassesConnected()
+    this.assertGlassesConnected()
     return this.runExclusive(async () => {
       if (this.current) {
         throw new StreamConflictError(
@@ -319,6 +392,7 @@ export class PhoneStreamCoordinator {
           ...(opts.video !== undefined ? {video: opts.video} : {}),
           ...(opts.audio !== undefined ? {audio: opts.audio} : {}),
           ...(opts.authToken ? {authToken: opts.authToken} : {}),
+          ...(typeof opts.captureAudio === "boolean" ? {captureAudio: opts.captureAudio} : {}),
         })
         const result = publisherStartResult(streamId, event)
         this.startLifecycle(streamId)
@@ -346,7 +420,7 @@ export class PhoneStreamCoordinator {
     // Two-phase: the entry-claim runs under the transition lock; the wait for
     // HLS readiness happens AFTER the lock releases so a long warm-up doesn't
     // block subsequent start/stop transitions on this coordinator.
-    assertGlassesConnected()
+    this.assertGlassesConnected()
     type JoinDecision =
       | {kind: "join"; entry: ManagedEntry; immediate: ManagedStartResult | null}
       | {kind: "fresh"; entry: ManagedEntry}
@@ -422,6 +496,7 @@ export class PhoneStreamCoordinator {
           // See startUnmanaged: the native bridge rejects explicit `undefined`.
           ...(opts.video !== undefined ? {video: opts.video} : {}),
           ...(opts.audio !== undefined ? {audio: opts.audio} : {}),
+          ...(typeof opts.captureAudio === "boolean" ? {captureAudio: opts.captureAudio} : {}),
         })
         entry.publisherStart = publisherStartResult(streamId, event)
         console.info("[STREAM_STARTUP]", {
@@ -543,6 +618,109 @@ export class PhoneStreamCoordinator {
     this.lifecycle?.handleAck(event.ackId)
   }
 
+  // ===========================================================================
+  // BLE link suspension
+  // ===========================================================================
+
+  private attachLink(): void {
+    if (this.unsubscribeLink) return
+    this.unsubscribeLink = this.linkSource.subscribe((connected) => this.handleLinkChange(connected))
+  }
+
+  private detachLinkIfIdle(): void {
+    if (this.current || this.pendingBleStop || !this.unsubscribeLink) return
+    this.unsubscribeLink()
+    this.unsubscribeLink = null
+  }
+
+  private handleLinkChange(connected: boolean): void {
+    if (connected) {
+      if (this.current && this.suspended) {
+        this.resumeLocked()
+      } else if (!this.current && this.pendingBleStop) {
+        this.flushPendingBleStop()
+      }
+      return
+    }
+    if (this.current && !this.suspended) this.suspend()
+  }
+
+  private suspend(): void {
+    const entry = this.current
+    if (!entry) return
+    const since = Date.now()
+    // Pause the heartbeat: misses now would be our own fault, not the
+    // publisher's, and counting them would reap a stream that is still live.
+    this.lifecycle?.setActive(false)
+    const graceTimer = setTimeout(() => this.onGraceExpired(entry.streamId), this.timings.glassesGraceMs)
+    this.suspended = {since, graceTimer, publisherGoneProbes: 0}
+    console.warn("[STREAM] BLE link lost; stream suspended", {
+      streamId: entry.streamId,
+      graceMs: this.timings.glassesGraceMs,
+    })
+    this.fanout({
+      streamId: entry.streamId,
+      source: "coordinator",
+      status: LINK_STATUS.suspended,
+      data: {reason: LINK_STATUS.reason, graceMs: this.timings.glassesGraceMs, since},
+    })
+  }
+
+  private resumeLocked(): void {
+    const entry = this.current
+    const suspended = this.suspended
+    if (!entry || !suspended) return
+    clearTimeout(suspended.graceTimer)
+    this.suspended = null
+    const suspendedMs = Date.now() - suspended.since
+    console.info("[STREAM] BLE link back; stream resumed", {streamId: entry.streamId, suspendedMs})
+    // Resume and heartbeat immediately: the glasses watchdog has been running
+    // the whole time, so the first keep-alive must not wait another interval.
+    this.lifecycle?.setActive(true)
+    this.lifecycle?.tickNow()
+    // A resumed session is a fresh status baseline for subscribers.
+    this.lastFanoutSignature = null
+    this.fanout({
+      streamId: entry.streamId,
+      source: "coordinator",
+      status: LINK_STATUS.resumed,
+      data: {reason: LINK_STATUS.reason, suspendedMs},
+    })
+  }
+
+  private onGraceExpired(streamId: string): void {
+    if (this.current?.streamId !== streamId || !this.suspended) return
+    this.failSuspended(streamId, "glasses_disconnected", {publisherGone: false})
+  }
+
+  /**
+   * End a suspended stream. `publisherGone` distinguishes "glasses are off and
+   * Cloudflare confirms nothing is publishing" from "grace ran out with the
+   * publisher possibly still alive" — miniapps word the two differently.
+   */
+  private failSuspended(streamId: string, reason: string, detail: {publisherGone: boolean}): void {
+    this.fanout({
+      streamId,
+      source: "coordinator",
+      status: "error",
+      data: {reason: LINK_STATUS.reason, teardownReason: reason, ...detail},
+    })
+    void this.runExclusive(async () => {
+      if (this.current?.streamId !== streamId) return
+      await this.teardownLocked(reason)
+    })
+  }
+
+  private flushPendingBleStop(): void {
+    const pending = this.pendingBleStop
+    if (!pending) return
+    this.pendingBleStop = null
+    console.info("[STREAM] BLE link back; sending deferred stopStream", pending)
+    void BluetoothSdk.stopStream()
+      .catch((err) => console.warn("[STREAM] deferred stopStream failed:", err))
+      .finally(() => this.detachLinkIfIdle())
+  }
+
   // ===========================================================================
   // Internal
   // ===========================================================================
@@ -552,7 +730,11 @@ export class PhoneStreamCoordinator {
     return `phone-${prefix}-${Date.now().toString(36)}-${this.idCounter}`
   }
 
+  /** BLE keep-alives. StreamLifecycleController uses BgTimer so they survive MentraOS backgrounding. */
   private startLifecycle(streamId: string): void {
+    // A new stream supersedes any deferred stop for the previous one.
+    this.pendingBleStop = null
+    this.attachLink()
     this.lifecycle?.dispose()
     const ctrl = new StreamLifecycleController(
       {
@@ -631,6 +813,20 @@ export class PhoneStreamCoordinator {
           status: status.isConnected ? "connected" : "disconnected",
           data: status as unknown as Record<string, unknown>,
         })
+        // While the BLE link is down, Cloudflare is the only witness to the
+        // publisher. Two consecutive "nobody is publishing" probes mean the
+        // glasses are off, not merely out of Bluetooth range — stop waiting.
+        if (this.suspended) {
+          if (status.isConnected) {
+            this.suspended.publisherGoneProbes = 0
+          } else {
+            this.suspended.publisherGoneProbes += 1
+            if (this.suspended.publisherGoneProbes >= this.timings.suspendedPublisherGoneProbes) {
+              this.failSuspended(entry.streamId, "glasses_disconnected_publisher_gone", {publisherGone: true})
+              keepPolling = false
+            }
+          }
+        }
         // webrtc mode readiness: first "connected" means WHEP playback is
         // available (WebRTC playback follows the ingest directly; there is no
         // manifest to probe).
@@ -799,12 +995,28 @@ export class PhoneStreamCoordinator {
     this.lastFanoutSignature = null
     this.resolvedConfigForwarded = false
 
+    if (this.suspended) {
+      clearTimeout(this.suspended.graceTimer)
+      this.suspended = null
+    }
+
     // Dispose the lifecycle controller immediately so it doesn't fire one
     // more keep-alive against a stream we're tearing down. The transition
     // lock guarantees no new lifecycle is started concurrently.
     this.lifecycle?.dispose()
     this.lifecycle = null
 
+    // With the link down a BLE write can only fail (and hold the transition
+    // lock for the native timeout). Defer it to the next reconnect instead.
+    const linkUp = this.linkSource.isConnected()
+    if (sendBleStop && !linkUp) {
+      this.pendingBleStop = {streamId: entry.streamId}
+      console.warn("[STREAM] BLE link down during teardown; stopStream deferred", {
+        streamId: entry.streamId,
+        reason,
+      })
+    }
+
     if (entry.kind === "managed") {
       if (entry.cloudflareTimer) clearTimeout(entry.cloudflareTimer)
       if (entry.hlsTimer) clearInterval(entry.hlsTimer)
@@ -816,7 +1028,7 @@ export class PhoneStreamCoordinator {
     }
 
     try {
-      if (sendBleStop) {
+      if (sendBleStop && linkUp) {
         await BluetoothSdk.stopStream()
       }
     } catch (err) {
@@ -827,6 +1039,7 @@ export class PhoneStreamCoordinator {
       // Only clear if we're still the active entry (defensive — runExclusive
       // serializes us, so this should always be true).
       if (this.current === entry) this.current = null
+      this.detachLinkIfIdle()
 
       if (entry.kind === "managed") {
         // Start remote cleanup only after the publisher has stopped, but do not

package/src/services/StreamLifecycleController.ts

@@ -1,11 +1,15 @@
 /**
- * Drives RTMP stream liveliness checks via a keep-alive heartbeat:
+ * Drives stream liveliness checks via a keep-alive heartbeat:
  * `setActive(true)` starts the timer; each tick sends a keep-alive with a
  * fresh ackId; `maxMissedAcks` consecutive timeouts fire `onTimeout`.
  *
  * Phone-owned successor to the retired cloud stream lifecycle controller.
  * It uses the local `LifecycleLogger` interface because pino is not a phone
  * dependency.
+ *
+ * Timers MUST go through BgTimer. React Native pauses plain `setInterval`
+ * while MentraOS is backgrounded; glasses WHIP then auto-stops after 60s
+ * without `keep_stream_alive`, and Mentra Call recovers by restarting ingest.
  */
 
 export interface LifecycleLogger {
@@ -23,6 +27,13 @@ interface StreamLifecycleCallbacks {
   onKeepAliveMissed?: (ackId: string, ageMs: number, missedCount: number) => void
 }
 
+export interface StreamLifecycleTimerApi {
+  setInterval: (callback: () => void, delay: number) => number
+  clearInterval: (intervalId: number) => void
+  setTimeout: (callback: () => void, delay: number) => number
+  clearTimeout: (timeoutId: number) => void
+}
+
 export interface StreamLifecycleOptions {
   logger: LifecycleLogger
   streamId: string
@@ -31,21 +42,27 @@ export interface StreamLifecycleOptions {
   maxMissedAcks: number
   shouldSendKeepAlive?: () => boolean
   now?: () => number
+  timers?: StreamLifecycleTimerApi
 }
 
 interface PendingAckInfo {
   sentAt: number
-  timeout: ReturnType<typeof setTimeout>
+  timeout: number
+}
+
+function productionTimers(): StreamLifecycleTimerApi {
+  // Lazy so unit tests that inject timers never parse react-native.
+  const {BgTimer} = require("../utils/timers") as {BgTimer: StreamLifecycleTimerApi}
+  return BgTimer
 }
 
 /**
- * Drives RTMP stream liveliness checks. Activate to start the heartbeat;
- * each tick sends a keep-alive with a fresh ackId and arms a timeout. When
- * `maxMissedAcks` consecutive timeouts fire, `onTimeout` is invoked and the
- * caller is expected to tear the stream down.
+ * Keep-alive heartbeat. Activate to start ticks; each tick sends keep-alive
+ * with a fresh ackId and arms a timeout. `maxMissedAcks` consecutive misses
+ * fire `onTimeout`, and the caller is expected to tear the stream down.
  */
 export class StreamLifecycleController {
-  private keepAliveTimer?: ReturnType<typeof setInterval>
+  private keepAliveTimer?: number
   private pendingAcks: Map<string, PendingAckInfo> = new Map()
   private missedAcks = 0
   private lastActivityMs: number
@@ -59,6 +76,7 @@ export class StreamLifecycleController {
   private readonly maxMissedAcks: number
   private readonly shouldSendKeepAlive?: () => boolean
   private readonly now: () => number
+  private readonly timers: StreamLifecycleTimerApi
 
   constructor(
     options: StreamLifecycleOptions,
@@ -71,6 +89,7 @@ export class StreamLifecycleController {
     this.maxMissedAcks = options.maxMissedAcks
     this.shouldSendKeepAlive = options.shouldSendKeepAlive
     this.now = options.now ?? (() => Date.now())
+    this.timers = options.timers ?? productionTimers()
     this.lastActivityMs = this.now()
   }
 
@@ -94,6 +113,17 @@ export class StreamLifecycleController {
     this.missedAcks = 0
   }
 
+  /**
+   * Send one keep-alive immediately instead of waiting for the next interval.
+   * Used when the BLE link comes back after a suspension: the glasses
+   * publisher's 60s watchdog has been running the whole time, so the first
+   * heartbeat after resume must not wait up to another full interval.
+   */
+  tickNow(): void {
+    if (this.disposed || !this.active) return
+    void this.tick()
+  }
+
   handleAck(ackId: string): void {
     if (this.disposed) return
 
@@ -103,7 +133,7 @@ export class StreamLifecycleController {
       return
     }
 
-    clearTimeout(ackInfo.timeout)
+    this.timers.clearTimeout(ackInfo.timeout)
     this.pendingAcks.delete(ackId)
     this.recordActivity()
 
@@ -125,7 +155,7 @@ export class StreamLifecycleController {
 
   private startTimer(): void {
     if (this.keepAliveTimer) return
-    this.keepAliveTimer = setInterval(() => {
+    this.keepAliveTimer = this.timers.setInterval(() => {
       void this.tick()
     }, this.keepAliveIntervalMs)
     this.logger.debug({streamId: this.streamId}, "Keep-alive timer started")
@@ -133,7 +163,7 @@ export class StreamLifecycleController {
 
   private stopTimer(): void {
     if (this.keepAliveTimer) {
-      clearInterval(this.keepAliveTimer)
+      this.timers.clearInterval(this.keepAliveTimer)
       this.keepAliveTimer = undefined
       this.logger.debug({streamId: this.streamId}, "Keep-alive timer stopped")
     }
@@ -153,7 +183,7 @@ export class StreamLifecycleController {
     const ackId = this.createAckId()
     const sentAt = this.now()
 
-    const timeout = setTimeout(() => {
+    const timeout = this.timers.setTimeout(() => {
       this.onAckTimeout(ackId, sentAt)
     }, this.ackTimeoutMs)
 
@@ -202,7 +232,7 @@ export class StreamLifecycleController {
 
   private clearPendingAcks(): void {
     for (const {timeout} of this.pendingAcks.values()) {
-      clearTimeout(timeout)
+      this.timers.clearTimeout(timeout)
     }
     this.pendingAcks.clear()
   }

package/src/services/acsAudioSource.ts

@@ -0,0 +1,53 @@
+export type SourceReason =
+  | "explicit"
+  | "current-mic"
+  | "ranking"
+  | "fallback-glasses-connected"
+  | "fallback-no-glasses"
+
+export type AcsAudioSource = "glasses" | "phone"
+
+/**
+ * Single switch for Mentra Call ACS uplink.
+ * `"phone"` = AudioRecord / iOS input tap → RawOutgoingAudioStream (no Cloudflare audio).
+ * `"glasses"` = today's glasses WHIP → Cloudflare → WHEP PCM → ACS path.
+ * preferred_mic does not govern this call.
+ */
+export const ACS_CALL_MIC: AcsAudioSource = "glasses"
+
+export type ResolvedAudioSource = {
+  source: AcsAudioSource
+  reason: SourceReason
+}
+
+function mapMic(value: string | null | undefined): AcsAudioSource | null {
+  if (value === "phone" || value === "bluetooth" || value === "bluetoothClassic") return "phone"
+  if (value === "glasses") return "glasses"
+  return null
+}
+
+/**
+ * Pure preferred_mic → ACS source mapping. Store reads stay in the thin wrapper
+ * so this table can be unit tested without zustand.
+ */
+export function resolveAudioSource(input: {
+  preferred: string
+  currentMic: string | null
+  micRanking: string[]
+  glassesConnected: boolean
+}): ResolvedAudioSource {
+  const preferred = input.preferred || "auto"
+  if (preferred === "phone" || preferred === "bluetooth") {
+    return {source: "phone", reason: "explicit"}
+  }
+  if (preferred === "glasses") {
+    return {source: "glasses", reason: "explicit"}
+  }
+  const fromCurrent = mapMic(input.currentMic)
+  if (fromCurrent) return {source: fromCurrent, reason: "current-mic"}
+  const fromRank = mapMic(input.micRanking[0])
+  if (fromRank) return {source: fromRank, reason: "ranking"}
+  return input.glassesConnected
+    ? {source: "glasses", reason: "fallback-glasses-connected"}
+    : {source: "phone", reason: "fallback-no-glasses"}
+}

package/src/utils/devMiniappLaunch.ts

@@ -121,6 +121,10 @@ function collectAlternateHosts(packageName: string, extra?: string[]): string[]
   }
 
   for (const h of extra ?? []) push(h)
+  // USB `adb reverse` publishes the laptop on the phone's loopback. Mentra
+  // Call's QR still advertises the Wi-Fi IP, which AP isolation drops. Try
+  // loopback last so LAN/mDNS keep winning when they work.
+  push("127.0.0.1")
   return hosts
 }