@plannotator/ui 0.52.1 → 0.53.1

package/hooks/useAnnotationHighlighter.ts

@@ -7,7 +7,7 @@
 
 import { useEffect, useRef, useState, useCallback, type RefObject } from 'react';
 import Highlighter from '@plannotator/web-highlighter';
-import type { Annotation, EditorMode, ImageAttachment } from '../types';
+import type { Annotation, EditorMode, HostDraft, ImageAttachment } from '../types';
 import { AnnotationType } from '../types';
 import type { QuickLabel } from '../utils/quickLabels';
 import { getIdentity } from '../utils/identity';
@@ -710,6 +710,13 @@ export interface UseAnnotationHighlighterOptions {
   /** Fires once per `applyAnnotations` pass with what that pass tried and what
    *  it could not anchor, so a host can mark the leftovers in its panel. */
   onRestoreReport?: (report: AnnotationRestoreReport) => void;
+  /**
+   * The composer handed to the host (see `HostDraft`). Set: whenever a
+   * selection's toolbar or composer would open, the host gets the draft
+   * instead (and null when it closes); the host draws no toolbar or composer
+   * from this hook's state. Absent: unchanged.
+   */
+  onHostDraft?: (draft: HostDraft | null) => void;
 }
 
 /** The outcome of one `applyAnnotations` pass. */
