@develemit/web-hooks 0.2.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.1 - 2026-11-06
+
+- `service-worker`: `useServiceWorker({ onError })` and `registerServiceWorker({ onError })`. Called with the rejection when `register()` fails (not after unmount or dispose). The latest callback is used; a throwing callback is swallowed. Registration failure still never throws into React.
+- `push`: an empty or whitespace `vapidPublicKey` is "not ready". The on-load re-subscribe waits for the key and runs once when it arrives; `subscribe()` sets `error` to `'push key not ready'` and never prompts or calls `pushManager.subscribe`. `shouldResubscribe` takes an optional `hasKey` (default `true`); new `isKeyReady`.
+- `service-worker`: a worker that skips waiting no longer makes the tab reload unasked on `controllerchange`. The hook reports `updateAvailable` and `applyUpdate()` reloads once. **Behaviour change:** this also replaces the old behaviour of following another tab's update with an automatic reload; that tab now shows the update prompt instead. No app relied on the old behaviour, so it ships as a patch.
+
+## 0.3.0 - 2026-11-06
+
+- `push`: `usePushSubscription({ vapidPublicKey, onSubscribe, onUnsubscribe, resubscribeOnLoad = true })` returning `{ support, permission, subscribed, busy, error, subscribe, unsubscribe }`, plus `urlBase64ToUint8Array`, `getPushSupport` (`'supported' | 'unsupported' | 'ios-needs-install'`) and the pure `shouldResubscribe`. The VAPID key is always converted to a `Uint8Array`, the browser's `pushManager.getSubscription()` is the source of truth, mounting never asks for permission, a dropped iOS subscription is re-made silently when permission is already granted, and an `onSubscribe` rejection with `status` 410 unsubscribes and subscribes once more. The package makes no HTTP requests; the app's callbacks do.
+- `keyboard-inset`: `useKeyboardInset({ minInset = 150, enabled = true })` returns the on-screen keyboard height in CSS px (0 when closed), plus the pure `computeKeyboardInset` and `isEditableElement`. Reports only while a text field is focused and ignores gaps under `minInset`, which removes the phantom ~100pt gap in a standalone iPhone PWA. After a blur it re-reads on the next animation frame so moving between fields doesn't flicker to 0.
+- `share`: `shareOrCopy({ title, text, url })` returning `{ status: 'shared' | 'copied' | 'cancelled' | 'failed' }`. Uses the native share sheet when present (honouring `navigator.canShare`), treats an `AbortError` as `cancelled` with no copy, and otherwise falls back to the clipboard module's `copyText`, so it works over plain http. Also `shareTextFor` (copies `text` then `url`, never `title`), `isShareCancel`, `canShareFiles` (detection only) and `useShareFeedback()`.
+- `online-status`: `useOnlineStatus()` built on `useSyncExternalStore`; `true` on the server and during hydration, so no mismatch when the device starts offline.
+- `service-worker`: `useServiceWorker({ url, scope, enabled })` returning `{ supported, updateAvailable, applyUpdate }`, plus `unregisterAll()` and the pure `deriveUpdateState`. A first install is never reported as an update; `applyUpdate()` posts `{ type: 'SKIP_WAITING' }` and the page reloads once on `controllerchange` (a module-level guard prevents loops; other tabs follow when an old worker was in control). The app's worker must handle `SKIP_WAITING`. The package never reads `process.env`; pass `enabled`.
+- `pwa`: `useInstallPrompt()` (`canPrompt`, `prompt()` returning `accepted | dismissed | unavailable` from `userChoice`, `installed`, `needsIosInstructions`), `useIsStandalone()`, `startInstallPromptCapture()` for the `beforeinstallprompt` that fires before hydration, and the pure `detectPlatform`, `isStandalone`, `isIos`, `isIosSafari`. iPadOS in desktop mode counts as iOS; Chrome, Firefox, Edge, Opera and in-app webviews on iOS are not iOS Safari. Both listeners are removed on unmount. Dismissal storage is left to the app.
+- `outside-press`: `useOutsidePress(refs, fn, { ignore })` takes a CSS selector. A press whose target is inside a matching element counts as inside, for popups that are found with `closest(selector)` and have no ref. New optional third argument to the pure `isOutside`.
+- `drawer-swipe`: `useDrawerSwipe({ ignoreSelector })` (default `'[data-no-swipe]'`, `null` disables). A swipe that starts inside a match, or inside a descendant of one, never opens or closes the drawer. New pure `isInIgnoredRegion`, and `resolveSwipeIntent` takes an optional `startedInIgnoredRegion`.
+- `clipboard`: `readText()` resolves to `{ ok: true, text }` or `{ ok: false, reason: 'unavailable' | 'denied' }` and never throws. Over plain http there is no way to read the clipboard, so it returns `unavailable` (show "paste manually").
+
 ## 0.2.0 - 2026-11-05
 
 - `unsaved-guard`: `useUnsavedChangesGuard(dirty)` and the pure `handleBeforeUnload`. Attached only while dirty and sets `returnValue = ''` as well as `preventDefault()`, which older Safari and Chrome need. `beforeunload` only; in-app navigation stays in the app.

