@eifi1/ui-kit 0.54.0 → 0.56.0

package/src/notifications/use-push-device.ts

@@ -1,448 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-
-import { useMediaQuery } from "../hooks/use-media-query";
-import { httpStatusOf } from "../lib/http-status";
-import { PUSH_SUBSCRIPTION_CHANGED, keyBytes, pushSubscriptionInput as inputOf } from "./push-worker";
-import type { PushSubscriptionInput } from "./push-worker";
-
-export { PUSH_SUBSCRIPTION_CHANGED };
-export type { PushSubscriptionInput };
-
-/**
- * This browser's Web Push subscription for the signed-in account
- * (docs/notifications-harmonization.md §2.7, §3.5, §4.2) — keksdose's
- * `shared/push/use-push.ts`, lifted. The service worker with its `push` and
- * `notificationclick` handlers stays the app's; this hook owns the browser's side:
- * permission, subscribe with the server's VAPID key, register the subscription, and
- * unsubscribe. The kit makes no request of its own: the app hands it one function per
- * endpoint.
- */
-
-/** The browser's notification permission, or `"unsupported"` where it has no push. */
-export type PushPermission = NotificationPermission | "unsupported";
-
-/** Why turning push on or off could not finish — a {@link PushDeviceError}'s `code`. */
-export type PushDeviceErrorCode = "no_service_worker" | "push_timeout";
-
-/**
- * The two failures the card has words of its own for: no service worker registered (or
- * one not ready in 10 s) — "reload and try again" — and a browser push service that did
- * not answer in 15 s — "check your connection". Anything else is the app's request
- * failing, rejected as it came.
- */
-export class PushDeviceError extends Error {
-  readonly code: PushDeviceErrorCode;
-  constructor(code: PushDeviceErrorCode) {
-    super(code);
-    this.name = "PushDeviceError";
-    this.code = code;
-  }
-}
-
-export interface UsePushDeviceOptions {
-  /** `GET /notifications/push-key` → its `key`; `""` when push is off on the server. */
-  pushKey: () => Promise<string>;
-  /** `POST /notifications/devices`. A 409 (another account's endpoint) is recovered
-   *  once: the hook unsubscribes and registers a fresh endpoint. */
-  register: (subscription: PushSubscriptionInput) => Promise<unknown>;
-  /** `POST /notifications/devices/unregister {endpoint}` — the endpoint never goes in a
-   *  URL. */
-  unregister: (endpoint: string) => Promise<unknown>;
-  /** `GET /notifications/devices`: the account's own list, which says whether THIS
-   *  account holds this browser's subscription. */
-  devices: () => Promise<readonly { endpoint: string }[]>;
-  /** `POST /notifications/test` → how many devices the push service accepted it for. */
-  test: () => Promise<{ sent: number }>;
-  /** Whether `register` refused another account's endpoint. Default: HTTP 409. */
-  isEndpointTaken?: (error: unknown) => boolean;
-  /** After an enable or a disable: the app refreshes its device queries. */
-  onChange?: () => void;
-}
-
-/** What {@link usePushDevice} answers. */
-export interface PushDevice {
-  /** The browser exposes service workers, `PushManager` and `Notification`. */
-  supported: boolean;
-  /** The server has VAPID keys; `undefined` until `pushKey` answered (or when it failed). */
-  configured: boolean | undefined;
-  /** Running as an installed app: `display-mode: standalone`, or iOS's
-   *  `navigator.standalone`. */
-  installed: boolean;
-  /** iPhone or iPad — where push reaches only the installed app. */
-  ios: boolean;
-  permission: PushPermission;
-  /** THIS account holds this browser's subscription. An unreachable device list falls
-   *  back to the browser's own answer. */
-  subscribed: boolean;
-  /** This browser holds a subscription that belongs to another account (two accounts in
-   *  one browser profile): `subscribed` is false, and turning on mints a fresh one. */
-  foreignSubscription: boolean;
-  /** This browser's subscription endpoint, or `null` — marks "This device" in a list. */
-  currentEndpoint: string | null;
-  /** An enable or a disable is running. */
-  busy: boolean;
-  /** Ask for permission (the browser's one prompt), subscribe and register. `false` when
-   *  the permission was not granted or push is off on the server; rejects with a
-   *  {@link PushDeviceError} or the app's request's error. */
-  enable: () => Promise<boolean>;
-  /** Tell the server first, then the browser, so a dropped device stops at once. At a
-   *  sign-out, with no card mounted: {@link releaseThisDevicePush}. */
-  disable: () => Promise<void>;
-  sendTest: () => Promise<{ sent: number }>;
-}
-
-/*
- * PUSH_SUBSCRIPTION_CHANGED (push-worker.ts): the window event every mounted
- * {@link usePushDevice} re-reads its state on. Fired by every enable and disable, and by
- * `PushDevicesSetting` when it removes this device — so an app's own card on the same
- * hook (keksdose's check-up) stays in step. The hook that fires it does not re-read: it
- * knows what it changed. Since 0.46 also the message a service worker posts after a
- * rotated subscription was re-registered (`handlePushSubscriptionChange`). Namespaced
- * for the kit; keksdose's was `"keksdose:push-subscription-changed"`.
- */
-
-/** Tell every {@link usePushDevice} that this browser's subscription changed. */
-export function notifyPushSubscriptionChanged(): void {
-  if (typeof window !== "undefined") window.dispatchEvent(new Event(PUSH_SUBSCRIPTION_CHANGED));
-}
-
-/** Whether this browser has the APIs push needs. iOS exposes them only to an INSTALLED
- *  app (Add to Home Screen). */
-export function pushSupported(): boolean {
-  return (
-    typeof window !== "undefined" &&
-    typeof navigator !== "undefined" &&
-    "serviceWorker" in navigator &&
-    "PushManager" in window &&
-    "Notification" in window
-  );
-}
-
-/** iPhone or iPad. iPadOS 13+ reports itself as a Mac; the touch points tell it apart. */
-function isIos(): boolean {
-  if (typeof navigator === "undefined") return false;
-  const ua = navigator.userAgent;
-  return /iphone|ipad|ipod/i.test(ua) || (/Macintosh/.test(ua) && navigator.maxTouchPoints > 1);
-}
-
-const READY_TIMEOUT_MS = 10_000;
-const PUSH_TIMEOUT_MS = 15_000;
-
-/** `promise`, or a {@link PushDeviceError} after `ms`. The timer is cleared either way. */
-function within<T>(promise: Promise<T>, ms: number, code: PushDeviceErrorCode): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  return Promise.race([
-    promise,
-    new Promise<never>((_, reject) => {
-      timer = setTimeout(() => reject(new PushDeviceError(code)), ms);
-    }),
-  ]).finally(() => clearTimeout(timer));
-}
-
-/**
- * The active registration. `navigator.serviceWorker.ready` never settles while the origin
- * has no registration, so a missing one fails at once, and one stuck installing fails
- * after 10 s (keksdose: enable() hung with the button latched before its worker was
- * served).
- */
-async function activeRegistration(): Promise<ServiceWorkerRegistration> {
-  const existing = await navigator.serviceWorker.getRegistration();
-  if (!existing) throw new PushDeviceError("no_service_worker");
-  return within(navigator.serviceWorker.ready, READY_TIMEOUT_MS, "no_service_worker");
-}
-
-const defaultEndpointTaken = (error: unknown) => httpStatusOf(error) === 409;
-
-/**
- * Drop this browser's subscription when the person turns push off: the server first, so a
- * dropped device stops receiving even if the browser's unsubscribe fails, then the
- * browser, cut at 15 s. Whether there was one. A refused server keeps the browser's
- * subscription: the card says the turn-off failed, still reads on, and the person tries
- * again. {@link usePushDevice}'s `disable`; a sign-out has its own
- * ({@link releaseThisDevicePush}).
- */
-async function releaseSubscription(unregister: (endpoint: string) => Promise<unknown>): Promise<boolean> {
-  const registration = await activeRegistration();
-  const subscription = await registration.pushManager.getSubscription();
-  if (!subscription) return false;
-  await unregister(subscription.endpoint);
-  await within(subscription.unsubscribe(), PUSH_TIMEOUT_MS, "push_timeout");
-  return true;
-}
-
-/**
- * Release this browser's push at an EXPLICIT sign-out (0.52, docs/notifications-
- * harmonization.md §10.6; refactor audit 2026-10-30, FLW-2) — without the settings card
- * mounted, which `usePushDevice().disable` needs.
- *
- * A sign-out left the subscription registered to the account, so the device went on
- * showing that account's notifications, title and body (keksdose: invoices, bookings,
- * shares), to whoever used it next — while the same sign-out wiped the mirror, the outbox
- * and the query cache "for the next person on this device".
- *
- * Call it with the app's `unregister` (`POST /notifications/devices/unregister
- * {endpoint}`) BEFORE the session is cleared, while the token is still valid:
- *
- *     async function logOut() {
- *       await releaseThisDevicePush(api.unregisterDevice).catch(() => undefined);
- *       clear();
- *     }
- *
- * The server first, then the browser — and the browser EVEN WHEN THE SERVER REFUSED (0.52
- * code review, this file): `disable`'s order left a sign-out on a flaky network, or one
- * that met a 5xx, with the device still subscribed. Unsubscribed, the push service answers
- * the server's next send with 410 and the server prunes the row. The browser's unsubscribe
- * is cut at 15 s (`PushDeviceError("push_timeout")`). Then it tells every mounted
- * {@link usePushDevice} ({@link PUSH_SUBSCRIPTION_CHANGED}).
- *
- * Resolves whether this browser held a subscription; `false` at once where push is
- * unsupported or was never set up — no service worker registration, or none ever active
- * (0.52 code review: most devices, which used to reject with `no_service_worker`, after
- * 10 s for a worker stuck installing). It asks the registration, not `ready`: a
- * subscription belongs to the registration, and a sign-out waits for no worker. Rejects
- * as the app's request did — once the browser has let go — or with `push_timeout`. Best
- * effort at a sign-out: catch it, a sign-out must not stop on push.
- *
- * Only an explicit sign-out (Marcel's decision 2 of the 2026-10-30 audit): a session that
- * merely expired keeps its device, and whoever signs back in turns push on again.
- */
-export async function releaseThisDevicePush(unregister: (endpoint: string) => Promise<unknown>): Promise<boolean> {
-  if (!pushSupported()) return false;
-  try {
-    const registration = await navigator.serviceWorker.getRegistration();
-    // A worker never active holds no subscription: `subscribe` needs an active one.
-    if (!registration?.active) return false;
-    const subscription = await registration.pushManager.getSubscription();
-    if (!subscription) return false;
-    try {
-      await unregister(subscription.endpoint);
-    } finally {
-      await within(subscription.unsubscribe(), PUSH_TIMEOUT_MS, "push_timeout");
-    }
-    return true;
-  } finally {
-    notifyPushSubscriptionChanged();
-  }
-}
-
-/**
- * This browser's push for the signed-in account. Hand it one function per endpoint
- * (§3.8); {@link PushDeviceSetting} draws it, and an app's own card may use it too.
- *
- * **"Subscribed" means this account**, not "this browser holds a subscription": a
- * browser profile's subscription has no account in it, so a second account in the same
- * profile would read the first's as its own (keksdose). The endpoint is checked against
- * the account's own `devices()`; when that list cannot be read (offline), the browser's
- * answer stands — a wrong "on" costs what it did before the check, a wrong "off" invites
- * re-subscribing a device that is fine.
- *
- * **A 409 from `register`** — the endpoint belongs to another account, and the server
- * will not re-home what it cannot prove this browser holds — unsubscribes and registers
- * a fresh endpoint, once.
- *
- * **Timeouts:** no registration fails at once and a worker not ready in 10 s fails, both
- * `PushDeviceError("no_service_worker")`; the browser's subscribe and unsubscribe are cut
- * at 15 s, `PushDeviceError("push_timeout")` — so `busy` can never latch.
- *
- * Every mounted hook re-reads its state on {@link PUSH_SUBSCRIPTION_CHANGED}.
- */
-export function usePushDevice(options: UsePushDeviceOptions): PushDevice {
-  // The app's functions are usually new on every render; the effects read the latest.
-  const latest = useRef(options);
-  useEffect(() => {
-    latest.current = options;
-  });
-
-  const supported = pushSupported();
-  const ios = isIos();
-  const standalone = useMediaQuery("(display-mode: standalone)", false);
-  const installed =
-    standalone ||
-    (typeof navigator !== "undefined" && (navigator as Navigator & { standalone?: boolean }).standalone === true);
-
-  const [permission, setPermission] = useState<PushPermission>(() =>
-    supported ? Notification.permission : "unsupported",
-  );
-  const [configured, setConfigured] = useState<boolean | undefined>(undefined);
-  const [subscribed, setSubscribed] = useState(false);
-  const [foreignSubscription, setForeignSubscription] = useState(false);
-  const [currentEndpoint, setCurrentEndpoint] = useState<string | null>(null);
-  const [busy, setBusy] = useState(false);
-  const mounted = useRef(true);
-  // Set while this hook fires the event itself: it already knows what changed, and a
-  // re-read could only be worse — an app whose `devices()` answers from a cache would
-  // hand back the list from before the change.
-  const announcing = useRef(false);
-  const announce = useCallback(() => {
-    announcing.current = true;
-    try {
-      notifyPushSubscriptionChanged();
-    } finally {
-      announcing.current = false;
-    }
-    latest.current.onChange?.();
-  }, []);
-  useEffect(() => {
-    mounted.current = true;
-    return () => {
-      mounted.current = false;
-    };
-  }, []);
-
-  // Whether the server has keys ("" → push is off there). Once per mount.
-  useEffect(() => {
-    if (!supported) return;
-    let cancelled = false;
-    latest.current.pushKey().then(
-      (key) => {
-        if (!cancelled) setConfigured(key !== "");
-      },
-      () => {
-        /* unknown: the card shows the ordinary states */
-      },
-    );
-    return () => {
-      cancelled = true;
-    };
-  }, [supported]);
-
-  // What this browser holds, and whether it is this account's — at mount, and whenever
-  // a subscription changes anywhere in the app.
-  useEffect(() => {
-    if (!supported) return;
-    let cancelled = false;
-    const sync = async () => {
-      try {
-        const registration = await activeRegistration();
-        const existing = await registration.pushManager.getSubscription();
-        if (cancelled) return;
-        // Read again: the person may have changed it in the browser's settings.
-        setPermission(Notification.permission);
-        if (!existing) {
-          setSubscribed(false);
-          setForeignSubscription(false);
-          setCurrentEndpoint(null);
-          return;
-        }
-        let mine: boolean;
-        try {
-          const devices = await latest.current.devices();
-          mine = devices.some((device) => device.endpoint === existing.endpoint);
-        } catch {
-          mine = true;
-        }
-        if (cancelled) return;
-        setCurrentEndpoint(existing.endpoint);
-        setSubscribed(mine);
-        setForeignSubscription(!mine);
-      } catch {
-        /* no active service worker yet: not subscribed */
-      }
-    };
-    const heard = () => {
-      if (!announcing.current) void sync();
-    };
-    // The worker's word after it re-registered a rotated subscription (0.46).
-    const fromWorker = (event: MessageEvent) => {
-      if ((event.data as { type?: unknown } | null)?.type === PUSH_SUBSCRIPTION_CHANGED) void sync();
-    };
-    const worker = navigator.serviceWorker as ServiceWorkerContainer | undefined;
-    void sync();
-    window.addEventListener(PUSH_SUBSCRIPTION_CHANGED, heard);
-    worker?.addEventListener?.("message", fromWorker);
-    return () => {
-      cancelled = true;
-      window.removeEventListener(PUSH_SUBSCRIPTION_CHANGED, heard);
-      worker?.removeEventListener?.("message", fromWorker);
-    };
-  }, [supported]);
-
-  const enable = useCallback(async (): Promise<boolean> => {
-    if (!supported) return false;
-    const { pushKey, register, isEndpointTaken = defaultEndpointTaken } = latest.current;
-    setBusy(true);
-    try {
-      const granted = await Notification.requestPermission();
-      if (mounted.current) setPermission(granted);
-      if (granted !== "granted") return false;
-
-      const key = await pushKey();
-      if (!key) {
-        if (mounted.current) setConfigured(false);
-        return false;
-      }
-      if (mounted.current) setConfigured(true);
-
-      const registration = await activeRegistration();
-      // The one place the browser is asked for a subscription, so the timeout and the
-      // `{userVisibleOnly, applicationServerKey}` literal are on both paths.
-      const subscribe = (reuse: boolean) =>
-        within(
-          (async () =>
-            (reuse ? await registration.pushManager.getSubscription() : null) ??
-            (await registration.pushManager.subscribe({
-              userVisibleOnly: true,
-              applicationServerKey: keyBytes(key),
-            })))(),
-          PUSH_TIMEOUT_MS,
-          "push_timeout",
-        );
-
-      let subscription = await subscribe(true);
-      let input = inputOf(subscription);
-      if (!input) return false;
-      try {
-        await register(input);
-      } catch (error) {
-        if (!isEndpointTaken(error)) throw error;
-        await within(subscription.unsubscribe(), PUSH_TIMEOUT_MS, "push_timeout");
-        subscription = await subscribe(false);
-        input = inputOf(subscription);
-        if (!input) return false;
-        await register(input);
-      }
-      if (mounted.current) {
-        setSubscribed(true);
-        setForeignSubscription(false);
-        setCurrentEndpoint(input.endpoint);
-      }
-      announce();
-      return true;
-    } finally {
-      if (mounted.current) setBusy(false);
-    }
-  }, [supported, announce]);
-
-  const disable = useCallback(async (): Promise<void> => {
-    if (!supported) return;
-    setBusy(true);
-    try {
-      await releaseSubscription((endpoint) => latest.current.unregister(endpoint));
-      if (mounted.current) {
-        setSubscribed(false);
-        setForeignSubscription(false);
-        setCurrentEndpoint(null);
-      }
-      announce();
-    } finally {
-      if (mounted.current) setBusy(false);
-    }
-  }, [supported, announce]);
-
-  const sendTest = useCallback(() => latest.current.test(), []);
-
-  return {
-    supported,
-    configured,
-    installed,
-    ios,
-    permission,
-    subscribed,
-    foreignSubscription,
-    currentEndpoint,
-    busy,
-    enable,
-    disable,
-    sendTest,
-  };
-}

