fix: tighten macos hold bounds for the actual ~4.4mb dmg (#415)

Author: juanmahidalgo

src/modules/streamOrFallback.test.ts

@@ -46,25 +46,38 @@ describe('estimateDownloadHoldMs', () => {
   })
 
   describe('when the HEAD request returns a Content-Length and the browser exposes downlink', () => {
+    // ~4.4 MB DMG — the actual size of the current Decentraland macOS
+    // installer, verified via curl HEAD on the gateway. Tauri reuses the
+    // system WebView so the bundle stays small.
+    const DMG_SIZE_BYTES = 4_618_782
+
     beforeEach(() => {
-      // 80 MB in bytes — the macOS DMG ballpark.
-      mockFetch.mockResolvedValue(buildHeadResponse(String(80 * 1024 * 1024)))
+      mockFetch.mockResolvedValue(buildHeadResponse(String(DMG_SIZE_BYTES)))
     })
 
-    it('should compute a hold proportional to size / downlink with the safety margin applied', async () => {
-      // 100 Mbps → 80MB ≈ 6.4s pure transfer + safety margin (~1.5s) → ~7.9s.
+    it('should compute a sub-second hold for fiber-class connections on the real DMG size', async () => {
+      // 4.4 MB at 100 Mbps ≈ 350ms transfer + 500ms safety margin → ~850ms,
+      // which clears the 800ms minimum so the math result is what we expect.
       setNavigatorConnection(100)
       const ms = await estimateDownloadHoldMs('https://example.com/file.dmg')
-      expect(ms).toBeGreaterThanOrEqual(7000)
-      expect(ms).toBeLessThanOrEqual(9000)
+      expect(ms).toBeGreaterThanOrEqual(800)
+      expect(ms).toBeLessThanOrEqual(1100)
     })
 
-    it('should produce a longer hold for a slower connection at the same size', async () => {
-      // 5 Mbps → 80MB ≈ 128s pure transfer, way over ESTIMATE_MAX_HOLD_MS.
-      setNavigatorConnection(5)
+    it('should produce a longer hold on a slow connection but never beyond MAX', async () => {
+      // 4.4 MB at 1 Mbps ≈ 35s pure transfer, way over ESTIMATE_MAX_HOLD_MS.
+      setNavigatorConnection(1)
       const ms = await estimateDownloadHoldMs('https://example.com/file.dmg')
       expect(ms).toBe(ESTIMATE_MAX_HOLD_MS)
     })
+
+    it('should produce a mid-range hold on typical broadband', async () => {
+      // 4.4 MB at 25 Mbps ≈ 1.4s + 500ms margin → ~1.9s. Well within MIN/MAX.
+      setNavigatorConnection(25)
+      const ms = await estimateDownloadHoldMs('https://example.com/file.dmg')
+      expect(ms).toBeGreaterThanOrEqual(1500)
+      expect(ms).toBeLessThanOrEqual(2500)
+    })
   })
 
   describe('when the HEAD request fails', () => {
@@ -102,10 +115,10 @@ describe('estimateDownloadHoldMs', () => {
 
   describe('when the browser does not expose navigator.connection (Safari, Firefox)', () => {
     it('should fall back to the default downlink and still produce an adaptive hold', async () => {
-      // 10 MB at the default 25 Mbps ≈ 3.2s pure transfer + safety margin.
-      // Sized to land between MIN and MAX so the assertion exercises the
-      // adaptive arithmetic rather than the clamps.
-      mockFetch.mockResolvedValue(buildHeadResponse(String(10 * 1024 * 1024)))
+      // 4.4 MB DMG at the default 50 Mbps ≈ 700ms + 500ms margin ≈ 1.2s.
+      // Lands between MIN and MAX so the assertion exercises the adaptive
+      // arithmetic rather than the clamps.
+      mockFetch.mockResolvedValue(buildHeadResponse(String(4_618_782)))
       clearNavigatorConnection()
 
       const ms = await estimateDownloadHoldMs('https://example.com/file.dmg')

src/modules/streamOrFallback.ts

@@ -11,25 +11,25 @@ import type { StreamOrFallbackArgs } from './streamOrFallback.types'
 const FALLBACK_LOADER_HOLD_MS = 4000
 
 // Bandwidth assumption when the browser doesn't expose `navigator.connection`
-// (Safari, Firefox). Conservative middle of "typical broadband" so fast users
-// see the modal close a bit late and slow users see it close a bit early —
-// the alternative (no signal at all) is worse than an imperfect estimate.
-const DEFAULT_DOWNLINK_MBPS = 25
+// (Safari, Firefox). Tuned to modern broadband — the alternative for fast
+// users is the modal hanging long after the file actually landed. Slow users
+// fall through to the browser's own download bar as the real progress signal.
+const DEFAULT_DOWNLINK_MBPS = 50
 
 // Wall-clock margin added on top of the pure transfer estimate to absorb
-// connection setup, HTTP/TLS handshake, server-side processing, and the
-// browser's write-to-disk after the bytes arrive. Picked empirically from
-// typical Mac DMG downloads.
-const ESTIMATE_SAFETY_MARGIN_MS = 1500
+// connection setup, server-side TTFB, and the browser's write-to-disk after
+// the bytes arrive. Sized for the current ~4.4 MB DMG — a flat 1.5s margin
+// dominates total hold time on a small file.
+const ESTIMATE_SAFETY_MARGIN_MS = 500
 
 // Always hold for at least this long so the modal doesn't blink-and-vanish
-// on cache hits / instant downloads.
-const ESTIMATE_MIN_HOLD_MS = 2000
+// on a cache hit / sub-second transfer.
+const ESTIMATE_MIN_HOLD_MS = 800
 
 // Never hang a static (no progress bar) modal beyond this. Past this point
 // the browser's own download manager already shows as the user-facing
 // progress signal — keeping our modal up longer would just look stuck.
-const ESTIMATE_MAX_HOLD_MS = 20000
+const ESTIMATE_MAX_HOLD_MS = 10000
 
 interface NavigatorConnectionLike {
   downlink?: number