package/README.md

@@ -18,6 +18,12 @@ that every app ends up hand-copying from the last one.
 | `@develemit/web-hooks/unsaved-guard` | Warn before the tab closes while a form is dirty |
 | `@develemit/web-hooks/hotkey` | Keyboard shortcuts such as `mod+k` |
 | `@develemit/web-hooks/auto-grow` | Grow a textarea with its content, keyboard-aware |
+| `@develemit/web-hooks/pwa` | Detect iOS and installed-PWA mode, and drive the install prompt |
+| `@develemit/web-hooks/online-status` | Track online/offline, hydration-safe |
+| `@develemit/web-hooks/service-worker` | Register a service worker and apply updates with one reload |
+| `@develemit/web-hooks/share` | Native share sheet with a clipboard fallback that works over plain http |
+| `@develemit/web-hooks/keyboard-inset` | On-screen keyboard height, without the phantom gap in standalone iPhone PWAs |
+| `@develemit/web-hooks/push` | Web push subscription, with iOS install detection and silent re-subscribe |
 
 Behavior only. No styling and no components: each app keeps its own look.
 
@@ -44,6 +50,11 @@ useDrawerSwipe({
 The left 60px band is left to the browser's back gesture, and swipes that start
 inside a horizontally scrolling container stay with that container.
 
+Mark a region that scrolls or gestures on its own (a terminal, a code view)
+with `data-no-swipe`, and swipes starting inside it are ignored. Pass
+`ignoreSelector: '.my-region'` to use a different selector, or `null` to turn
+the opt-out off.
+
 ### Drawer with focus trap and Escape
 
 ```tsx
@@ -83,6 +94,11 @@ const { copy, status } = useCopyFeedback({ resetMs: 1500 });
 rejects. On plain-http origins (a PWA over a Tailscale address)
 `navigator.clipboard` doesn't exist, so it falls back to `execCommand('copy')`.
 
+`readText()` is the paste side. It resolves to `{ ok: true, text }` or
+`{ ok: false, reason: 'unavailable' | 'denied' }` and never rejects. Reading has
+no fallback: over plain http it returns `unavailable`, so show a "paste
+manually" hint.
+
 ### Lock page scroll behind an overlay
 
 ```tsx
@@ -135,6 +151,9 @@ portalled panel's ref too. Right clicks are ignored, and a target removed from
 the DOM during the event counts as inside. The callback is read through a ref,
 so it needs no `useCallback`.
 
+When the popup has no ref, pass `{ ignore: '.inline-cell-search' }`: a press
+inside any element matching the selector counts as inside (unreleased).
+
 ### visibility-polling
 
 ```tsx
@@ -248,3 +267,141 @@ back to `window` `resize`. At `maxHeight` it stops growing and sets
 `overflowY: auto`. The pure `nextHeight(scrollHeight, maxHeight)` does the
 clamping.
 
+### Install prompt and platform detection
+
+```tsx
+import { startInstallPromptCapture, useInstallPrompt, useIsStandalone } from '@develemit/web-hooks/pwa';
+
+// Root client component, outside React's lifecycle: Android Chrome often fires
+// `beforeinstallprompt` before hydration, and it fires only once.
+startInstallPromptCapture();
+
+const { canPrompt, prompt, installed, needsIosInstructions } = useInstallPrompt();
+if (canPrompt) await prompt(); // 'accepted' | 'dismissed' | 'unavailable'
+```
+
+`needsIosInstructions` is true in iOS Safari (not Chrome, Firefox, Edge, Opera
+or an in-app browser) when the app isn't installed. iPads in desktop mode count
+as iOS. The pure `detectPlatform(env)`, `isIos()`, `isIosSafari()` and
+`isStandalone()` are exported too; they read the globals when called and
+return `false` on the server.
+
+The package doesn't store dismissal: the key and snooze rules are product
+decisions. Combine the hook with `useStorageState` from `storage-state`.
+
+### Online status and service worker
+
+```tsx
+import { useOnlineStatus } from '@develemit/web-hooks/online-status';
+import { useServiceWorker } from '@develemit/web-hooks/service-worker';
+
+const online = useOnlineStatus(); // true on the server and during hydration
+
+const { updateAvailable, applyUpdate, supported } = useServiceWorker({
+  url: '/sw.js',
+  scope: '/',
+  enabled: process.env.NODE_ENV === 'production',
+  onError: (error) => captureError(error), // registration failed; never throws into React
+});
+if (updateAvailable) showBanner({ onTap: applyUpdate });
+```
+
+`applyUpdate()` posts `{ type: 'SKIP_WAITING' }` to the waiting worker and the
+page reloads once when the new worker takes control. Your worker must handle
+that message:
+
+```js
+self.addEventListener('message', (event) => {
+  if (event.data?.type === 'SKIP_WAITING') self.skipWaiting();
+});
+```
+
+Workers that call `self.skipWaiting()` on install (as emit-infra's does) take
+control with no waiting stage. The page is never reloaded unasked: when a new
+worker takes control of a tab that was already controlled, `updateAvailable`
+becomes `true` and `applyUpdate()` reloads the page once. The same applies when
+another tab applied the update.
+
+A first install (no controller yet) is not reported as an update. In dev, call
+`unregisterAll()` to clear workers left by a production build. Browsers without
+service workers get `supported: false`.
+
+### Share
+
+```tsx
+import { useShareFeedback } from '@develemit/web-hooks/share';
+
+const { share, status } = useShareFeedback(); // 'idle' | 'shared' | 'copied' | 'cancelled' | 'failed'
+<button onClick={() => void share({ title, text, url })}>Share</button>;
+```
+
+`shareOrCopy(data)` opens the native share sheet when there is one. Closing the
+sheet is `cancelled`, not a failure, and copies nothing. Any other share error
+(for example `NotAllowedError` when the call isn't from a user gesture), a
+missing `navigator.share`, or `canShare(data) === false` falls back to
+`copyText`, which works over plain http. The copied text is `text` then `url`
+joined by a newline (`url` alone when that is all there is); `title` is not
+copied. Call it directly from the tap handler, before any `await`, so the
+browser still sees a user gesture. `canShareFiles(files)` is detection only.
+
+### Keyboard inset
+
+```tsx
+import { useKeyboardInset } from '@develemit/web-hooks/keyboard-inset';
+
+const inset = useKeyboardInset();
+
+useEffect(() => {
+  document.documentElement.style.setProperty('--keyboard-inset', `${inset}px`);
+}, [inset]);
+```
+
+Returns the height of the on-screen keyboard in CSS pixels, `0` when it is
+closed, on the server and when `visualViewport` is missing. It reports an
+inset only while a text field is focused and ignores gaps under `minInset`
+(default 150), because a standalone iPhone PWA reports a ~100pt gap between the
+layout and visual viewport with no keyboard open. The hook returns a number;
+apply it as padding or `bottom` yourself, for example `padding-bottom:
+var(--keyboard-inset)` with the effect above. The pure `computeKeyboardInset`
+and `isEditableElement` are exported too.
+
+### Push
+
+```tsx
+import { usePushSubscription } from '@develemit/web-hooks/push';
+
+const push = usePushSubscription({
+  vapidPublicKey: process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY!,
+  onSubscribe: (sub) => api.post('/push/subscribe', sub),
+  onUnsubscribe: (endpoint) => api.delete('/push/subscribe', { endpoint }),
+});
+
+if (push.support === 'ios-needs-install') return <InstallHint />;
+<button onClick={push.subscribe} disabled={push.busy}>Enable</button>
+```
+
+`vapidPublicKey` may be `''` while the app is still fetching it. Until it is
+non-blank, the on-load re-subscribe is skipped (and runs once when the key
+arrives) and `subscribe()` sets `error` to `'push key not ready'` without
+asking for permission or touching the push manager.
+
+Returns `{ support, permission, subscribed, busy, error, subscribe, unsubscribe }`.
+`support` is `'supported'`, `'unsupported'` or `'ios-needs-install'`: iOS only
+allows Web Push in an installed PWA (16.4+), so an iPhone Safari tab (or any
+iOS browser outside the home-screen app) gets `ios-needs-install` and
+`subscribe()` does nothing.
+
+Call `subscribe()` from a tap handler: the hook never requests permission on
+mount, because browsers (and iOS especially) need a user gesture. `subscribed`
+comes from `pushManager.getSubscription()`, never from a stored flag. The
+service worker comes from `navigator.serviceWorker.ready`; this package never
+registers one for push (use `useServiceWorker`).
+
+iOS silently drops push subscriptions. With `resubscribeOnLoad` (default
+`true`), when permission is already `granted` and the browser has no
+subscription, the hook subscribes again without a prompt and calls
+`onSubscribe`. If `onSubscribe` rejects with an error whose `status` is `410`,
+the dead subscription is unsubscribed and one fresh one is made and sent. The
+package never makes HTTP requests: `onSubscribe(subscription:
+PushSubscriptionJSON)` and `onUnsubscribe(endpoint)` are yours. The pure
+`urlBase64ToUint8Array`, `getPushSupport` and `shouldResubscribe` are exported.

package/dist/chunk-4PVVTQ5V.js

@@ -0,0 +1,74 @@
+"use client";
+import {
+  copyText
+} from "./chunk-FE3BQD2I.js";
+
+// src/share/share-text.ts
+function shareTextFor({ text, url }) {
+  return [text, url].filter((part) => !!part).join("\n");
+}
+function isShareCancel(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+
+// src/share/share-or-copy.ts
+async function shareOrCopy(data) {
+  if (canShareNatively(data)) {
+    try {
+      await navigator.share(data);
+      return { status: "shared" };
+    } catch (error) {
+      if (isShareCancel(error)) return { status: "cancelled" };
+    }
+  }
+  const result = await copyText(shareTextFor(data));
+  return { status: result.ok ? "copied" : "failed" };
+}
+function canShareFiles(files) {
+  if (typeof navigator === "undefined" || typeof navigator.canShare !== "function") return false;
+  try {
+    return navigator.canShare({ files });
+  } catch {
+    return false;
+  }
+}
+function canShareNatively(data) {
+  if (typeof navigator === "undefined" || typeof navigator.share !== "function") return false;
+  if (typeof navigator.canShare !== "function") return true;
+  try {
+    return navigator.canShare(data);
+  } catch {
+    return false;
+  }
+}
+
+// src/share/use-share-feedback.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function useShareFeedback({ resetMs = 1500 } = {}) {
+  const [status, setStatus] = useState("idle");
+  const timerRef = useRef(void 0);
+  const clearTimer = useCallback(() => {
+    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    timerRef.current = void 0;
+  }, []);
+  useEffect(() => clearTimer, [clearTimer]);
+  const share = useCallback(
+    async (data) => {
+      const result = await shareOrCopy(data);
+      clearTimer();
+      setStatus(result.status);
+      timerRef.current = setTimeout(() => setStatus("idle"), resetMs);
+      return result;
+    },
+    [clearTimer, resetMs]
+  );
+  return { share, status };
+}
+
+export {
+  shareTextFor,
+  isShareCancel,
+  shareOrCopy,
+  canShareFiles,
+  useShareFeedback
+};

package/dist/{chunk-OZ4PU4E3.js → chunk-5XRVPZHD.js}

@@ -11,7 +11,8 @@ var HORIZONTAL_DOMINANCE = 1.5;
 function isInOpenZone(x, viewportWidth) {
   return x > BACK_ZONE_PX && x < viewportWidth - FORWARD_ZONE_PX;
 }
-function resolveSwipeIntent(start, end, drawerOpen, viewportWidth) {
+function resolveSwipeIntent(start, end, drawerOpen, viewportWidth, startedInIgnoredRegion = false) {
+  if (startedInIgnoredRegion) return null;
   const dx = end.x - start.x;
   const dy = end.y - start.y;
   if (end.time - start.time > MAX_SWIPE_DURATION_MS) return null;
@@ -33,6 +34,11 @@ function isInsideHorizontalScroller(target) {
   }
   return false;
 }
+var DEFAULT_IGNORE_SELECTOR = "[data-no-swipe]";
+function isInIgnoredRegion(target, selector) {
+  if (!selector || !(target instanceof Element)) return false;
+  return target.closest(selector) !== null;
+}
 
 // src/drawer-swipe/use-drawer-swipe.ts
 import { useEffect, useRef } from "react";
@@ -44,17 +50,19 @@ function useDrawerSwipe({
   onOpen,
   onClose,
   enabled = true,
-  maxViewportWidth = 768
+  maxViewportWidth = 768,
+  ignoreSelector = DEFAULT_IGNORE_SELECTOR
 }) {
   const start = useRef(null);
-  const handlers = useRef({ drawerOpen, onOpen, onClose, maxViewportWidth });
-  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth };
+  const handlers = useRef({ drawerOpen, onOpen, onClose, maxViewportWidth, ignoreSelector });
+  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth, ignoreSelector };
   useEffect(() => {
     if (!enabled) return;
     function handleStart(event) {
       start.current = null;
       if (event.touches.length !== 1) return;
       if (isWideViewport(handlers.current.maxViewportWidth)) return;
+      if (isInIgnoredRegion(event.target, handlers.current.ignoreSelector)) return;
       if (!handlers.current.drawerOpen && isInsideHorizontalScroller(event.target)) {
         return;
       }
@@ -111,5 +119,7 @@ export {
   isInOpenZone,
   resolveSwipeIntent,
   isInsideHorizontalScroller,
+  DEFAULT_IGNORE_SELECTOR,
+  isInIgnoredRegion,
   useDrawerSwipe
 };

package/dist/{chunk-3UGRXQIA.js → chunk-DQBKU7HI.js}

@@ -1,21 +1,28 @@
 "use client";
 
 // src/outside-press/outside-press.ts
-function isOutside(target, elements) {
+function isOutside(target, elements, ignoreSelector) {
   if (!target) return false;
   if (!target.isConnected) return false;
+  if (ignoreSelector && isInIgnoredRegion(target, ignoreSelector)) return false;
   return !elements.some((el) => el?.contains(target));
 }
 function isPrimaryPress(event) {
   return !(event.pointerType === "mouse" && event.button !== 0);
 }
+function isInIgnoredRegion(target, selector) {
+  const element = target instanceof Element ? target : target.parentElement;
+  return element?.closest(selector) != null;
+}
 
 // src/outside-press/use-outside-press.ts
 import { useEffect, useRef } from "react";
-function useOutsidePress(refs, onOutsidePress, { enabled = true } = {}) {
+function useOutsidePress(refs, onOutsidePress, { enabled = true, ignore } = {}) {
   const refsRef = useRef(refs);
   const handlerRef = useRef(onOutsidePress);
+  const ignoreRef = useRef(ignore);
   useEffect(() => {
+    ignoreRef.current = ignore;
     refsRef.current = refs;
     handlerRef.current = onOutsidePress;
   });
@@ -25,7 +32,7 @@ function useOutsidePress(refs, onOutsidePress, { enabled = true } = {}) {
       if (!isPrimaryPress(event)) return;
       const list = Array.isArray(refsRef.current) ? refsRef.current : [refsRef.current];
       const elements = list.map((ref) => ref.current);
-      if (isOutside(event.target, elements)) handlerRef.current(event);
+      if (isOutside(event.target, elements, ignoreRef.current)) handlerRef.current(event);
     }
     document.addEventListener("pointerdown", onPointerDown, true);
     return () => document.removeEventListener("pointerdown", onPointerDown, true);

package/dist/chunk-EXEJI4FK.js

@@ -0,0 +1,43 @@
+"use client";
+import {
+  copyText
+} from "./chunk-FE3BQD2I.js";
+
+// src/clipboard/use-copy-feedback.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function useCopyFeedback({ resetMs = 1500 } = {}) {
+  const [status, setStatus] = useState("idle");
+  const timerRef = useRef(void 0);
+  const clearTimer = useCallback(() => {
+    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    timerRef.current = void 0;
+  }, []);
+  useEffect(() => clearTimer, [clearTimer]);
+  const copy = useCallback(
+    async (text) => {
+      const result = await copyText(text);
+      clearTimer();
+      setStatus(result.ok ? "copied" : "failed");
+      timerRef.current = setTimeout(() => setStatus("idle"), resetMs);
+      return result;
+    },
+    [clearTimer, resetMs]
+  );
+  return { copy, status };
+}
+
+// src/clipboard/read-text.ts
+async function readText() {
+  const hasClipboardApi = typeof navigator !== "undefined" && !!navigator.clipboard?.readText && typeof window !== "undefined" && window.isSecureContext;
+  if (!hasClipboardApi) return { ok: false, reason: "unavailable" };
+  try {
+    return { ok: true, text: await navigator.clipboard.readText() };
+  } catch {
+    return { ok: false, reason: "denied" };
+  }
+}
+
+export {
+  useCopyFeedback,
+  readText
+};

package/dist/{chunk-3CACI4OQ.js → chunk-FE3BQD2I.js}

@@ -39,30 +39,6 @@ function execCommandCopy(text) {
   }
 }
 
-// src/clipboard/use-copy-feedback.ts
-import { useCallback, useEffect, useRef, useState } from "react";
-function useCopyFeedback({ resetMs = 1500 } = {}) {
-  const [status, setStatus] = useState("idle");
-  const timerRef = useRef(void 0);
-  const clearTimer = useCallback(() => {
-    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
-    timerRef.current = void 0;
-  }, []);
-  useEffect(() => clearTimer, [clearTimer]);
-  const copy = useCallback(
-    async (text) => {
-      const result = await copyText(text);
-      clearTimer();
-      setStatus(result.ok ? "copied" : "failed");
-      timerRef.current = setTimeout(() => setStatus("idle"), resetMs);
-      return result;
-    },
-    [clearTimer, resetMs]
-  );
-  return { copy, status };
-}
-
 export {
-  copyText,
-  useCopyFeedback
+  copyText
 };

package/dist/chunk-HTVNN2NM.js

@@ -0,0 +1,29 @@
+"use client";
+import {
+  COARSE_POINTER_QUERY,
+  REDUCED_MOTION_QUERY,
+  getMatches,
+  subscribe
+} from "./chunk-WVM2LTWQ.js";
+
+// src/media-query/use-media-query.ts
+import { useCallback, useSyncExternalStore } from "react";
+function useMediaQuery(query, options = {}) {
+  const serverDefault = options.serverDefault ?? false;
+  const subscribeToQuery = useCallback((onChange) => subscribe(query, onChange), [query]);
+  const getSnapshot = useCallback(() => getMatches(query) ?? serverDefault, [query, serverDefault]);
+  const getServerSnapshot = useCallback(() => serverDefault, [serverDefault]);
+  return useSyncExternalStore(subscribeToQuery, getSnapshot, getServerSnapshot);
+}
+function useReducedMotion(options) {
+  return useMediaQuery(REDUCED_MOTION_QUERY, options);
+}
+function useCoarsePointer(options) {
+  return useMediaQuery(COARSE_POINTER_QUERY, options);
+}
+
+export {
+  useMediaQuery,
+  useReducedMotion,
+  useCoarsePointer
+};

package/dist/chunk-R2PFNE3U.js

@@ -0,0 +1,154 @@
+"use client";
+import {
+  isIos,
+  isStandalone
+} from "./chunk-YFMMSLMB.js";
+
+// src/push/use-push-subscription.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/push/support.ts
+function getPushSupport(env = readPushEnv()) {
+  if (env.isIos && !env.isStandalone) return "ios-needs-install";
+  if (!env.hasPushManager || !env.hasServiceWorker || !env.hasNotification) return "unsupported";
+  return "supported";
+}
+function readPushEnv() {
+  const browser = typeof window !== "undefined" && typeof navigator !== "undefined";
+  return {
+    hasPushManager: browser && "PushManager" in window,
+    hasServiceWorker: browser && "serviceWorker" in navigator,
+    hasNotification: browser && "Notification" in window,
+    isIos: browser && isIos(),
+    isStandalone: browser && isStandalone()
+  };
+}
+function readPermission() {
+  if (typeof window === "undefined" || !("Notification" in window)) return "unsupported";
+  return Notification.permission;
+}
+function isKeyReady(key) {
+  return key.trim().length > 0;
+}
+function shouldResubscribe({ permission, hasSubscription, resubscribeOnLoad, hasKey = true }) {
+  return hasKey && resubscribeOnLoad && permission === "granted" && !hasSubscription;
+}
+function isGone(error) {
+  return typeof error === "object" && error !== null && error.status === 410;
+}
+
+// src/push/vapid.ts
+function urlBase64ToUint8Array(key) {
+  const padding = "=".repeat((4 - key.length % 4) % 4);
+  const base64 = (key + padding).replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(base64);
+  const out = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
+  return out;
+}
+
+// src/push/register.ts
+function subscribeFresh(reg, vapidPublicKey) {
+  return reg.pushManager.subscribe({
+    userVisibleOnly: true,
+    // lib.dom wants ArrayBufferView<ArrayBuffer>; a Uint8Array satisfies the runtime contract.
+    applicationServerKey: urlBase64ToUint8Array(vapidPublicKey)
+  });
+}
+async function ensureSubscribed(reg, { vapidPublicKey, onSubscribe }, existing) {
+  let sub = existing ?? await reg.pushManager.getSubscription() ?? await subscribeFresh(reg, vapidPublicKey);
+  try {
+    await onSubscribe(sub.toJSON());
+  } catch (error) {
+    if (!isGone(error)) throw error;
+    await sub.unsubscribe();
+    sub = await subscribeFresh(reg, vapidPublicKey);
+    await onSubscribe(sub.toJSON());
+  }
+  return sub;
+}
+
+// src/push/use-push-subscription.ts
+var messageOf = (error, fallback) => error instanceof Error ? error.message : fallback;
+function usePushSubscription(options) {
+  const { resubscribeOnLoad = true } = options;
+  const [support, setSupport] = useState("unsupported");
+  const [permission, setPermission] = useState("unsupported");
+  const [subscribed, setSubscribed] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState(null);
+  const hasKey = isKeyReady(options.vapidPublicKey);
+  const latest = useRef(options);
+  latest.current = options;
+  useEffect(() => {
+    const current = getPushSupport();
+    setSupport(current);
+    setPermission(readPermission());
+    if (current !== "supported") return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const reg = await navigator.serviceWorker.ready;
+        const existing = await reg.pushManager.getSubscription();
+        if (cancelled) return;
+        const permissionNow = readPermission();
+        setPermission(permissionNow);
+        if (existing) return setSubscribed(true);
+        if (!shouldResubscribe({ permission: permissionNow, hasSubscription: false, resubscribeOnLoad, hasKey })) return;
+        await ensureSubscribed(reg, latest.current);
+        if (!cancelled) setSubscribed(true);
+      } catch {
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [resubscribeOnLoad, hasKey]);
+  const subscribe = useCallback(async () => {
+    if (getPushSupport() !== "supported") return;
+    if (!isKeyReady(latest.current.vapidPublicKey)) {
+      setError("push key not ready");
+      return;
+    }
+    setError(null);
+    setBusy(true);
+    try {
+      const result = await Notification.requestPermission();
+      setPermission(result);
+      if (result !== "granted") return;
+      const reg = await navigator.serviceWorker.ready;
+      await ensureSubscribed(reg, latest.current);
+      setSubscribed(true);
+    } catch (e) {
+      setError(messageOf(e, "subscribe failed"));
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  const unsubscribe = useCallback(async () => {
+    if (getPushSupport() !== "supported") return;
+    setError(null);
+    setBusy(true);
+    try {
+      const reg = await navigator.serviceWorker.ready;
+      const sub = await reg.pushManager.getSubscription();
+      if (sub) {
+        await latest.current.onUnsubscribe(sub.endpoint);
+        await sub.unsubscribe();
+      }
+      setSubscribed(false);
+    } catch (e) {
+      setError(messageOf(e, "unsubscribe failed"));
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  return { support, permission, subscribed, busy, error, subscribe, unsubscribe };
+}
+
+export {
+  getPushSupport,
+  shouldResubscribe,
+  urlBase64ToUint8Array,
+  usePushSubscription
+};