package/src/offline/local-first.ts

@@ -1,100 +0,0 @@
-import { isTransientRefreshFailure } from "../lib/session-refresh";
-
-/*
- * The leaf utilities of local-first (docs/local-first-harmonization.md §2.3, 0.46): what a
- * page and a sync engine both need, with no store behind them. One module that both
- * `@eifi1/ui-kit/offline` and `@eifi1/ui-kit/sync` export, so `/sync` never loads
- * `/offline`'s TanStack and idb-keyval peers, and `/offline` never loads Dexie. It imports
- * no package at all (packaging-contract.test.ts holds that).
- */
-
-/**
- * An `updated_at` that wins Last-Write-Wins over `previous`: now, or one millisecond past
- * `previous` when that is not behind this clock (keksdose's sync-client.ts:639-643).
- *
- * `/sync` keeps the server's row when it is STRICTLY newer, comparing this device's clock
- * with the server's. A row the server just wrote carries the server's time, so an edit
- * stamped by a clock a second slow would lose and come straight back. The millisecond is
- * enough although the server keeps microseconds: `Date.parse` truncates them.
- */
-export function stampAfter(previous: unknown): string {
-  const now = Date.now();
-  const prior = typeof previous === "string" ? Date.parse(previous) : Number.NaN;
-  return new Date(Number.isFinite(prior) && prior >= now ? prior + 1 : now).toISOString();
-}
-
-/**
- * A name-based UUID, version 5 (RFC 4122 §4.3: SHA-1 of the namespace's 16 bytes and the
- * name's UTF-8), the same as Python's `uuid.uuid5(uuid.UUID(namespace), name)` — for an id
- * the device and the server derive alike (§2: the per-owner vote id
- * `uuid5(namespace, "<item>:<invitation>")`). Lower case, hyphenated. `namespace` is a UUID,
- * hyphenated or not, in either case; anything else is a `TypeError`. Uses `crypto.subtle`
- * (a secure context: https or localhost).
- */
-export async function uuid5(namespace: string, name: string): Promise<string> {
-  const hex = /^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}$/i.test(namespace)
-    ? namespace.replaceAll("-", "")
-    : null;
-  if (!hex) throw new TypeError(`uuid5: the namespace must be a UUID, not ${JSON.stringify(namespace)}`);
-  const nameBytes = new TextEncoder().encode(name);
-  const input = new Uint8Array(16 + nameBytes.length);
-  for (let i = 0; i < 16; i += 1) input[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  input.set(nameBytes, 16);
-  const bytes = new Uint8Array(await crypto.subtle.digest("SHA-1", input)).slice(0, 16);
-  bytes[6] = (bytes[6] & 0x0f) | 0x50; // version 5
-  bytes[8] = (bytes[8] & 0x3f) | 0x80; // the RFC 4122 variant
-  const out = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-  return `${out.slice(0, 8)}-${out.slice(8, 12)}-${out.slice(12, 16)}-${out.slice(16, 20)}-${out.slice(20)}`;
-}
-
-/**
- * The connection, not the server, failed: the request had no answer (an axios-like error
- * without `response`, or `fetch`'s `TypeError`), or the session refresh marked a 401 as
- * passing because the server was out of reach ({@link isTransientRefreshFailure}). A real
- * HTTP answer — a 4xx or a 5xx — is never offline: the caller must see it.
- */
-export function isOfflineError(err: unknown): boolean {
-  if (isTransientRefreshFailure(err)) return true;
-  if (typeof err !== "object" || err === null) return false;
-  const bag = err as { isAxiosError?: unknown; response?: unknown };
-  if (bag.isAxiosError === true || "response" in bag) return bag.response == null;
-  return err instanceof TypeError;
-}
-
-/**
- * Read from the server, and from the device's copy only when the connection failed
- * ({@link isOfflineError}); a 4xx or 5xx still throws. `onOnline` gets the server's answer
- * before it is returned (to refresh the copy, say); a throw from it counts as a failure of
- * the online path. The plain form of keksdose's net.ts:58, without its sealed-household
- * and cold-start branches (those stay keksdose's).
- */
-export async function readLocalFirst<T>(
-  online: () => Promise<T>,
-  offline: () => Promise<T>,
-  onOnline?: (result: T) => void | Promise<void>,
-): Promise<T> {
-  try {
-    const result = await online();
-    await onOnline?.(result);
-    return result;
-  } catch (err) {
-    if (!isOfflineError(err)) throw err;
-    return offline();
-  }
-}
-
-/**
- * Write through the server first (`rest`), and queue the change on the device (`queue`)
- * only when the connection failed; any other failure throws, nothing queued. Online writes
- * stay server-stamped (D2). A create mints its id BEFORE calling this and sends it on both
- * paths, so a REST create that timed out after the server applied it is not created twice
- * (D16).
- */
-export async function writeLocalFirst<T>(rest: () => Promise<T>, queue: () => Promise<T>): Promise<T> {
-  try {
-    return await rest();
-  } catch (err) {
-    if (!isOfflineError(err)) throw err;
-    return queue();
-  }
-}