@@ -777,6 +784,8 @@ export interface UseAnnotationHighlighterReturn {
   removeHighlight: (id: string) => void;
   clearAllHighlights: () => void;
   applyAnnotations: (annotations: Annotation[]) => void;
+  /** For a host that composes on a touch screen: the page selection as a draft now (see `ViewerHandle.takeSelection`). */
+  takeSelection?: () => boolean;
 }
 
 /**
@@ -796,6 +805,7 @@ export function useAnnotationHighlighter({
   verifyRestoredContent = false,
   onRestoreMismatch,
   onRestoreReport,
+  onHostDraft,
 }: UseAnnotationHighlighterOptions): UseAnnotationHighlighterReturn {
   const highlighterRef = useRef<Highlighter | null>(null);
   const modeRef = useRef<EditorMode>(mode);
@@ -844,6 +854,14 @@ export function useAnnotationHighlighter({
     pendingMathElementRef.current = source.element;
   }, []);
 
+  // A host that composes (onHostDraft) on a touch screen takes the selection
+  // itself, from its own Comment action (`takeSelection`): painting it as it
+  // settles would replace the system selection, and its edit menu with it.
+  const hostComposesRef = useRef(false);
+  hostComposesRef.current = onHostDraft !== undefined;
+  const takeTouchSelectionRef = useRef<() => boolean>(() => false);
+  const takeSelection = useCallback(() => takeTouchSelectionRef.current(), []);
+
   // Track mouse position for quick label picker
   useEffect(() => {
     const track = (e: MouseEvent) => { lastMousePosRef.current = { x: e.clientX, y: e.clientY }; };
@@ -996,7 +1014,8 @@ export function useAnnotationHighlighter({
     return null;
   }, []);
 
-  const createAnnotationFromSource = (
+  /** The annotation a selection's source makes, or null for a blank quote. No side effects. */
+  const buildAnnotationFromSource = (
     highlighter: Highlighter,
     source: any,
     type: AnnotationType,
@@ -1005,11 +1024,11 @@ export function useAnnotationHighlighter({
     isQuickLabel?: boolean,
     quickLabelTip?: string,
     mentions?: readonly string[],
-  ) => {
+  ): Annotation | null => {
     // #881: the last line before an annotation exists. A quote of pure
     // whitespace cannot be re-anchored on the next load, so it would come back
     // as an invisible row that is still counted and still exported.
-    if (isBlankQuote(source?.text)) return;
+    if (isBlankQuote(source?.text)) return null;
 
     const doms = highlighter.getDoms(source.id);
     let blockId = '';
@@ -1057,6 +1076,22 @@ export function useAnnotationHighlighter({
       ...(isQuickLabel ? { isQuickLabel: true } : {}),
       ...(quickLabelTip ? { quickLabelTip } : {}),
     };
+    return newAnnotation;
+  };
+
+  const createAnnotationFromSource = (
+    highlighter: Highlighter,
+    source: any,
+    type: AnnotationType,
+    text?: string,
+    images?: ImageAttachment[],
+    isQuickLabel?: boolean,
+    quickLabelTip?: string,
+    mentions?: readonly string[],
+  ) => {
+    const newAnnotation = buildAnnotationFromSource(highlighter, source, type, text, images, isQuickLabel, quickLabelTip, mentions);
+    if (!newAnnotation) return;
+    const mathTargets = pendingMathTargetsRef.current;
 
     if (type === AnnotationType.DELETION) {
       highlighter.addClass('deletion', source.id);
@@ -1585,7 +1620,11 @@ export function useAnnotationHighlighter({
     container.addEventListener('mouseup', handlePointerEndCapture, true);
     container.addEventListener('touchend', handlePointerEndCapture, true);
 
-    highlighter.run();
+    // On a touch screen a host that composes takes the selection when the
+    // person chooses its Comment (takeSelection); the library painting it at
+    // touchend would end the system selection and its edit menu first.
+    const isTouchPrimary = window.matchMedia('(pointer: coarse)').matches;
+    if (!(isTouchPrimary && hostComposesRef.current)) highlighter.run();
 
     const handleMathMouseDown = (event: MouseEvent) => {
       mouseDownMathRef.current = closestMathElement(event.target as Node, containerRef.current);
@@ -1675,28 +1714,33 @@ export function useAnnotationHighlighter({
     containerRef.current.addEventListener('mouseup', handleMathMouseUp, true);
 
     // Mobile bridge
-    const isTouchPrimary = window.matchMedia('(pointer: coarse)').matches;
     let selectionTimer: ReturnType<typeof setTimeout>;
+    // The page's selection, painted as a pending highlight; false when there is none to take.
+    const takeTouchSelection = (): boolean => {
+      const sel = window.getSelection();
+      if (!sel || sel.isCollapsed || sel.rangeCount === 0) return false;
+      if (!containerRef.current?.contains(sel.anchorNode)) return false;
+      const range = sel.getRangeAt(0).cloneRange();
+      // Same fail-closed rule as the pointer-end guard (#881): touch
+      // selections settle on block boundaries just as often.
+      if (isBlankQuote(sel.toString()) || !isSerializableRange(range)) return false;
+      snapRangeStartPastExcluded(range);
+      pendingRangeRunsRef.current = rangeTextPieces(range);
+      try {
+        highlighter.fromRange(range);
+        return true;
+      } catch (error) {
+        pendingRangeRunsRef.current = null;
+        warnHighlighterFailure('painting a touch selection', error);
+        return false;
+      }
+    };
+    takeTouchSelectionRef.current = takeTouchSelection;
     const handleSelectionChange = isTouchPrimary
       ? () => {
           clearTimeout(selectionTimer);
-          selectionTimer = setTimeout(() => {
-            const sel = window.getSelection();
-            if (!sel || sel.isCollapsed || sel.rangeCount === 0) return;
-            if (!containerRef.current?.contains(sel.anchorNode)) return;
-            const range = sel.getRangeAt(0).cloneRange();
-            // Same fail-closed rule as the pointer-end guard (#881): touch
-            // selections settle on block boundaries just as often.
-            if (isBlankQuote(sel.toString()) || !isSerializableRange(range)) return;
-            snapRangeStartPastExcluded(range);
-            pendingRangeRunsRef.current = rangeTextPieces(range);
-            try {
-              highlighter.fromRange(range);
-            } catch (error) {
-              pendingRangeRunsRef.current = null;
-              warnHighlighterFailure('painting a touch selection', error);
-            }
-          }, 400);
+          if (hostComposesRef.current) return;
+          selectionTimer = setTimeout(takeTouchSelection, 400);
         }
       : null;
 
@@ -2025,6 +2069,66 @@ export function useAnnotationHighlighter({
     window.getSelection()?.removeAllRanges();
   }, [clearPendingSelection, quickLabelPicker]);
 
+  // --- The composer handed to the host (onHostDraft) ---
+  // The toolbar and composer states still drive everything here; the host is
+  // told about them instead of seeing them drawn. A math source has no id of
+  // its own until it is committed, so its draft id is minted once per source.
+  const onHostDraftRef = useRef(onHostDraft);
+  onHostDraftRef.current = onHostDraft;
+  const hostDraftIdsRef = useRef(new WeakMap<object, string>());
+  const hostDraftOn = onHostDraft !== undefined;
+  useEffect(() => {
+    const report = onHostDraftRef.current;
+    if (!report) return;
+    const open = commentPopover ?? toolbarState;
+    const source = open?.source;
+    const highlighter = highlighterRef.current;
+    if (!source || !highlighter) {
+      report(null);
+      return;
+    }
+    let annotation: Annotation | null;
+    if (isMathAnnotationSource(source)) {
+      let id = hostDraftIdsRef.current.get(source);
+      if (!id) {
+        id = annotationId();
+        hostDraftIdsRef.current.set(source, id);
+      }
+      annotation = {
+        id,
+        blockId: source.blockId,
+        startOffset: 0,
+        endOffset: source.text.length,
+        type: AnnotationType.COMMENT,
+        text: '',
+        originalText: source.text,
+        createdA: Date.now(),
+        author: getIdentity(),
+      };
+    } else {
+      annotation = buildAnnotationFromSource(highlighter, source, AnnotationType.COMMENT, '');
+    }
+    if (!annotation) {
+      report(null);
+      return;
+    }
+    report({
+      annotation,
+      intent: commentPopover ? 'compose' : 'selection',
+      cancel: () => {
+        // A newer selection owns the pending state now: leave it alone.
+        if (pendingSourceRef.current !== source) return;
+        if (!isMathAnnotationSource(source)) highlighterRef.current?.remove(source.id);
+        clearPendingSelection();
+        setToolbarState(null);
+        setCommentPopover(null);
+        window.getSelection()?.removeAllRanges();
+      },
+    });
+    // buildAnnotationFromSource reads refs only; the states are the inputs.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [commentPopover, toolbarState, hostDraftOn, clearPendingSelection]);
+
   return {
     highlighterRef,
     toolbarState,
@@ -2043,5 +2147,6 @@ export function useAnnotationHighlighter({
     removeHighlight,
     clearAllHighlights,
     applyAnnotations: applyAnnotationsInternal,
+    takeSelection,
   };
 }

package/hooks/useExternalAnnotations.ts

@@ -123,6 +123,11 @@ interface UseExternalAnnotationsReturn<T> {
 /** The agent session that opened this review closed it (`session-closed` on the stream). */
 export interface ExternalSessionClosed {
   unsentAnnotations: number;
+  /**
+   * Who closed it: the agent (`POST /api/host/close`), or `"session"` when plan
+   * mode or the agent session itself ended. Anything else reads as `"agent"`.
+   */
+  by?: 'agent' | 'session';
 }
 
 export function useExternalAnnotations<T extends { id: string; source?: string }>(
@@ -193,6 +198,7 @@ export function useExternalAnnotations<T extends { id: string; source?: string }
         case 'session-closed':
           onSessionClosedRef.current?.({
             unsentAnnotations: typeof parsed.unsentAnnotations === 'number' ? parsed.unsentAnnotations : 0,
+            by: parsed.by === 'session' ? 'session' : 'agent',
           });
           break;
       }

package/hooks/useMentionAutocomplete.ts

@@ -115,7 +115,7 @@ export function useMentionAutocomplete(options: {
   }, [mentionsKey, onMentionsChange]);
 
   const items = useMemo(
-    () => (source && trigger ? mentionMatches(source.people, trigger, taggedIds) : []),
+    () => (source && trigger ? mentionMatches(source.people, trigger, taggedIds, source.kinds, source.matchDetail ?? true) : []),
     [source, trigger, taggedIds],
   );
 

package/hooks/useOpenInApps.ts

@@ -0,0 +1,88 @@
+import { useEffect, useState } from 'react';
+import type { OpenInKind, OpenInPlatform } from '@plannotator/core/open-in-apps';
+import { getStoredOpenInApp, setLastOpenInApp } from '../utils/storage';
+
+/**
+ * The "Open in" pieces every host shares: the detected-apps list (fetched
+ * once per URL and shared by every control on the page) and the remembered
+ * app (the `plannotator-open-in-app` cookie, so code review, annotate and the
+ * Inbox remember the same editor). OpenInAppButton reads `/api/open-in/apps`;
+ * the Inbox reads its own local-only `/api/inbox/open-in/apps`.
+ */
+
+export interface DetectedOpenInApp {
+  id: string;
+  label: string;
+  kind: OpenInKind;
+  icon: string;
+}
+
+export interface OpenInAppsAnswer {
+  /** True only when the route says so: false in a remote session, on a route this server does not have, or when the read failed. */
+  available: boolean;
+  apps: DetectedOpenInApp[];
+  /** The host's platform, when the route says (the Inbox's does). */
+  platform?: OpenInPlatform;
+}
+
+const loads = new Map<string, Promise<OpenInAppsAnswer>>();
+
+/**
+ * The apps a route answers, fetched once per URL for the page. Only an
+ * answer the route gave is kept: a failed read or a non-OK status (a
+ * restarting server, a route this server lacks) is not, so the next caller
+ * asks again.
+ */
+export function loadOpenInApps(url: string): Promise<OpenInAppsAnswer> {
+  let load = loads.get(url);
+  if (!load) {
+    const unavailable = (): OpenInAppsAnswer => {
+      loads.delete(url);
+      return { available: false, apps: [] };
+    };
+    load = fetch(url)
+      .then(async (response) => {
+        if (!response.ok) return unavailable();
+        const data = (await response.json()) as Partial<OpenInAppsAnswer>;
+        const platform = data.platform === 'mac' || data.platform === 'win' || data.platform === 'linux' ? data.platform : undefined;
+        return { available: data.available === true, apps: Array.isArray(data.apps) ? data.apps : [], ...(platform ? { platform } : {}) };
+      })
+      .catch(unavailable);
+    loads.set(url, load);
+  }
+  return load;
+}
+
+/**
+ * The detected apps from `url`, or null while they load. `enabled: false`
+ * reads nothing (and answers null). A new `retryKey` asks again after a read
+ * that did not answer; a kept answer comes back at once.
+ */
+export function useOpenInApps(url: string, enabled = true, retryKey?: string): OpenInAppsAnswer | null {
+  const [answer, setAnswer] = useState<OpenInAppsAnswer | null>(null);
+  useEffect(() => {
+    if (!enabled) return;
+    let cancelled = false;
+    void loadOpenInApps(url).then((next) => {
+      if (!cancelled) setAnswer(next);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [url, enabled, retryKey]);
+  return enabled ? answer : null;
+}
+
+/**
+ * The remembered app id (null when nothing was ever picked, so each host
+ * chooses its own first default) and the way to remember another (written
+ * to the shared cookie).
+ */
+export function useRememberedOpenInApp(): [string | null, (id: string) => void] {
+  const [id, setId] = useState<string | null>(() => getStoredOpenInApp());
+  const remember = (next: string) => {
+    setLastOpenInApp(next);
+    setId(next);
+  };
+  return [id, remember];
+}

package/hooks/useSkillReferenceAutocomplete.ts

@@ -59,14 +59,18 @@ export interface UseSkillReferenceAutocompleteResult {
  * active row and dismisses the menu when the user has engaged with it (a row
  * is active or a query was typed); on a bare-trigger menu with no engagement
  * it passes through, so Escape still closes the composer in one press.
+ * `bareEscapeDismisses` (default off) makes Escape close any open menu first,
+ * for a composer where Escape costs more than a press (the Inbox's compose
+ * dialog asks whether to keep a draft).
  */
 export function useSkillReferenceAutocomplete(options: {
   text: string;
   setText: (text: string) => void;
   textareaRef: React.RefObject<HTMLTextAreaElement | null>;
   enabled: boolean;
+  bareEscapeDismisses?: boolean;
 }): UseSkillReferenceAutocompleteResult {
-  const { text, setText, textareaRef, enabled } = options;
+  const { text, setText, textareaRef, enabled, bareEscapeDismisses = false } = options;
   // Seed from the memory cache only when the surface opted in — a disabled
   // composer must stay inert even after another surface warmed the catalog.
   const [catalog, setCatalog] = useState<SkillCatalogEntry[]>(() =>
@@ -205,7 +209,7 @@ export function useSkillReferenceAutocomplete(options: {
           // Only consume Escape when the user engaged with the menu (typed a
           // query or activated a row). A bare-trigger menu the user ignored
           // must not cost an extra Escape on the way to closing the composer.
-          if (boundedActive === null && trigger.query.length === 0) return false;
+          if (!bareEscapeDismisses && boundedActive === null && trigger.query.length === 0) return false;
           e.preventDefault();
           e.stopPropagation();
           setActiveIndex(null);
@@ -215,7 +219,7 @@ export function useSkillReferenceAutocomplete(options: {
           return false;
       }
     },
-    [boundedActive, items.length, open, select, trigger],
+    [bareEscapeDismisses, boundedActive, items.length, open, select, trigger],
   );
 
   const humanOnlyReferences = useMemo(

package/hooks/useUpdateCheck.ts

@@ -1,5 +1,6 @@
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useCallback, useMemo } from 'react';
 import { getItem, setItem } from '../utils/storage';
+import type { UpdateAction, UpdateAdvert } from '../utils/updateNotice';
 
 declare const __APP_VERSION__: string;
 
@@ -12,120 +13,59 @@ export interface UpdateInfo {
   currentVersion: string;
   latestVersion: string;
   updateAvailable: boolean;
+  /** The Options dot was seen for this version (opening the menu dismisses it). */
   dismissed: boolean;
   releaseUrl: string;
   featureHighlight?: FeatureHighlight;
+  /** What updating means here: `script` (Update now), `copy`, `pi`, `opencode`. */
+  action?: UpdateAction;
+  /** The command for this host, with the remembered install flags. */
+  command?: string;
   dismiss: () => void;
 }
 
-interface VersionCheckResult {
-  currentVersion: string;
-  latestVersion: string;
-  updateAvailable: boolean;
-  releaseUrl: string;
-  featureHighlight?: FeatureHighlight;
-}
-
-const GITHUB_API = 'https://api.github.com/repos/backnotprop/plannotator/releases/latest';
-
 const DISMISSED_VERSION_KEY = 'update-dismissed-version';
 
-// Feature highlights for milestone releases
-const FEATURE_HIGHLIGHTS: Record<string, FeatureHighlight> = {
-  '0.5.0': {
-    title: 'Code Review is here!',
-    description: 'Review git diffs with inline annotations. Run /plannotator-review to try it.',
-  },
-};
-
-function compareVersions(current: string, latest: string): boolean {
-  const cleanVersion = (v: string) => v.replace(/^v/, '');
-  const currentParts = cleanVersion(current).split('.').map(Number);
-  const latestParts = cleanVersion(latest).split('.').map(Number);
-
-  for (let i = 0; i < Math.max(currentParts.length, latestParts.length); i++) {
-    const curr = currentParts[i] || 0;
-    const lat = latestParts[i] || 0;
-    if (lat > curr) return true;
-    if (lat < curr) return false;
-  }
-  return false;
-}
-
 function isDismissedVersion(latestVersion: string): boolean {
   const dismissed = getItem(DISMISSED_VERSION_KEY);
   if (!dismissed) return false;
-  const cleanLatest = latestVersion.replace(/^v/, '');
-  const cleanDismissed = dismissed.replace(/^v/, '');
-  return cleanLatest === cleanDismissed;
+  return latestVersion.replace(/^v/, '') === dismissed.replace(/^v/, '');
 }
 
-export function useUpdateCheck(): UpdateInfo | null {
-  const [checkResult, setCheckResult] = useState<VersionCheckResult | null>(null);
-  const [dismissed, setDismissed] = useState(false);
-
-  const dismiss = useCallback(() => {
-    if (!checkResult?.latestVersion) return;
-    const clean = checkResult.latestVersion.replace(/^v/, '');
-    setItem(DISMISSED_VERSION_KEY, clean);
-    setDismissed(true);
-  }, [checkResult?.latestVersion]);
-
-  useEffect(() => {
-    const checkForUpdates = async () => {
-      try {
-        const currentVersion = typeof __APP_VERSION__ !== 'undefined'
-          ? __APP_VERSION__
-          : '0.0.0';
-
-        // Debug: ?preview-update=0.5.0 simulates an update to that version
-        const urlParams = new URLSearchParams(window.location.search);
-        const previewVersion = urlParams.get('preview-update');
-
-        if (previewVersion) {
-          const cleanPreview = previewVersion.replace(/^v/, '');
-          setDismissed(isDismissedVersion(cleanPreview));
-          setCheckResult({
-            currentVersion,
-            latestVersion: previewVersion,
-            updateAvailable: true,
-            releaseUrl: `https://github.com/backnotprop/plannotator/releases/tag/v${cleanPreview}`,
-            featureHighlight: FEATURE_HIGHLIGHTS[cleanPreview],
-          });
-          return;
-        }
-
-        const response = await fetch(GITHUB_API);
-        if (!response.ok) return;
-
-        const release = await response.json();
-        const latestVersion = release.tag_name;
-
-        const updateAvailable = compareVersions(currentVersion, latestVersion);
-
-        const cleanLatest = latestVersion.replace(/^v/, '');
-        const featureHighlight = FEATURE_HIGHLIGHTS[cleanLatest];
-
-        setDismissed(isDismissedVersion(latestVersion));
-        setCheckResult({
-          currentVersion,
-          latestVersion,
-          updateAvailable,
-          releaseUrl: release.html_url,
-          featureHighlight,
-        });
-      } catch {
-      }
-    };
-
-    checkForUpdates();
+/**
+ * The Options menu's update state, from the server's advert (`updateAvailable`
+ * on /api/plan and /api/diff). The browser never asks GitHub: the machine
+ * checks once a day (packages/shared/update-check.ts) and the server passes
+ * the answer on, or nothing when update checks are off, in a dev build, or on
+ * a surface with no server.
+ *
+ * `?preview-update=0.29.0` still simulates an update, for screenshots.
+ */
+export function useUpdateCheck(advert?: UpdateAdvert | null): UpdateInfo | null {
+  const preview = useMemo(() => {
+    if (typeof window === 'undefined') return null;
+    const version = new URLSearchParams(window.location.search).get('preview-update');
+    return version ? version.replace(/^v/, '') : null;
   }, []);
+  const latestVersion = preview ?? advert?.version ?? null;
+  const [dismissedVersion, setDismissedVersion] = useState<string | null>(null);
 
-  if (!checkResult) return null;
+  const dismiss = useCallback(() => {
+    if (!latestVersion) return;
+    setItem(DISMISSED_VERSION_KEY, latestVersion);
+    setDismissedVersion(latestVersion);
+  }, [latestVersion]);
 
+  if (!latestVersion) return null;
+  const currentVersion = advert?.current ?? (typeof __APP_VERSION__ !== 'undefined' ? __APP_VERSION__ : '0.0.0');
   return {
-    ...checkResult,
-    dismissed,
+    currentVersion,
+    latestVersion,
+    updateAvailable: true,
+    dismissed: dismissedVersion === latestVersion || isDismissedVersion(latestVersion),
+    releaseUrl: advert?.releaseUrl ?? `https://github.com/backnotprop/plannotator/releases/tag/v${latestVersion}`,
+    action: advert?.action ?? 'script',
+    command: advert?.command ?? 'curl -fsSL https://plannotator.ai/install.sh | bash',
     dismiss,
   };
 }

package/hooks/useUpdateCheckSetting.ts

@@ -0,0 +1,43 @@
+import { useCallback, useState } from 'react';
+
+/**
+ * The update-notice switch (PLANNOTATOR_UPDATE_CHECK / `updateCheck`) for
+ * Settings → General: the server's value from serverConfig, written back
+ * with POST /api/config. Deliberately not a settings-registry entry: the
+ * registry is bundled into the portable guides.show viewer, whose pinned
+ * build must not change for a Plannotator-only setting.
+ */
+export interface UpdateCheckSetting {
+  /** The effective value: the env var when it decides, else config.json (default true). */
+  on: boolean;
+  /** PLANNOTATOR_UPDATE_CHECK when it overrides the config file: the switch is locked. */
+  env?: boolean;
+  onChange: (next: boolean) => void;
+}
+
+export function useUpdateCheckSetting(): {
+  setting: UpdateCheckSetting | undefined;
+  adopt: (serverConfig: Record<string, unknown> | undefined) => void;
+} {
+  const [state, setState] = useState<{ config: boolean; env?: boolean } | undefined>();
+
+  const adopt = useCallback((serverConfig: Record<string, unknown> | undefined) => {
+    const config = serverConfig?.updateCheck;
+    const env = serverConfig?.updateCheckEnv;
+    setState(typeof config === 'boolean' ? { config, ...(typeof env === 'boolean' && { env }) } : undefined);
+  }, []);
+
+  const onChange = useCallback((next: boolean) => {
+    setState((current) => (current ? { ...current, config: next } : current));
+    void fetch('/api/config', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ updateCheck: next }),
+    }).catch(() => {});
+  }, []);
+
+  return {
+    setting: state ? { on: state.env ?? state.config, ...(state.env !== undefined && { env: state.env }), onChange } : undefined,
+    adopt,
+  };
+}