@meshconnect/uwc-bridge-child 0.2.2 → 0.2.3-snapshot.35caafb

package/src/BridgeChild.ts

@@ -3,6 +3,12 @@
 
 import * as Comlink from 'comlink'
 import { hasInFrameTonBridge } from './tonInFrameBridge'
+import {
+  MAX_POLL_MS,
+  POLL_INTERVAL_MS,
+  raceParentRead,
+  BridgeReadTimeout
+} from './bridge-timing'
 
 // Define the expected parent API interface locally
 interface ParentAPI {
@@ -23,8 +29,12 @@ export class BridgeChild {
   private parentAPI?: Comlink.Remote<ParentAPI>
   private tronInjectedIds: string[]
   private tonJsBridgeKeys: string[]
-  private tronDiscoveryTriggered = false
-  private tonDiscoveryTriggered = false
+
+  // Per-namespace completion flags so we only marshal each set once.
+  private eip6963Done = false
+  private solanaDone = false
+  private tronDone = false
+  private tonDone = false
 
   constructor(options?: {
     tronInjectedIds?: string[]
@@ -41,241 +51,355 @@ export class BridgeChild {
     }
     window.UWCBridgeChildInitialized = true
 
+    // If another bootstrap already published at least one non-empty wallet
+    // array, skip everything. Matches the old BridgeChild semantics for
+    // embedded flows. Note: a previously-set empty array (`[]`, distinct from
+    // `undefined`) does NOT short-circuit us — another module saying "I
+    // couldn't find any EVM wallets" shouldn't prevent us from still
+    // discovering TON/Tron via the bridge.
+    if (this.anyWindowWalletsAlreadySet()) {
+      return
+    }
+
     this.parentAPI = Comlink.wrap<ParentAPI>(
       Comlink.windowEndpoint(window.parent, self, '*')
     )
 
+    // Tron/TON discovery is driven from the poll loop (tryMarshalTron/Ton),
+    // which re-issues discoverTron/TonWallets every tick until the parent
+    // answers. A single eager trigger here would be silently lost if it raced
+    // the parent's Comlink.expose (Comlink calls hang, never reject).
+
+    // Fetch the parent origin concurrently for TON Connect manifest URL.
+    this.syncParentOrigin()
+
     this.pollForWallets()
   }
 
-  private async pollForWallets(): Promise<void> {
-    const pollInterval = 100
-    const maxPollTime = 10000 // Poll for maximum 10 seconds
-    const startTime = Date.now()
+  private anyWindowWalletsAlreadySet(): boolean {
+    return Boolean(
+      (window.eip6963Wallets && window.eip6963Wallets.length > 0) ||
+      (window.walletStandardWallets &&
+        window.walletStandardWallets.length > 0) ||
+      (window.tronWallets && window.tronWallets.length > 0) ||
+      (window.tonWallets && window.tonWallets.length > 0)
+    )
+  }
 
-    const poll = () => {
-      // Check if we've exceeded the max poll time
-      if (Date.now() - startTime > maxPollTime) {
+  private async syncParentOrigin(): Promise<void> {
+    // Same late-expose hazard as the wallet poll: a parentOrigin read posted
+    // before the parent's Comlink.expose hangs forever (the request message is
+    // dropped, so it never resolves even once the parent comes up). Retry with a
+    // per-read deadline until the parent answers or the poll budget elapses.
+    // A *resolved* read is final, not retried: the current BridgeParent sets
+    // parentOrigin to window.location.origin synchronously before expose, so a
+    // resolved value is always a real origin; a falsy resolve means an older
+    // parent without parentOrigin, where spinning the full budget is pointless.
+    const startTime = Date.now()
+    while (Date.now() - startTime <= MAX_POLL_MS) {
+      try {
+        const origin = await raceParentRead(this.parentAPI?.parentOrigin)
+        if (origin) window.uwcParentOrigin = origin
+        return
+      } catch (err) {
+        if (err instanceof BridgeReadTimeout) {
+          await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS))
+          continue
+        }
+        // Older BridgeParent that throws on parentOrigin — ignore.
         return
       }
+    }
+  }
 
-      // Check if global variables are already set
-      if (
-        (window.eip6963Wallets && window.eip6963Wallets.length > 0) ||
-        (window.walletStandardWallets &&
-          window.walletStandardWallets.length > 0) ||
-        (window.tronWallets && window.tronWallets.length > 0) ||
-        (window.tonWallets && window.tonWallets.length > 0)
-      ) {
+  private pollForWallets(): void {
+    const startTime = Date.now()
+
+    const poll = async () => {
+      if (!this.parentAPI) return
+      if (Date.now() - startTime > MAX_POLL_MS) {
+        this.fillEmptyDefaults()
         return
       }
 
-      if (!this.parentAPI) {
-        setTimeout(poll, pollInterval)
+      // Run all four namespace marshals concurrently. Each short-circuits if
+      // already done or not yet ready, so the cost is a single
+      // `await ready` round-trip per pending namespace per tick.
+      await Promise.all([
+        this.tryMarshalEip6963(),
+        this.tryMarshalSolana(),
+        this.tryMarshalTron(),
+        this.tryMarshalTon()
+      ])
+
+      // Tron/TON have no early default: tryMarshal{Tron,Ton} writes the real
+      // wallets (or [] on a ready-with-empty / unsupported parent), and the
+      // MAX_POLL_MS fillEmptyDefaults backstop covers a parent that never
+      // reports ready. Writing [] earlier would race a still-pending discovery
+      // and make the consumer's one-shot poll miss a wallet that lands a tick
+      // later.
+
+      if (
+        this.eip6963Done &&
+        this.solanaDone &&
+        this.tronDone &&
+        this.tonDone
+      ) {
         return
       }
-
-      // Create a timeout promise to prevent hanging
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error('Timeout accessing parent API')), 100)
-      })
-
-      // Try to check wallets with a timeout
-      Promise.race([this.checkWallets(), timeoutPromise])
-        .then(result => {
-          if (result === 'continue') {
-            // Continue polling
-            setTimeout(poll, pollInterval)
-          }
-          // If result is 'stop', polling will stop
-        })
-        .catch(_error => {
-          // Continue polling on error
-          setTimeout(poll, pollInterval)
-        })
+      setTimeout(poll, POLL_INTERVAL_MS)
     }
 
-    // Start polling immediately
+    // Kick off synchronously — no first-tick delay.
     poll()
   }
 
-  private async checkWallets(): Promise<string> {
+  private fillEmptyDefaults(): void {
+    if (window.eip6963Wallets === undefined) window.eip6963Wallets = []
+    if (window.walletStandardWallets === undefined) {
+      window.walletStandardWallets = []
+    }
+    if (window.tronWallets === undefined) window.tronWallets = []
+    if (window.tonWallets === undefined) window.tonWallets = []
+  }
+
+  private async tryMarshalEip6963(): Promise<void> {
+    if (this.eip6963Done || !this.parentAPI) return
     try {
-      // Check if EIP6963 and Wallet Standard wallets are ready
-      const eip6963Ready = await this.parentAPI?.eip6963WalletsReady
-      const walletStandardReady =
-        await this.parentAPI?.walletStandardWalletsReady
+      const ready = await raceParentRead(this.parentAPI.eip6963WalletsReady)
+      if (!ready) return
+
+      const len = await this.parentAPI.eip6963Wallets.length
+      const wallets: unknown[] = []
+      if (len > 0) {
+        const indices = Array.from({ length: len }, (_, i) => i)
+        const marshalled = await Promise.all(
+          indices.map(async i => {
+            const entry = this.parentAPI!.eip6963Wallets[i]
+            const [uuid, name, icon, rdns] = await Promise.all([
+              entry.uuid,
+              entry.name,
+              entry.icon,
+              entry.rdns
+            ])
+            return { uuid, name, icon, rdns, provider: entry.provider }
+          })
+        )
+        wallets.push(...marshalled)
+      }
+      window.eip6963Wallets = wallets
+      this.eip6963Done = true
+    } catch {
+      // retry on next tick
+    }
+  }
 
-      if (!eip6963Ready || !walletStandardReady) {
-        return 'continue'
+  private async tryMarshalSolana(): Promise<void> {
+    if (this.solanaDone || !this.parentAPI) return
+    try {
+      const ready = await raceParentRead(
+        this.parentAPI.walletStandardWalletsReady
+      )
+      if (!ready) return
+
+      const len = await this.parentAPI.walletStandardWallets.length
+      const wallets: unknown[] = []
+      if (len > 0) {
+        const indices = Array.from({ length: len }, (_, i) => i)
+        const marshalled = await Promise.all(
+          indices.map(async i => {
+            const entry = this.parentAPI!.walletStandardWallets[i]
+            const [uuid, name, chains, features] = await Promise.all([
+              entry.uuid,
+              entry.name,
+              entry.chains,
+              entry.features
+            ])
+            return { uuid, name, chains, features, adapter: entry.adapter }
+          })
+        )
+        wallets.push(...marshalled)
       }
+      window.walletStandardWallets = wallets
+      this.solanaDone = true
+    } catch {
+      // retry on next tick
+    }
+  }
 
-      // Get EIP6963 wallets
-      const availableEip6963Wallets =
-        await this.parentAPI?.eip6963Wallets.length
-      const eip6963Wallets = []
-
-      if (availableEip6963Wallets > 0) {
-        for (let index = 0; index < availableEip6963Wallets; index++) {
-          const wallet = {
-            uuid: await this.parentAPI.eip6963Wallets[index].uuid,
-            name: await this.parentAPI.eip6963Wallets[index].name,
-            icon: await this.parentAPI.eip6963Wallets[index].icon,
-            rdns: await this.parentAPI.eip6963Wallets[index].rdns,
-            provider: this.parentAPI.eip6963Wallets[index].provider
-          }
-          eip6963Wallets.push(wallet)
-        }
+  private async tryMarshalTron(): Promise<void> {
+    if (this.tronDone || !this.parentAPI) return
+
+    // (Re-)ask the parent to run Tron discovery on every tick. A one-shot
+    // trigger is silently lost if posted before the parent's Comlink.expose (the
+    // request hangs, never rejects), so re-issuing mirrors EIP-6963's per-tick
+    // resilience. Comlink calls return a Promise and never throw synchronously,
+    // so an unsupported parent is handled by the tronWalletsReady read below (or
+    // the MAX_POLL_MS backstop) — not here. The try only guards a non-Comlink
+    // stub whose call throws synchronously.
+    // Each pre-expose reissue leaves one lightweight Comlink pending-listener
+    // Map entry (requestResponseMessage — not a DOM listener or MessageChannel
+    // port); bounded by the expose delay and GC'd. An in-flight guard is
+    // intentionally avoided: it would deadlock recovery, since a never-settling
+    // pre-expose call would block all subsequent re-issues.
+    //
+    // Fired in a detached async IIFE so that the await — needed to make the
+    // try/catch absorb both sync throws (test stubs) and async rejections —
+    // does not block this tick. A pre-expose hang sits inside the IIFE
+    // harmlessly until the parent comes up or GC reaps it.
+    void (async () => {
+      try {
+        await this.parentAPI.discoverTronWallets?.(this.tronInjectedIds)
+      } catch {
+        // absorb — the readiness read below governs the outcome
       }
+    })()
 
-      // Get Wallet Standard wallets
-      const availableWalletStandardWallets =
-        await this.parentAPI.walletStandardWallets.length
-      const walletStandardWallets = []
-
-      if (availableWalletStandardWallets > 0) {
-        for (let index = 0; index < availableWalletStandardWallets; index++) {
-          const wallet = {
-            uuid: await this.parentAPI.walletStandardWallets[index].uuid,
-            name: await this.parentAPI.walletStandardWallets[index].name,
-            chains: await this.parentAPI.walletStandardWallets[index].chains,
-            features:
-              await this.parentAPI.walletStandardWallets[index].features,
-            adapter: this.parentAPI.walletStandardWallets[index].adapter
-          }
-          walletStandardWallets.push(wallet)
-        }
+    let ready
+    try {
+      ready = await raceParentRead(this.parentAPI.tronWalletsReady)
+    } catch (err) {
+      // Read timed out → parent not live yet, retry next tick. Any other error
+      // (older parent throwing on the property) → no Tron support.
+      if (err instanceof BridgeReadTimeout) {
+        return
       }
+      window.tronWallets = []
+      this.tronDone = true
+      return
+    }
 
-      // Get Tron wallets - wrapped in try/catch for backward compatibility
-      // with older BridgeParent versions that don't have Tron support
-      let tronWallets: unknown[] = []
-      try {
-        if (!this.tronDiscoveryTriggered) {
-          await this.parentAPI?.discoverTronWallets?.(this.tronInjectedIds)
-          this.tronDiscoveryTriggered = true
-        }
+    if (!ready) return
 
-        const tronReady = await this.parentAPI?.tronWalletsReady
-        if (tronReady) {
-          const availableTronWallets = await this.parentAPI.tronWallets.length
-
-          if (availableTronWallets > 0) {
-            for (let index = 0; index < availableTronWallets; index++) {
-              const wallet = {
-                uuid: await this.parentAPI.tronWallets[index].uuid,
-                name: await this.parentAPI.tronWallets[index].name,
-                injectedId: await this.parentAPI.tronWallets[index].injectedId,
-                provider: this.parentAPI.tronWallets[index].provider
-              }
-              tronWallets.push(wallet)
-            }
-          }
-        }
-      } catch {
-        // Parent doesn't support Tron - use empty array
-        tronWallets = []
+    try {
+      const len = await this.parentAPI.tronWallets.length
+      const wallets: unknown[] = []
+      if (len > 0) {
+        const indices = Array.from({ length: len }, (_, i) => i)
+        const marshalled = await Promise.all(
+          indices.map(async i => {
+            const entry = this.parentAPI!.tronWallets[i]
+            const [uuid, name, injectedId] = await Promise.all([
+              entry.uuid,
+              entry.name,
+              entry.injectedId
+            ])
+            return { uuid, name, injectedId, provider: entry.provider }
+          })
+        )
+        wallets.push(...marshalled)
       }
+      window.tronWallets = wallets
+      this.tronDone = true
+    } catch {
+      window.tronWallets = []
+      this.tronDone = true
+    }
+  }
 
-      // Get TON wallets - wrapped in try/catch for backward compatibility
-      // with older BridgeParent versions that don't have TON support
-      let tonWallets: unknown[] = []
-      try {
-        if (!this.tonDiscoveryTriggered) {
-          await this.parentAPI?.discoverTonWallets?.(this.tonJsBridgeKeys)
-          this.tonDiscoveryTriggered = true
-        }
+  private async tryMarshalTon(): Promise<void> {
+    if (this.tonDone || !this.parentAPI) return
 
-        const tonReady = await this.parentAPI?.tonWalletsReady
-        if (tonReady) {
-          const availableTonWallets = await this.parentAPI.tonWallets.length
-
-          if (availableTonWallets > 0) {
-            for (let index = 0; index < availableTonWallets; index++) {
-              const wallet = {
-                uuid: await this.parentAPI.tonWallets[index].uuid,
-                name: await this.parentAPI.tonWallets[index].name,
-                icon: await this.parentAPI.tonWallets[index].icon,
-                jsBridgeKey: await this.parentAPI.tonWallets[index].jsBridgeKey,
-                provider: this.parentAPI.tonWallets[index].provider
-              }
-              tonWallets.push(wallet)
-            }
-          }
-        }
+    // Re-issue discovery each tick — same expose-race resilience as Tron.
+    // See tryMarshalTron for the detached-IIFE rationale.
+    void (async () => {
+      try {
+        await this.parentAPI.discoverTonWallets?.(this.tonJsBridgeKeys)
       } catch {
-        // Parent doesn't support TON - use empty array
-        tonWallets = []
+        // absorb — the readiness read below governs the outcome
       }
+    })()
 
-      // Set parent origin on window for TON Connect manifest URL resolution
-      try {
-        const origin = await this.parentAPI?.parentOrigin
-        if (origin) {
-          window.uwcParentOrigin = origin
-        }
-      } catch {
-        // Parent doesn't support parentOrigin - older BridgeParent version
+    let ready
+    try {
+      ready = await raceParentRead(this.parentAPI.tonWalletsReady)
+    } catch (err) {
+      if (err instanceof BridgeReadTimeout) return
+      window.tonWallets = []
+      this.tonDone = true
+      return
+    }
+    if (!ready) return
+
+    try {
+      const len = await this.parentAPI.tonWallets.length
+      const wallets: Array<{
+        uuid: string
+        name: string
+        icon: string
+        jsBridgeKey: string
+        provider: any
+      }> = []
+
+      if (len > 0) {
+        const indices = Array.from({ length: len }, (_, i) => i)
+        const marshalled = await Promise.all(
+          indices.map(async i => {
+            const entry = this.parentAPI!.tonWallets[i]
+            const [uuid, name, icon, jsBridgeKey] = await Promise.all([
+              entry.uuid,
+              entry.name,
+              entry.icon,
+              entry.jsBridgeKey
+            ])
+            return { uuid, name, icon, jsBridgeKey, provider: entry.provider }
+          })
+        )
+        wallets.push(...marshalled)
       }
 
-      // Set all wallet types on window
-      window.eip6963Wallets = eip6963Wallets
-      window.walletStandardWallets = walletStandardWallets
-      window.tronWallets = tronWallets
-      window.tonWallets = tonWallets
-
-      // Shim window[jsBridgeKey].tonconnect so @tonconnect/sdk finds the Comlink proxy.
-      // We build a local adapter because:
-      // - Static props (deviceInfo, walletInfo) must be sync, but Comlink returns Promises
-      // - listen(callback) can't send functions via postMessage without Comlink.proxy()
-      // - listen() must return a sync unsubscribe function, not a Promise
-      for (const wallet of tonWallets as {
-        jsBridgeKey?: string
-        provider?: any
-      }[]) {
-        if (!wallet.jsBridgeKey || !wallet.provider) continue
-
-        // keep a real in-frame provider so connect() attributes to the
-        // iframe origin; shimming it would attribute to the parent, which the
-        // wallet's manifest origin check rejects.
-        if (hasInFrameTonBridge(wallet.jsBridgeKey)) continue
-
-        const proxy = wallet.provider
-        // Read static properties upfront (they were transferred as values by Comlink)
-        const deviceInfo = await proxy.deviceInfo
-        const walletInfo = await proxy.walletInfo
-        const protocolVersion = await proxy.protocolVersion
-        const isWalletBrowser = await proxy.isWalletBrowser
-
-        ;(window as any)[wallet.jsBridgeKey] = {
-          tonconnect: {
-            deviceInfo,
-            walletInfo,
-            protocolVersion: protocolVersion ?? 2,
-            isWalletBrowser: isWalletBrowser ?? false,
-            connect: (ver: number, msg: unknown) => proxy.connect(ver, msg),
-            restoreConnection: () => proxy.restoreConnection(),
-            send: (msg: unknown) => proxy.send(msg),
-            listen: (callback: (event: unknown) => void) => {
-              const proxiedCallback = Comlink.proxy(callback)
-              let unsubscribe: (() => void) | null = null
-              const result = proxy.listen(proxiedCallback)
-              // Comlink returns a Promise; direct calls return the value
-              Promise.resolve(result).then((unsub: unknown) => {
-                unsubscribe = typeof unsub === 'function' ? unsub : () => {}
-              })
-              return () => {
-                if (unsubscribe) unsubscribe()
-              }
-            },
-            disconnect: () => proxy.disconnect?.()
+      window.tonWallets = wallets
+
+      // Shim window[jsBridgeKey].tonconnect so @tonconnect/sdk finds the
+      // Comlink proxy. Static props must be sync, but Comlink returns
+      // Promises — so we prefetch them here in parallel.
+      await Promise.all(
+        wallets.map(async wallet => {
+          if (!wallet.jsBridgeKey || !wallet.provider) return
+          // Keep the real in-frame provider so connect() attributes to the
+          // iframe origin; shimming would attribute to the parent, which the
+          // wallet's manifest origin check rejects.
+          if (hasInFrameTonBridge(wallet.jsBridgeKey)) return
+          const proxy = wallet.provider
+          const [deviceInfo, walletInfo, protocolVersion, isWalletBrowser] =
+            await Promise.all([
+              proxy.deviceInfo,
+              proxy.walletInfo,
+              proxy.protocolVersion,
+              proxy.isWalletBrowser
+            ])
+
+          ;(window as any)[wallet.jsBridgeKey] = {
+            tonconnect: {
+              deviceInfo,
+              walletInfo,
+              protocolVersion: protocolVersion ?? 2,
+              isWalletBrowser: isWalletBrowser ?? false,
+              connect: (ver: number, msg: unknown) => proxy.connect(ver, msg),
+              restoreConnection: () => proxy.restoreConnection(),
+              send: (msg: unknown) => proxy.send(msg),
+              listen: (callback: (event: unknown) => void) => {
+                const proxiedCallback = Comlink.proxy(callback)
+                let unsubscribe: (() => void) | null = null
+                const result = proxy.listen(proxiedCallback)
+                Promise.resolve(result).then((unsub: unknown) => {
+                  unsubscribe = typeof unsub === 'function' ? unsub : () => {}
+                })
+                return () => {
+                  if (unsubscribe) unsubscribe()
+                }
+              },
+              disconnect: () => proxy.disconnect?.()
+            }
           }
-        }
-      }
+        })
+      )
 
-      return 'stop'
+      this.tonDone = true
     } catch {
-      return 'continue'
+      // Parent doesn't support TON — mark done with empty list.
+      window.tonWallets = []
+      this.tonDone = true
     }
   }
 }

package/src/bridge-timing.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { raceParentRead, BridgeReadTimeout } from './bridge-timing'
+
+describe('raceParentRead', () => {
+  beforeEach(() => vi.useFakeTimers())
+  afterEach(() => vi.useRealTimers())
+
+  it('resolves with the value when the read settles before the deadline', async () => {
+    const result = await raceParentRead(Promise.resolve('origin'))
+    expect(result).toBe('origin')
+  })
+
+  it('resolves a non-promise value', async () => {
+    const result = await raceParentRead(true)
+    expect(result).toBe(true)
+  })
+
+  it('rejects with BridgeReadTimeout when the read never settles', async () => {
+    const neverSettles = new Promise<string>(() => {})
+    const assertion = expect(
+      raceParentRead(neverSettles)
+    ).rejects.toBeInstanceOf(BridgeReadTimeout)
+    await vi.advanceTimersByTimeAsync(200)
+    await assertion
+  })
+
+  it('clears the deadline timer on the winning-read path (no leaked timer)', async () => {
+    const clearSpy = vi.spyOn(globalThis, 'clearTimeout')
+    await raceParentRead(Promise.resolve('x'))
+    expect(clearSpy).toHaveBeenCalled()
+    clearSpy.mockRestore()
+  })
+})

package/src/bridge-timing.ts

@@ -0,0 +1,52 @@
+/**
+ * Timing primitives for the bridge child's wallet poll.
+ *
+ * Extracted into a typed module (BridgeChild.ts is `@ts-nocheck`) so this
+ * infrastructure is type-checked.
+ */
+
+// Child's give-up deadline for the wallet poll: writes [] via fillEmptyDefaults
+// if the parent never reports ready. The injected-connector consumer derives its
+// own poll budget (BRIDGE_WALLET_POLL_MS) from this and MUST exceed it, so it can
+// observe a wallet the child marshals on its final tick.
+export const MAX_POLL_MS = 5000
+
+export const POLL_INTERVAL_MS = 50
+
+// A parent read is a postMessage round-trip — typically <5ms, so 150ms is
+// generous. A spurious timeout (parent briefly busy) just retries on the next
+// tick; it never drops a result.
+const PARENT_READ_TIMEOUT_MS = 150
+
+export class BridgeReadTimeout extends Error {
+  constructor() {
+    super('bridge parent read timed out')
+    this.name = 'BridgeReadTimeout'
+  }
+}
+
+/**
+ * A Comlink read to a parent that hasn't `Comlink.expose`d yet never settles
+ * (comlink's `requestResponseMessage` has no timeout, and the request message is
+ * dropped — so it won't resolve even once the parent comes up; a *new* read must
+ * be posted). The parent is typically created on the iframe's `load` event,
+ * which can fire after the child starts polling, so the first reads would hang
+ * the poll loop forever. Race every read against a short deadline so a pre-expose
+ * tick rejects (and the caller retries) instead of stalling.
+ */
+export function raceParentRead<T>(
+  read: PromiseLike<T> | T
+): Promise<Awaited<T>> {
+  let timer: ReturnType<typeof setTimeout> | undefined
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(
+      () => reject(new BridgeReadTimeout()),
+      PARENT_READ_TIMEOUT_MS
+    )
+  })
+  // clearTimeout on settle so a winning read doesn't leak a pending timer. (The
+  // losing Comlink read can't be cancelled, but the timer can.)
+  return Promise.race([Promise.resolve(read), timeout]).finally(() =>
+    clearTimeout(timer)
+  )
+}