package/src/offline/pwa-update-prompt-labels.ts

@@ -1,9 +0,0 @@
-// The English words of ./pwa-update-prompt, in a module with no component code (0.34, KS U8).
-// keksdose's reviewed words (pwa.updateAvailable, pwa.reload) are the canon.
-
-import type { PwaUpdatePromptLabels } from "./pwa-update-prompt";
-
-export const DEFAULT_PWA_UPDATE_PROMPT_LABELS: PwaUpdatePromptLabels = {
-  updateAvailable: "A new version is available.",
-  reload: "Reload",
-};

package/src/offline/pwa-update-prompt.tsx

@@ -1,78 +0,0 @@
-import { useEffect, useRef } from "react";
-import { useKitLabels, type LabelOverride } from "../i18n/kit-labels";
-import { toast } from "../components/toast";
-import { DEFAULT_PWA_UPDATE_PROMPT_LABELS } from "./pwa-update-prompt-labels";
-
-/**
- * "A new version is available. — Reload": keksdose's service-worker toast
- * (app/pwa-update-prompt.tsx) as a kit component (docs/local-first-harmonization.md §1.5
- * D8). The app keeps `useRegisterSW` (vite-plugin-pwa, `registerType: "prompt"`) and hands
- * its state in: `needRefresh` from it, `onReload` = `updateServiceWorker(true)`,
- * `onDismiss` = `setNeedRefresh(false)`.
- *
- * `hold` defers the prompt while a reload would hurt — a handover being signed, a tour
- * running. Nothing shows while it holds; the toast appears once it drops. A hold that
- * starts while the toast is up takes it down again until it drops.
- *
- * Renders nothing itself: the toast needs a mounted `<Toaster>`.
- */
-export interface PwaUpdatePromptLabels {
-  updateAvailable: string;
-  reload: string;
-}
-
-// Defined in ./pwa-update-prompt-labels, which holds no component code (0.34, KS U8).
-export { DEFAULT_PWA_UPDATE_PROMPT_LABELS };
-
-export interface PwaUpdatePromptProps {
-  /** A new service worker is waiting. */
-  needRefresh: boolean;
-  /** Activates it and reloads — `updateServiceWorker(true)`. */
-  onReload: () => void;
-  /** The toast was closed without reloading. */
-  onDismiss?: () => void;
-  /** Wait: a handover is open, a tour runs. */
-  hold?: boolean;
-  labels?: LabelOverride<PwaUpdatePromptLabels>;
-}
-
-/** The toast's id: one prompt at a time, replaced in place. */
-const PWA_UPDATE_TOAST_ID = "pwa-update";
-
-export function PwaUpdatePrompt({
-  needRefresh,
-  onReload,
-  onDismiss,
-  hold = false,
-  labels: labelsProp,
-}: PwaUpdatePromptProps) {
-  const labels = useKitLabels("pwaUpdate", DEFAULT_PWA_UPDATE_PROMPT_LABELS, labelsProp);
-  // The callbacks are read at click time, so a new function each render does not
-  // re-raise the toast.
-  const handlers = useRef({ onReload, onDismiss });
-  useEffect(() => {
-    handlers.current = { onReload, onDismiss };
-  });
-
-  const show = needRefresh && !hold;
-  useEffect(() => {
-    if (!show) return;
-    // sonner calls `onDismiss` for a programmatic dismiss too: the one this effect makes
-    // when a hold starts must not tell the app the person waved the update away.
-    let ours = false;
-    toast(labels.updateAvailable, {
-      id: PWA_UPDATE_TOAST_ID,
-      duration: Infinity,
-      action: { label: labels.reload, onClick: () => handlers.current.onReload() },
-      onDismiss: () => {
-        if (!ours) handlers.current.onDismiss?.();
-      },
-    });
-    return () => {
-      ours = true;
-      toast.dismiss(PWA_UPDATE_TOAST_ID);
-    };
-  }, [show, labels.updateAvailable, labels.reload]);
-
-  return null;
-}