@kabmo-labs/kabmo 0.8.0 → 0.9.0

package/src/client/hooks/editor/use-scroll-restore.test.ts

@@ -161,6 +161,19 @@ function storedOffsets(): ScrollPositions | undefined {
   return getSessionValue<ScrollPositions>(SESSION, SCROLL_POSITIONS_KEY);
 }
 
+/**
+ * A READER's scroll: the input that causes it, then the movement.
+ *
+ * The hook distinguishes the two, and it has to: a `scroll` with no input behind
+ * it is the browser re-anchoring the document as its real height lands, which
+ * must NOT be read as the reader moving. `wheel` is the simplest input a code
+ * surface sees.
+ */
+function readerScroll(probe: ProbeHandle, top: number): void {
+  probe.el.dispatchEvent(new Event('wheel', { bubbles: true }));
+  probe.el.scrollTop = top;
+}
+
 describe('useScrollRestore', () => {
   test('restores the stored offset for the tab and surface', async () => {
     const probe = await mount('7', 'code', { '7': { code: 900 } });
@@ -181,7 +194,47 @@ describe('useScrollRestore', () => {
 
   test("a reader's own scroll wins over a pending restore", async () => {
     const probe = await mount('7', 'code', { '7': { code: 900 } });
-    probe.el.scrollTop = 120;
+    readerScroll(probe, 120);
+    await act(async () => {
+      StubResizeObserver.latest()?.fire();
+    });
+    expect(probe.el.scrollTop).toBe(120);
+  });
+
+  test('the document re-anchoring is not the reader, and the restore re-applies', async () => {
+    // The bug the e2e spec found: the restore writes 900, the document's real
+    // height lands a frame later, and CodeMirror re-anchors to keep the visible
+    // content stable — `scrollTop` moves to 420 with nobody assigning. Reading
+    // that as the reader's own scroll dropped the pending restore, so the
+    // anchored value became where the reader stayed (measured: opening a tab
+    // moved them 29 lines) and the wrong offset was persisted.
+    const probe = await mount('7', 'code', { '7': { code: 900 } }, 600);
+    expect(probe.el.scrollTop).toBe(100);
+
+    // The browser's own correction: no input event behind it.
+    probe.el.scrollTop = 420;
+    probe.setHeight(5000);
+    await act(async () => {
+      StubResizeObserver.latest()?.fire();
+    });
+
+    // The restore is still in charge, so the reader lands where the session
+    // recorded — not where the anchoring put them.
+    expect(probe.el.scrollTop).toBe(900);
+  });
+
+  test('a reader’s scroll is still theirs after an anchoring correction', async () => {
+    // The discriminator must not swallow the NEXT real scroll: the input that
+    // explains a movement is consumed by it, so a reader who scrolls after the
+    // document settles keeps their own position.
+    const probe = await mount('7', 'code', { '7': { code: 900 } });
+    probe.el.scrollTop = 420; // anchoring, no input
+    await act(async () => {
+      StubResizeObserver.latest()?.fire();
+    });
+    expect(probe.el.scrollTop).toBe(900);
+
+    readerScroll(probe, 120);
     await act(async () => {
       StubResizeObserver.latest()?.fire();
     });
@@ -192,7 +245,7 @@ describe('useScrollRestore', () => {
     const probe = await mount('7', 'code', {});
     jest.useFakeTimers();
     try {
-      probe.el.scrollTop = 350;
+      readerScroll(probe, 350);
       jest.advanceTimersByTime(200);
       await act(async () => {});
     } finally {

package/src/client/hooks/editor/use-scroll-restore.ts

@@ -32,7 +32,7 @@
  *   overwrite the position this hook exists to keep.
  */
 
-import { useCallback, useContext, useLayoutEffect, useRef } from 'preact/hooks';
+import { useCallback, useContext, useEffect, useLayoutEffect, useRef } from 'preact/hooks';
 import { SessionStateContext } from '@/client/hooks/workspace/session-state/context';
 import { getSessionValue, setSessionKey } from '@/shared/lib/workspace/session-state/store';
 import {
@@ -52,6 +52,29 @@ const SAVE_DEBOUNCE_MS = 150;
 /** Scroll deltas below this are rounding, not a move. */
 const NOISE_PX = 1;
 
+/**
+ * The cancel hook of every restore currently armed, by scroller.
+ *
+ * A pending restore REPLAYS while the document settles, and it re-applies
+ * through a `ResizeObserver` — which can fire BEFORE the scroll event a
+ * programmatic reveal causes. Measured: an outline jump scrolled a 2 520-line
+ * file to 34 695 px and the observer wrote the stored 0 back 375 ms later, so
+ * the caret moved and the view stayed at the top.
+ *
+ * An explicit reveal therefore has to CANCEL the restore rather than race it,
+ * and the surface that scrolls is the one that knows. This registry is that
+ * hand-off: keyed by the element, so a caller needs no reference to the hook
+ * instance that armed it (the surface owns the scroller; the panel owns the
+ * hook).
+ */
+const armedRestores = new Map<HTMLElement, () => void>();
+
+/** Stop a pending restore of `element` — a reveal wins over a remembered offset. */
+export function cancelScrollRestore(element: HTMLElement | null): void {
+  if (!element) return;
+  armedRestores.get(element)?.();
+}
+
 /** What a caller attaches to its scroll container. */
 export interface ScrollRestoreBinding {
   ref: (element: HTMLElement | null) => void;
@@ -67,6 +90,16 @@ export interface UseScrollRestoreOptions {
   ready?: boolean;
   /** The session-state slot to read/write; the editor column's by default. */
   slot?: string;
+  /**
+   * The element to restore, for a caller that does not own a `ref` on it.
+   *
+   * The code surface's scroller belongs to CodeMirror (`view.scrollDOM`) and
+   * exists only after the view mounts, so the surface reports it through
+   * `onScroller` and the caller passes it here. `undefined` means "this caller
+   * uses `ref`"; `null` means "the element is not there yet", which re-arms the
+   * restore on the next render that has one.
+   */
+  element?: HTMLElement | null;
 }
 
 export function useScrollRestore({
@@ -74,6 +107,7 @@ export function useScrollRestore({
   surface,
   ready = true,
   slot = SCROLL_POSITIONS_KEY,
+  element: providedElement,
 }: UseScrollRestoreOptions): ScrollRestoreBinding {
   // Read OPTIONALLY: the shared diff views also draw a chat tool card, and a
   // caller may mount one without the provider. A null context makes the whole
@@ -100,6 +134,37 @@ export function useScrollRestore({
    * whose height is still growing then stayed where the clamp left it.
    */
   const writingRef = useRef(false);
+  /**
+   * What the element's `scrollTop` was at the last observation, so a scroll
+   * event that moves it WITHOUT anyone assigning can be recognised as the
+   * browser's own anchoring rather than the reader's.
+   *
+   * This is the bug the e2e spec found on CI and could not explain: returning to
+   * a long file landed the reader on line 99 instead of line 70, and the wrong
+   * offset was then persisted. Measured in the browser: the restore wrote 1255,
+   * the document's real height arrived a frame later (5796 → 7232), and
+   * CodeMirror re-anchored — `scrollTop` became 1777 with no assignment from
+   * this hook. That produced a `scroll` event, the handler below compared it
+   * against `restoredTopRef` (1255), read a 522px delta, and treated it as the
+   * reader's own scroll: the pending restore was dropped, and the anchored
+   * value became what got stored. The reader moved 29 lines for opening a tab.
+   *
+   * An anchoring correction is not a reader. It is re-applied like any other
+   * height change, because the target offset is the one the session recorded.
+   */
+  const observedTopRef = useRef(0);
+  /**
+   * Whether the reader has DONE something since the last scroll event — the
+   * only thing that separates their scroll from the browser's own.
+   *
+   * Every way a reader scrolls a code surface starts with an input event: a
+   * wheel, a key (arrows, PageDown, Home/End), a pointer press on the scrollbar
+   * or a drag-select, a touch. CodeMirror re-anchoring starts with none, so a
+   * `scroll` with no input behind it is the document settling. The flag is
+   * cleared by the scroll it explains, so the next unattributed move is read as
+   * anchoring again.
+   */
+  const readerIntentRef = useRef(false);
   /** The last offset the READER produced, persisted on the way out. */
   const lastTopRef = useRef<number | null>(null);
   const saveTimerRef = useRef<ReturnType<typeof setTimeout>>();
@@ -113,13 +178,17 @@ export function useScrollRestore({
       pendingRef.current = null;
       return;
     }
-    if (Math.abs(element.scrollTop - pending.top) < NOISE_PX) return;
+    if (Math.abs(element.scrollTop - pending.top) < NOISE_PX) {
+      observedTopRef.current = element.scrollTop;
+      return;
+    }
     writingRef.current = true;
     element.scrollTop = pending.top;
     writingRef.current = false;
     // Read back: the document may be shorter than the target, and the clamped
     // value is what an asynchronous scroll event will report.
     restoredTopRef.current = element.scrollTop;
+    observedTopRef.current = element.scrollTop;
   }, []);
 
   const attach = useCallback(
@@ -152,9 +221,23 @@ export function useScrollRestore({
       // because the event may arrive synchronously (during the assignment) or
       // on a later frame (against the value the write landed on).
       if (writingRef.current) return;
+      // Moved with nobody assigning AND no reader input behind it: CodeMirror
+      // re-anchoring after the document's real height landed. NOT the reader —
+      // re-applying the recorded offset is what keeps them where they were. See
+      // `observedTopRef` for the measurement.
+      const moved = Math.abs(top - observedTopRef.current) >= NOISE_PX;
+      observedTopRef.current = top;
+      if (moved && !readerIntentRef.current) {
+        applyPending();
+        return;
+      }
       if (Math.abs(top - restoredTopRef.current) < NOISE_PX * 2) return;
       pendingRef.current = null;
     }
+    observedTopRef.current = top;
+    // The input this scroll belongs to has now been accounted for; the next
+    // unattributed move is anchoring again.
+    readerIntentRef.current = false;
     lastTopRef.current = top;
     clearTimeout(saveTimerRef.current);
     saveTimerRef.current = setTimeout(() => {
@@ -162,14 +245,47 @@ export function useScrollRestore({
       const value = lastTopRef.current;
       if (value !== null) persist(value);
     }, SAVE_DEBOUNCE_MS);
-  }, [persist, tabKey]);
+  }, [applyPending, persist, tabKey]);
+
+  // A provided element is not a React-rendered node, so its scroll events have
+  // to be wired here: the caller has no `onScroll` prop to hang them on. The
+  // ref path keeps the caller's own `onScroll`.
+  useEffect(() => {
+    if (!providedElement) return;
+    const listener = () => onScroll();
+    providedElement.addEventListener('scroll', listener, { passive: true });
+    return () => providedElement.removeEventListener('scroll', listener);
+  }, [providedElement, onScroll]);
+
+  // What counts as the reader having scrolled, for `readerIntentRef`. Wired on
+  // the element AND the window, because a keydown goes to the focused editor
+  // while a wheel over the gutter goes to the window's capture phase.
+  useEffect(() => {
+    const element = providedElement ?? elementRef.current;
+    if (!element) return;
+    const note = () => {
+      readerIntentRef.current = true;
+    };
+    const types = ['wheel', 'keydown', 'pointerdown', 'touchstart'] as const;
+    for (const type of types) element.addEventListener(type, note, { passive: true });
+    window.addEventListener('keydown', note, { passive: true });
+    return () => {
+      for (const type of types) element.removeEventListener(type, note);
+      window.removeEventListener('keydown', note);
+    };
+  }, [providedElement]);
 
   // A layout effect so the restore lands in the same frame the tab paints — a
   // passive effect would show the document's head for one frame first.
   useLayoutEffect(() => {
     pendingRef.current = null;
     lastTopRef.current = null;
+    readerIntentRef.current = false;
     let observer: ResizeObserver | null = null;
+    // A provided element WINS over the ref: the caller handed us the element it
+    // wants restored, and a stale ref from the other surface of the same tab
+    // must not be restored instead.
+    if (providedElement !== undefined) elementRef.current = providedElement;
     const element = elementRef.current;
 
     if (ready && storeReady && tabKey && element) {
@@ -179,6 +295,9 @@ export function useScrollRestore({
       // of it. "No stored offset" means the top, and the top is where they go.
       const top = readScrollTop(getSessionValue<ScrollPositions>(sessionId, slot), tabKey, surface);
       pendingRef.current = { top, until: performance.now() + RESTORE_WINDOW_MS };
+      armedRestores.set(element, () => {
+        pendingRef.current = null;
+      });
       applyPending();
       // The document's own height is what moves after this commit (measurement,
       // a width animation, spacers landing), so its growth is what re-applies.
@@ -190,6 +309,7 @@ export function useScrollRestore({
     }
 
     return () => {
+      if (element) armedRestores.delete(element);
       observer?.disconnect();
       clearTimeout(saveTimerRef.current);
       saveTimerRef.current = undefined;
@@ -203,7 +323,7 @@ export function useScrollRestore({
     };
     // `applyPending`/`persist` are stable, and re-running this effect restarts
     // the restore — which is exactly what a tab or surface change needs.
-  }, [ready, storeReady, tabKey, surface, sessionId, slot, applyPending, persist]);
+  }, [ready, storeReady, tabKey, surface, sessionId, slot, applyPending, persist, providedElement]);
 
   return { ref: attach, onScroll };
 }

package/src/client/hooks/editor/use-search-reveal.ts

@@ -29,7 +29,7 @@
 import { useEffect, useMemo, useState } from 'preact/hooks';
 import { useSyncExternalStore } from 'preact/compat';
 
-import { findMatches, lineStartOffset, matchIndexAtOrAfter } from '@/shared/lib/code/editor/find';
+import { findMatches, lineStartOffset, matchIndexAtOrAfter } from '@/shared/lib/code/editor/find-scan';
 import {
   getSearchReveal,
   setSearchReveal,

package/src/client/hooks/ui/settings-modal.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The desktop layout's settings modal: whether it is open, which category it
+ * opens on, and whether a provider dialog follows.
+ *
+ * A hook because two different triggers drive it — the sidebar footer's button
+ * and the `omp:open-settings` window event (dispatched by the model dropdown,
+ * the phone's footer and any plugin) — and the event carries the category it
+ * wants. Stated once, the two paths cannot open the same modal on different
+ * screens.
+ */
+
+import { useState } from 'preact/hooks';
+import { useKabmoEvent } from '@/client/hooks/ui/window-event';
+import type { SettingsCategoryId } from '@/shared/types';
+
+export interface SettingsModalState {
+  isOpen: boolean;
+  category: SettingsCategoryId;
+  /** The "add provider" dialog opens on top of the modal's Providers screen. */
+  autoOpenAddProvider: boolean;
+  open: (category?: SettingsCategoryId, autoOpenAdd?: boolean) => void;
+  close: () => void;
+}
+
+export function useSettingsModal(): SettingsModalState {
+  const [isOpen, setOpen] = useState(false);
+  const [category, setCategory] = useState<SettingsCategoryId>('appearance');
+  const [autoOpenAddProvider, setAutoOpenAddProvider] = useState(false);
+
+  const open = (next?: SettingsCategoryId, autoOpenAdd = false) => {
+    setCategory(next ?? 'appearance');
+    setAutoOpenAddProvider(autoOpenAdd);
+    setOpen(true);
+  };
+
+  useKabmoEvent('omp:open-settings', (event) => {
+    const detail = (event as CustomEvent<{ category?: SettingsCategoryId; autoOpenAdd?: boolean }>).detail;
+    open(detail?.category, Boolean(detail?.autoOpenAdd));
+  });
+
+  return {
+    isOpen,
+    category,
+    autoOpenAddProvider,
+    open,
+    close: () => {
+      setOpen(false);
+      setAutoOpenAddProvider(false);
+    },
+  };
+}

package/src/client/hooks/ui/updates/shell-download.test.ts

@@ -21,6 +21,7 @@ const RELEASE = {
   url: 'https://github.com/kabmo-labs/kabmo/releases/download/v1.2.3/Kabmo-1.2.3-android.apk',
   latest: '1.2.3',
   releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v1.2.3',
+  direct: true,
 };
 
 const UPDATE: ShellDownload = { ...RELEASE, kind: 'update', platform: 'android' };
@@ -209,6 +210,7 @@ describe('desktopShellFromIdentity', () => {
     expect(desktopShellFromIdentity({ platform: 'macos', shellVersion: '0.2.0' })).toEqual({
       platform: 'macos',
       version: '0.2.0',
+      arch: null,
     });
     expect(desktopShellFromIdentity({ platform: 'windows', shellVersion: '0.2.0' })?.platform).toBe('windows');
     expect(desktopShellFromIdentity({ platform: 'linux', shellVersion: '0.2.0' })?.platform).toBe('linux');

package/src/client/hooks/ui/updates/shell-download.ts

@@ -29,6 +29,7 @@
 
 import { useEffect, useState } from 'preact/hooks';
 import { isNewer } from '@/shared/lib/updates/semver';
+import { parseShellArch, type ShellArch } from '@/shared/lib/updates/shell-arch';
 import {
   isDesktopShellKind,
   type DesktopShellKind,
@@ -43,11 +44,13 @@ export type ShellOfferKind = 'update' | 'install';
 
 export interface ShellDownload {
   /**
-   * What the control links to.
+   * What the control points at.
    *
    * The artifact itself for the mobile pair (an APK the shell installs, an IPA
-   * the release page explains), and the RELEASE PAGE for a desktop shell: every
-   * desktop build is per-architecture, so the console cannot name one file.
+   * the release page explains), and for a desktop shell EITHER its own
+   * per-architecture artifact (when it reported `arch`) or the RELEASE PAGE (when
+   * it did not). `direct` says which, and that is what decides between a button
+   * and a link.
    */
   url: string;
   /** The version that artifact ships. */
@@ -58,12 +61,22 @@ export interface ShellDownload {
   kind: ShellOfferKind;
   /** Which shell this offer is for. */
   platform: ShellPlatform;
+  /**
+   * True when `url` is the artifact itself, so the SHELL can install it.
+   *
+   * False means `url` is the release page: the console cannot name one file
+   * (a desktop shell that did not report its architecture), so the offer is a
+   * link a human follows. That distinction is what decides between an `<a>` and
+   * a button that drives `update_apply`.
+   */
+  direct: boolean;
 }
 
 interface ReleasePayload {
   url?: unknown;
   latest?: unknown;
   releaseUrl?: unknown;
+  direct?: unknown;
 }
 
 /** The platform's own name, as the label says it. */
@@ -91,6 +104,10 @@ export function parseShellRelease(payload: unknown): Omit<ShellDownload, 'kind'
     url: body.url,
     latest: body.latest,
     releaseUrl: typeof body.releaseUrl === 'string' ? body.releaseUrl : null,
+    // Absent means "not installable": a shell that cannot install the bytes must
+    // fall back to the link rather than to a button that would download into
+    // nowhere.
+    direct: body.direct === true,
   };
 }
 
@@ -147,8 +164,14 @@ export function shellDownloadLabel(download: ShellDownload): string {
  * The desktop trio shares ONE route with an explicit `kind`, so no absence can
  * silently mean a platform — the reason the mobile pair has two.
  */
-export function shellReleasePath(platform: ShellPlatform): string {
-  if (isDesktopShellKind(platform)) return `/api/updates/desktop?kind=${platform}`;
+export function shellReleasePath(platform: ShellPlatform, arch: ShellArch | null = null): string {
+  if (isDesktopShellKind(platform)) {
+    // The arch is what makes the answer a FILE rather than a page. A shell that
+    // did not report one still asks, and still gets the page that lists every
+    // architecture — the offer is then a link, which is the honest fallback.
+    const base = `/api/updates/desktop?kind=${platform}`;
+    return arch ? `${base}&arch=${arch}` : base;
+  }
   return `/api/updates/${platform}`;
 }
 
@@ -182,10 +205,17 @@ export function shellFromBootstrap(bootstrap: {
 export function desktopShellFromIdentity(identity: {
   platform?: string;
   shellVersion?: string;
-} | null | undefined): { platform: DesktopShellKind; version: string } | null {
+  arch?: string;
+} | null | undefined): { platform: DesktopShellKind; version: string; arch: ShellArch | null } | null {
   if (!identity?.platform || !identity.shellVersion) return null;
   if (!isDesktopShellKind(identity.platform)) return null;
-  return { platform: identity.platform, version: identity.shellVersion };
+  return {
+    platform: identity.platform,
+    version: identity.shellVersion,
+    // A shell too old to report one keeps working: the offer degrades to the
+    // release page instead of disappearing.
+    arch: parseShellArch(identity.arch),
+  };
 }
 
 /**
@@ -200,6 +230,7 @@ export function useShellDownload(
   version: string | null | undefined,
   onAndroid: boolean | null | undefined,
   fetchImpl: typeof fetch = fetch,
+  arch: ShellArch | null = null,
 ): ShellDownload | null {
   /**
    * The answer, TAGGED with the platform it was read for.
@@ -210,10 +241,14 @@ export function useShellDownload(
    * — offering an Android APK to a Mac for one render.
    */
   const [answer, setAnswer] = useState<{
-    platform: ShellPlatform;
+    key: string;
     release: Omit<ShellDownload, 'kind' | 'platform'> | null;
   } | null>(null);
   const wanted = Boolean(version) || (platform === 'android' && Boolean(onAndroid));
+  // The question this hook is asking, arch included: two windows on one console
+  // differ only by architecture, and an answer read for the other one is not an
+  // answer.
+  const key = `${platform}:${arch ?? ''}`;
 
   useEffect(() => {
     if (!wanted) return;
@@ -221,10 +256,10 @@ export function useShellDownload(
     let cancelled = false;
     void (async () => {
       try {
-        const response = await fetchImpl(shellReleasePath(platform));
+        const response = await fetchImpl(shellReleasePath(platform, arch));
         if (!response.ok) return;
         const payload: unknown = await response.json();
-        if (!cancelled) setAnswer({ platform, release: parseShellRelease(payload) });
+        if (!cancelled) setAnswer({ key, release: parseShellRelease(payload) });
       } catch {
         // A probe that cannot answer is a button that must not appear.
       }
@@ -233,10 +268,10 @@ export function useShellDownload(
     return () => {
       cancelled = true;
     };
-  }, [wanted, platform, fetchImpl]);
+  }, [wanted, key, platform, arch, fetchImpl]);
 
-  // A stale answer belongs to the platform it was read for, not this one.
-  const release = answer?.platform === platform ? answer.release : null;
+  // A stale answer belongs to the question it was read for, not this one.
+  const release = answer?.key === key ? answer.release : null;
   return shouldOfferShellDownload(platform, version, onAndroid, release);
 }
 
@@ -285,7 +320,13 @@ export function useShellOffer(
   const platform = fromBridge?.platform ?? mobile?.platform ?? 'android';
   const version = fromBridge?.version ?? mobile?.version ?? null;
 
-  return useShellDownload(platform, version, fromBridge ? null : bootstrap?.isAndroid, fetchImpl);
+  return useShellDownload(
+    platform,
+    version,
+    fromBridge ? null : bootstrap?.isAndroid,
+    fetchImpl,
+    fromBridge?.arch ?? null,
+  );
 }
 
 /**

package/src/client/hooks/ui/updates/shell-offer.test.ts

@@ -35,6 +35,7 @@ const RELEASE = {
   url: 'https://github.com/kabmo-labs/kabmo/releases/download/v0.7.0/Kabmo-0.6.0-android.apk',
   latest: '0.6.0',
   releaseUrl: 'https://github.com/kabmo-labs/kabmo/releases/tag/v0.7.0',
+  direct: true,
 };
 
 function Harness({ fetchImpl }: { fetchImpl: typeof fetch }) {
@@ -169,6 +170,31 @@ describe('the desktop shells', () => {
     expect(await mount(stubFetch([]))).toBe('update:linux:0.6.0');
   });
 
+  /**
+   * A shell that reports its architecture asks for THAT machine's artifact.
+   *
+   * Without it the console can only answer the release page — every desktop
+   * artifact is per-architecture — so the offer is a link a human follows instead
+   * of an update the shell installs.
+   */
+  test('reports the arch, so the answer is a file rather than a page', async () => {
+    shell({ desktop: { platform: 'macos', shellVersion: '0.1.0', arch: 'arm64' } });
+    const asked: string[] = [];
+
+    await mount(stubFetch(asked));
+    expect(asked).toEqual(['/api/updates/desktop?kind=macos&arch=arm64']);
+  });
+
+  test('a shell with no arch still asks, and gets the page', async () => {
+    // An older shell must keep working: the offer degrades to the release page
+    // instead of disappearing.
+    shell({ desktop: { platform: 'macos', shellVersion: '0.1.0' } });
+    const asked: string[] = [];
+
+    await mount(stubFetch(asked));
+    expect(asked).toEqual(['/api/updates/desktop?kind=macos']);
+  });
+
   test('a refused probe draws no button', async () => {
     shell({ desktop: { platform: 'macos', shellVersion: '0.1.0' } });
     const refusing = (async () => ({ ok: false, json: async () => ({}) }) as Response) as unknown as typeof fetch;