@sweidos/eidos 1.0.34 → 1.2.0

package/dist/idb.js

@@ -1,80 +1,83 @@
-const p = "eidos";
-const o = "action-queue";
-let b = null;
-function a() {
+var f = "eidos", p = 1, o = "action-queue", b = null;
+function c() {
   return b ? Promise.resolve(b) : new Promise((s, n) => {
-    const t = indexedDB.open(p, 1);
-    t.onupgradeneeded = (r) => {
-      const e = r.target.result;
-      if (!e.objectStoreNames.contains(o)) {
-        const c = e.createObjectStore(o, { keyPath: "id" });
-        c.createIndex("status", "status", { unique: !1 }), c.createIndex("actionId", "actionId", { unique: !1 });
+    const r = indexedDB.open(f, p);
+    r.onupgradeneeded = (e) => {
+      const t = e.target.result;
+      if (!t.objectStoreNames.contains(o)) {
+        const a = t.createObjectStore(o, { keyPath: "id" });
+        a.createIndex("status", "status", { unique: !1 }), a.createIndex("actionId", "actionId", { unique: !1 });
       }
-    }, t.onsuccess = () => {
-      b = t.result, s(t.result);
-    }, t.onerror = () => n(t.error);
+    }, r.onsuccess = () => {
+      b = r.result, s(r.result);
+    }, r.onerror = () => n(r.error);
   });
 }
-async function x(s) {
-  const n = await a();
-  return new Promise((t, r) => {
-    const e = n.transaction(o, "readwrite");
-    e.objectStore(o).add(s), e.oncomplete = () => t(), e.onerror = () => r(e.error);
+async function g(s) {
+  const n = await c();
+  return new Promise((r, e) => {
+    const t = n.transaction(o, "readwrite");
+    t.objectStore(o).add(s), t.oncomplete = () => r(), t.onerror = () => e(t.error);
   });
 }
 async function y() {
-  const s = await a();
-  return new Promise((n, t) => {
+  const s = await c();
+  return new Promise((n, r) => {
     const e = s.transaction(o, "readonly").objectStore(o).getAll();
-    e.onsuccess = () => n(e.result), e.onerror = () => t(e.error);
+    e.onsuccess = () => n(e.result), e.onerror = () => r(e.error);
   });
 }
 async function P(s, n) {
-  const t = await a();
-  return new Promise((r, e) => {
-    const c = t.transaction(o, "readwrite"), i = c.objectStore(o), u = i.get(s);
-    u.onsuccess = () => {
-      u.result && i.put({ ...u.result, ...n });
-    }, c.oncomplete = () => r(), c.onerror = () => e(c.error);
+  const r = await c();
+  return new Promise((e, t) => {
+    const a = r.transaction(o, "readwrite"), u = a.objectStore(o), i = u.get(s);
+    i.onsuccess = () => {
+      i.result && u.put({
+        ...i.result,
+        ...n
+      });
+    }, a.oncomplete = () => e(), a.onerror = () => t(a.error);
   });
 }
 async function S(s) {
-  const n = await a();
-  return new Promise((t, r) => {
-    const e = n.transaction(o, "readwrite");
-    e.objectStore(o).delete(s), e.oncomplete = () => t(), e.onerror = () => r(e.error);
+  const n = await c();
+  return new Promise((r, e) => {
+    const t = n.transaction(o, "readwrite");
+    t.objectStore(o).delete(s), t.oncomplete = () => r(), t.onerror = () => e(t.error);
   });
 }
-async function g() {
-  const s = await a();
-  function n(e) {
-    return new Promise((c, i) => {
-      const w = s.transaction(o, "readonly").objectStore(o).index("status"), m = [], d = w.openCursor(IDBKeyRange.only(e));
-      d.onsuccess = (f) => {
-        const l = f.target.result;
-        l ? (m.push(l.value), l.continue()) : c(m);
-      }, d.onerror = () => i(d.error);
+async function x() {
+  const s = await c();
+  function n(t) {
+    return new Promise((a, u) => {
+      const i = s.transaction(o, "readonly").objectStore(o).index("status"), m = [], d = i.openCursor(IDBKeyRange.only(t));
+      d.onsuccess = (w) => {
+        const l = w.target.result;
+        l ? (m.push(l.value), l.continue()) : a(m);
+      }, d.onerror = () => u(d.error);
     });
   }
-  const [t, r] = await Promise.all([
-    n("pending"),
-    n("failed")
-  ]);
-  return [...t, ...r];
+  const [r, e] = await Promise.all([n("pending"), n("failed")]);
+  return [...r, ...e];
 }
-async function I() {
-  const s = await a();
-  return new Promise((n, t) => {
-    const r = s.transaction(o, "readwrite");
-    r.objectStore(o).clear(), r.oncomplete = () => n(), r.onerror = () => t(r.error);
+async function v() {
+  const s = await c();
+  return new Promise((n, r) => {
+    const e = s.transaction(o, "readwrite");
+    e.objectStore(o).clear(), e.oncomplete = () => n(), e.onerror = () => r(e.error);
   });
 }
+var j = {
+  add: g,
+  getAll: y,
+  getPending: x,
+  update: P,
+  remove: S,
+  clear: v
+};
 export {
-  x as idbAddToQueue,
-  I as idbClearQueue,
-  g as idbGetPendingItems,
   y as idbGetQueue,
-  S as idbRemoveFromQueue,
-  P as idbUpdateQueueItem
+  j as idbQueueStorage
 };
-//# sourceMappingURL=idb.js.map
+
+//# sourceMappingURL=idb.js.map

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { JSX as JSX_2 } from 'react';
+import { JSX } from 'react';
 import { ReactNode } from 'react';
 
 export declare function action<TArgs extends any[], TReturn>(fn: ActionFn<TArgs, TReturn>, config: ActionConfig): ActionHandle<TArgs, TReturn>;
@@ -13,6 +13,13 @@ export declare interface ActionConfig {
     maxRetries?: number;
     /** Human-readable name for the action (used in devtools). */
     name?: string;
+    /**
+     * Prefixes the registered action id (`namespace::name`). Use to avoid
+     * collisions when two actions share a name (e.g. across micro-frontends,
+     * or two `createOrder` actions in different modules) — without a
+     * namespace, the second registration silently overwrites the first.
+     */
+    namespace?: string;
     /**
      * Replay order when multiple queued actions are pending.
      * `'high'` items replay before `'normal'`, which replay before `'low'`.
@@ -21,9 +28,11 @@ export declare interface ActionConfig {
      */
     priority?: 'high' | 'normal' | 'low';
     /**
-     * Called immediately before the async function executes, with the same args.
-     * Use to apply an optimistic UI update (add item, mark as pending, etc.).
-     * Called on every invocation — online, offline, and during queue replay.
+     * Called immediately before the async function executes, with the same args
+     * plus a trailing `ActionContext`. Use to apply an optimistic UI update (add
+     * item, mark as pending, etc.) and to capture `idempotencyKey` for later
+     * `handle.cancel(idempotencyKey)` calls. Called on every invocation —
+     * online, offline, and during queue replay.
      */
     onOptimistic?: (...args: any[]) => void;
     /**
@@ -46,7 +55,25 @@ export declare interface ActionConfig {
      * The `error` argument is whatever `fn` threw — typically a `Response` object
      * or a custom error with a `.status` property.
      */
+    /**
+     * @deprecated Use `conflict` instead. If both are set, `conflict` wins.
+     * Return `'retry'` to keep the item in the queue and retry per normal
+     * backoff, or `'skip'` to silently remove the item.
+     */
     onConflict?: (error: unknown, args: any[]) => 'retry' | 'skip';
+    /**
+     * Declarative conflict-resolution strategy used during queue replay when
+     * the server responds with a 4xx status (conflict, gone, unprocessable,
+     * etc.). Replaces `onConflict` for new code — see `ConflictConfig`.
+     */
+    conflict?: ConflictConfig;
+    /**
+     * When `true`, each invocation gets an `AbortController` whose `signal` is
+     * passed via `ActionContext.signal`. Forward it to `fetch`/etc. so
+     * `handle.cancel(idempotencyKey)` can abort an in-flight call, or remove a
+     * not-yet-replayed queued item.
+     */
+    cancellable?: boolean;
 }
 
 declare type ActionFn<TArgs extends any[], TReturn> = (...args: TArgs) => Promise<TReturn>;
@@ -55,13 +82,28 @@ export declare interface ActionHandle<TArgs extends any[], TReturn> {
     (...args: TArgs): Promise<TReturn | QueuedResult>;
     readonly id: string;
     readonly config: ActionConfig;
+    /**
+     * Cancel an invocation by its `idempotencyKey` (from `ActionContext` /
+     * `onOptimistic`). Aborts the in-flight call if `cancellable: true` and
+     * still running, otherwise removes a not-yet-replayed queued item.
+     * Returns `true` if something was cancelled/removed.
+     */
+    cancel: (idempotencyKey: string) => Promise<boolean>;
 }
 
 export declare interface ActionQueueItem {
+    /** Shape version this item was persisted with. Items from before v2 are migrated on load. */
+    schemaVersion: number;
     id: string;
     /** ID of the registered action (maps to the function in the registry). */
     actionId: string;
     actionName: string;
+    /**
+     * Stable per-invocation key, generated once and reused across every retry/replay
+     * of this item. Pass to your server as an idempotency key so retries that reach
+     * the server after a dropped response don't double-execute.
+     */
+    idempotencyKey: string;
     args: unknown[];
     queuedAt: number;
     retryCount: number;
@@ -105,6 +147,46 @@ export declare type CacheStrategy = 'cache-first' | 'stale-while-revalidate' | '
 /** Remove all items from the action queue (storage + in-memory store). */
 export declare function clearQueue(): Promise<void>;
 
+declare interface ConflictConfig {
+    /**
+     * - `'serverWins'`: drop the queued item, keeping the server's state.
+     * - `'clientWins'`: keep retrying — the client's write should eventually
+     *   be accepted (e.g. once the server-side conflict is cleared).
+     * - `'lastWriteWins'`: same as `'clientWins'` for now — requires a
+     *   server-supplied timestamp contract to compare against `queuedAt`
+     *   (see Phase 3 of the roadmap). Treated as `'clientWins'` until then.
+     * - `'merge'` / `'custom'`: call `resolve` to decide.
+     */
+    strategy: 'serverWins' | 'clientWins' | 'lastWriteWins' | 'merge' | 'custom';
+    /** Required for `'merge'` and `'custom'`. */
+    resolve?: (ctx: ConflictContext) => ConflictResolution;
+}
+
+/**
+ * Passed to `ConflictConfig.resolve` (for `'merge'`/`'custom'` strategies)
+ * when a queued action's replay receives a 4xx response.
+ */
+declare interface ConflictContext {
+    /** Whatever `fn` threw — typically a `Response` or an error with `.status`. */
+    error: unknown;
+    /** The original arguments the action was queued with. */
+    args: any[];
+    /** Number of replay attempts so far (0 on first replay). */
+    attempt: number;
+    idempotencyKey: string;
+}
+
+/**
+ * Outcome of `ConflictConfig.resolve`:
+ * - `'retry'`: keep the item queued, retry per normal backoff.
+ * - `'skip'`: silently remove the item (no `onRollback`).
+ * - `{ resolved: args }`: replace the queued args and retry immediately
+ *   on the next replay pass.
+ */
+declare type ConflictResolution = 'retry' | 'skip' | {
+    resolved: any[];
+};
+
 /**
  * Live state for a single queue item by ID. Returns `undefined` once the item
  * is removed from the queue (after a successful replay or `clearQueue()`).
@@ -131,7 +213,7 @@ export declare interface EidosConfig {
  *   <App />
  * </EidosProvider>
  */
-export declare function EidosProvider({ children, swPath, autoReplay }: EidosProviderProps): JSX_2.Element;
+export declare function EidosProvider({ children, swPath, autoReplay }: EidosProviderProps): JSX.Element;
 
 declare interface EidosProviderProps extends EidosConfig {
     children: ReactNode;
@@ -185,20 +267,9 @@ export declare const eidosStatus: EidosReadable<{
     swError: string | undefined;
 }>;
 
-export declare interface EidosStore extends EidosState {
+export declare interface EidosStore extends EidosState, ResourceActions, QueueActions {
     setOnline: (online: boolean) => void;
     setSwStatus: (status: EidosState['swStatus'], error?: string) => void;
-    registerResource: (url: string, entry: ResourceEntry) => void;
-    updateResource: (url: string, update: Partial<ResourceEntry>) => void;
-    unregisterResource: (url: string) => void;
-    addQueueItem: (item: ActionQueueItem) => void;
-    updateQueueItem: (id: string, update: Partial<ActionQueueItem>) => void;
-    batchUpdateQueueItems: (updates: Array<{
-        id: string;
-        update: Partial<ActionQueueItem>;
-    }>) => void;
-    removeQueueItem: (id: string) => void;
-    hydrateQueue: (items: ActionQueueItem[]) => void;
 }
 
 /** Full Eidos state snapshot. Prefer the narrower stores below. */
@@ -220,14 +291,32 @@ export declare function _getQueueStorage(): QueueStorage | null;
 
 declare function _getState(): EidosStore;
 
+export declare function getSwRegistration(): ServiceWorkerRegistration | null;
+
 export declare function initEidos(config?: EidosConfig): Promise<void>;
 
 export declare function isBgSyncSupported(): boolean;
 
 declare type Listener = () => void;
 
+declare interface PushHandlers {
+    onNotificationClick?: (data: unknown) => void;
+    onSubscriptionExpired?: (sub: PushSubscriptionJSON) => void;
+}
+
 declare type QueryInvalidator = (queryKey: [string, string]) => void;
 
+declare interface QueueActions {
+    addQueueItem: (item: ActionQueueItem) => void;
+    updateQueueItem: (id: string, update: Partial<ActionQueueItem>) => void;
+    batchUpdateQueueItems: (updates: Array<{
+        id: string;
+        update: Partial<ActionQueueItem>;
+    }>) => void;
+    removeQueueItem: (id: string) => void;
+    hydrateQueue: (items: ActionQueueItem[]) => void;
+}
+
 export declare interface QueuedResult {
     readonly queued: true;
     readonly id: string;
@@ -243,6 +332,8 @@ export declare interface QueueStorage {
     clear(): Promise<void>;
 }
 
+export declare function registerPushCallbacks(handlers: PushHandlers): void;
+
 export declare function replayQueue(): Promise<ReplayResult>;
 
 /** Summary returned by replayQueue(). */
@@ -259,12 +350,20 @@ export declare interface ReplayResult {
     skipped: number;
     /** Items that received a 4xx response and were dropped via `onConflict: () => 'skip'`. */
     conflicted: number;
+    /** Items removed via `handle.cancel(idempotencyKey)` before/during replay. */
+    cancelled: number;
 }
 
 export declare function _resetEidos(): void;
 
 export declare function resource<T = unknown>(url: string, config: ResourceConfig): ResourceHandle<T>;
 
+declare interface ResourceActions {
+    registerResource: (url: string, entry: ResourceEntry) => void;
+    updateResource: (url: string, update: Partial<ResourceEntry>) => void;
+    unregisterResource: (url: string) => void;
+}
+
 export declare interface ResourceConfig {
     /** Make this resource available when the device is offline. */
     offline: boolean;
@@ -305,6 +404,8 @@ export declare interface ResourceHandle<T = unknown> {
     unregister: () => void;
 }
 
+export declare function sendToWorker(message: Record<string, unknown>): void;
+
 export declare function setOfflineSimulation(enabled: boolean): void;
 
 /* Excluded from this release type: setQueryInvalidator */
@@ -314,6 +415,22 @@ export declare function setQueueStorage(s: QueueStorage): void;
 
 declare function _subscribe(listener: Listener): () => void;
 
+/**
+ * Subscribe to online/offline transitions and trigger replayQueue() on
+ * reconnect, plus replay any pending items left over from a previous session.
+ *
+ * Shared by the web (runtime.ts) and React Native (runtime-rn.ts) init paths.
+ *
+ * WHY subscribe to the store instead of window.addEventListener('online'):
+ * setOfflineSimulation() updates the store directly but never fires a real
+ * browser `online` event. Watching the store catches both:
+ *   • Real network reconnects (sw-bridge updates store on window.online)
+ *   • Simulation toggled off (setOfflineSimulation(false) → store.setOnline(true))
+ *
+ * Returns an unsubscribe function.
+ */
+export declare function subscribeReplayOnReconnect(): () => void;
+
 /** Full Eidos store — prefer the narrower hooks below for performance. */
 export declare function useEidos(): EidosStore;
 
@@ -372,7 +489,7 @@ export declare const useEidosStore: {
     setState: (partial: Partial<EidosStore> | ((s: EidosStore) => Partial<EidosStore>)) => void;
 };
 
-export declare const VERSION = "1.0.34";
+export declare const VERSION = "1.2.0";
 
 /**
  * Bulk-prefetch an array of resource handles concurrently, warming the cache

package/dist/index.js

@@ -1,44 +1,48 @@
-import { resource as r, setQueryInvalidator as s, warmCache as t } from "./resource.js";
-import { action as i, clearQueue as d, replayQueue as a } from "./action.js";
-import { _resetEidos as S, initEidos as f } from "./runtime.js";
-import { _getQueueStorage as E, setQueueStorage as c } from "./queue-storage.js";
-import { AsyncStorageQueueStorage as x } from "./async-storage-adapter.js";
-import { EidosProvider as g } from "./react/Provider.js";
-import { useEidos as y, useEidosAction as R, useEidosOnDrain as A, useEidosQueue as O, useEidosQueueStats as v, useEidosResource as I, useEidosResources as _, useEidosStatus as h } from "./react/hooks.js";
-import { VERSION as B } from "./version.js";
-import { isBgSyncSupported as D, setOfflineSimulation as N } from "./sw-bridge.js";
-import { useEidosStore as V } from "./store.js";
-import { eidosAction as j, eidosQueue as k, eidosQueueStats as q, eidosResource as z, eidosStatus as F, eidosStore as G } from "./stores.js";
+import { useEidosStore as o } from "./store.js";
+import { getSwRegistration as s, isBgSyncSupported as i, registerPushCallbacks as t, sendToWorker as u, setOfflineSimulation as m } from "./sw-bridge.js";
+import { resource as a, setQueryInvalidator as p, warmCache as n } from "./resource.js";
+import { _getQueueStorage as S, setQueueStorage as f } from "./queue-storage.js";
+import { action as Q, clearQueue as g, replayQueue as l } from "./action.js";
+import { subscribeReplayOnReconnect as y } from "./replay.js";
+import { _resetEidos as b, initEidos as A } from "./runtime.js";
+import { AsyncStorageQueueStorage as k } from "./async-storage-adapter.js";
+import { EidosProvider as w } from "./react/Provider.js";
+import { useEidos as I, useEidosAction as P, useEidosOnDrain as _, useEidosQueue as x, useEidosQueueStats as B, useEidosResource as D, useEidosResources as N, useEidosStatus as T } from "./react/hooks.js";
+import { VERSION as W } from "./version.js";
+import { eidosAction as q, eidosQueue as z, eidosQueueStats as F, eidosResource as G, eidosStatus as H, eidosStore as J } from "./stores.js";
 export {
-  x as AsyncStorageQueueStorage,
-  g as EidosProvider,
-  B as VERSION,
-  E as _getQueueStorage,
-  S as _resetEidos,
-  i as action,
-  d as clearQueue,
-  j as eidosAction,
-  k as eidosQueue,
-  q as eidosQueueStats,
-  z as eidosResource,
-  F as eidosStatus,
-  G as eidosStore,
-  f as initEidos,
-  D as isBgSyncSupported,
-  a as replayQueue,
-  r as resource,
-  N as setOfflineSimulation,
-  s as setQueryInvalidator,
-  c as setQueueStorage,
-  y as useEidos,
-  R as useEidosAction,
-  A as useEidosOnDrain,
-  O as useEidosQueue,
-  v as useEidosQueueStats,
-  I as useEidosResource,
-  _ as useEidosResources,
-  h as useEidosStatus,
-  V as useEidosStore,
-  t as warmCache
+  k as AsyncStorageQueueStorage,
+  w as EidosProvider,
+  W as VERSION,
+  S as _getQueueStorage,
+  b as _resetEidos,
+  Q as action,
+  g as clearQueue,
+  q as eidosAction,
+  z as eidosQueue,
+  F as eidosQueueStats,
+  G as eidosResource,
+  H as eidosStatus,
+  J as eidosStore,
+  s as getSwRegistration,
+  A as initEidos,
+  i as isBgSyncSupported,
+  t as registerPushCallbacks,
+  l as replayQueue,
+  a as resource,
+  u as sendToWorker,
+  m as setOfflineSimulation,
+  p as setQueryInvalidator,
+  f as setQueueStorage,
+  y as subscribeReplayOnReconnect,
+  I as useEidos,
+  P as useEidosAction,
+  _ as useEidosOnDrain,
+  x as useEidosQueue,
+  B as useEidosQueueStats,
+  D as useEidosResource,
+  N as useEidosResources,
+  T as useEidosStatus,
+  o as useEidosStore,
+  n as warmCache
 };
-//# sourceMappingURL=index.js.map

package/dist/nextjs.js

@@ -1,12 +1,3 @@
 "use client";
 import { EidosProvider, useEidos, useEidosAction, useEidosOnDrain, useEidosQueue, useEidosQueueStats, useEidosResource, useEidosStatus } from "@sweidos/eidos";
-export {
-  EidosProvider,
-  useEidos,
-  useEidosAction,
-  useEidosOnDrain,
-  useEidosQueue,
-  useEidosQueueStats,
-  useEidosResource,
-  useEidosStatus
-};
+export { EidosProvider, useEidos, useEidosAction, useEidosOnDrain, useEidosQueue, useEidosQueueStats, useEidosResource, useEidosStatus };

package/dist/push.cjs

@@ -0,0 +1,120 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _sweidos_eidos = require("@sweidos/eidos");
+//#region src/push.ts
+/**
+* @sweidos/eidos/push
+*
+* Web Push integration. Framework-agnostic: register click/expiry handlers
+* once at app init (any tab), and trigger subscription from a user gesture.
+*
+* @example
+* ```ts
+* import { registerPushHandlers, subscribeToPush } from '@sweidos/eidos/push'
+*
+* // App init — every tab, no permission prompt
+* registerPushHandlers({
+*   onNotificationClick: (data) => router.push(data.url),
+*   onSubscriptionExpired: (sub) => fetch('/api/push-subscribe', { method: 'POST', body: JSON.stringify(sub) }),
+* })
+*
+* // User gesture (button click)
+* const result = await subscribeToPush({
+*   vapidPublicKey: import.meta.env.VITE_EIDOS_VAPID_PUBLIC_KEY,
+*   onSubscribe: (sub) => fetch('/api/push-subscribe', { method: 'POST', body: JSON.stringify(sub) }),
+* })
+* ```
+*/
+/** Why push is unavailable on this device, or null if it's supported. */
+function getPushUnsupportedReason() {
+	if (typeof window === "undefined") return "no-push-api";
+	if (/iPhone|iPad|iPod/.test(navigator.userAgent) && !navigator.standalone) return "ios-not-installed";
+	if (!("serviceWorker" in navigator) || !("PushManager" in window) || !("Notification" in window)) return "no-push-api";
+	return null;
+}
+function isPushSupported() {
+	return getPushUnsupportedReason() === null;
+}
+function getPushPermissionState() {
+	if (!isPushSupported()) return "unsupported";
+	return Notification.permission;
+}
+function registerPushHandlers(handlers) {
+	(0, _sweidos_eidos.registerPushCallbacks)(handlers);
+}
+async function subscribeToPush(config) {
+	if (!isPushSupported()) return { status: "unsupported" };
+	let permission;
+	try {
+		permission = await Notification.requestPermission();
+	} catch (error) {
+		return {
+			status: "error",
+			error
+		};
+	}
+	if (permission !== "granted") return { status: "denied" };
+	const registration = (0, _sweidos_eidos.getSwRegistration)();
+	if (!registration) return { status: "sw-not-ready" };
+	try {
+		const applicationServerKey = urlBase64ToUint8Array(config.vapidPublicKey);
+		let subscription = await registration.pushManager.getSubscription();
+		if (subscription && !subscriptionKeyMatches(subscription, config.vapidPublicKey)) {
+			await subscription.unsubscribe();
+			subscription = null;
+		}
+		if (!subscription) subscription = await registration.pushManager.subscribe({
+			userVisibleOnly: true,
+			applicationServerKey
+		});
+		(0, _sweidos_eidos.sendToWorker)({
+			type: "EIDOS_CACHE_VAPID_KEY",
+			key: config.vapidPublicKey
+		});
+		const json = subscription.toJSON();
+		config.onSubscribe?.(json);
+		return {
+			status: "subscribed",
+			subscription: json
+		};
+	} catch (error) {
+		return {
+			status: "error",
+			error
+		};
+	}
+}
+async function unsubscribeFromPush() {
+	const registration = (0, _sweidos_eidos.getSwRegistration)();
+	if (!registration) return;
+	await (await registration.pushManager.getSubscription())?.unsubscribe();
+}
+async function getCurrentPushSubscription() {
+	const registration = (0, _sweidos_eidos.getSwRegistration)();
+	if (!registration) return null;
+	const subscription = await registration.pushManager.getSubscription();
+	return subscription ? subscription.toJSON() : null;
+}
+function urlBase64ToUint8Array(base64Url) {
+	const base64 = (base64Url + "=".repeat((4 - base64Url.length % 4) % 4)).replace(/-/g, "+").replace(/_/g, "/");
+	const raw = atob(base64);
+	return Uint8Array.from(raw, (c) => c.charCodeAt(0));
+}
+function uint8ArrayToUrlBase64(bytes) {
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/** Compares an existing subscription's key against the configured VAPID public key. */
+function subscriptionKeyMatches(subscription, vapidPublicKey) {
+	const key = subscription.options.applicationServerKey;
+	if (!key) return false;
+	return uint8ArrayToUrlBase64(new Uint8Array(key)) === uint8ArrayToUrlBase64(urlBase64ToUint8Array(vapidPublicKey));
+}
+//#endregion
+exports.getCurrentPushSubscription = getCurrentPushSubscription;
+exports.getPushPermissionState = getPushPermissionState;
+exports.getPushUnsupportedReason = getPushUnsupportedReason;
+exports.isPushSupported = isPushSupported;
+exports.registerPushHandlers = registerPushHandlers;
+exports.subscribeToPush = subscribeToPush;
+exports.unsubscribeFromPush = unsubscribeFromPush;

package/dist/push.d.ts

@@ -0,0 +1,28 @@
+export interface PushHandlers {
+    /** Fired when the user clicks a notification while a tab is open. */
+    onNotificationClick?: (data: unknown) => void;
+    /** Fired when the browser silently rotates the push subscription. Re-send to your backend. */
+    onSubscriptionExpired?: (sub: PushSubscriptionJSON) => void;
+}
+export interface PushConfig {
+    /** Base64url-encoded VAPID public key. Generate with `npx @sweidos/eidos generate-vapid-keys`. */
+    vapidPublicKey: string;
+    /** Called with the new subscription right after a successful subscribe. Send this to your backend. */
+    onSubscribe?: (sub: PushSubscriptionJSON) => void;
+}
+export type PushResult = {
+    status: 'subscribed';
+    subscription: PushSubscriptionJSON;
+} | {
+    status: 'denied' | 'unsupported' | 'sw-not-ready' | 'error';
+    error?: unknown;
+};
+export type PushUnsupportedReason = 'no-push-api' | 'ios-not-installed' | null;
+/** Why push is unavailable on this device, or null if it's supported. */
+export declare function getPushUnsupportedReason(): PushUnsupportedReason;
+export declare function isPushSupported(): boolean;
+export declare function getPushPermissionState(): NotificationPermission | 'unsupported';
+export declare function registerPushHandlers(handlers: PushHandlers): void;
+export declare function subscribeToPush(config: PushConfig): Promise<PushResult>;
+export declare function unsubscribeFromPush(): Promise<void>;
+export declare function getCurrentPushSubscription(): Promise<PushSubscriptionJSON | null>;