@wow-two-beta/ui-vue 0.0.4 → 0.0.6

package/dist/foundation/notifications/hooks/UseNotificationPermission.d.ts

@@ -0,0 +1,27 @@
+import { ComputedRef, ShallowRef } from 'vue';
+import { NotificationPermissionState } from '../NotificationPermission';
+/** What {@link useNotificationPermission} returns. */
+export interface NotificationPermissionControls {
+    /** The current grant. `unsupported` during SSR and until mount, then the real value. */
+    readonly permission: Readonly<ShallowRef<NotificationPermissionState>>;
+    /** Convenience for `permission === 'granted'` — the gate a `notify` call sits behind. */
+    readonly granted: ComputedRef<boolean>;
+    /** Whether the Notification API exists at all: `false` only for `unsupported`. Hide the feature when false. */
+    readonly supported: ComputedRef<boolean>;
+    /** Whether a prompt is worth offering — `permission === 'default'`. False once the user has decided either way. */
+    readonly requestable: ComputedRef<boolean>;
+    /** Whether a {@link NotificationPermissionControls.request} call is in flight — the button's disabled flag. */
+    readonly requesting: Readonly<ShallowRef<boolean>>;
+    /**
+     * Prompts for the grant and resolves to the resulting state, which is also written to
+     * {@link NotificationPermissionControls.permission}. Never throws, never rejects.
+     */
+    readonly request: () => Promise<NotificationPermissionState>;
+}
+/**
+ * Exposes the notification grant as reactive state, with a `request()` that prompts for it.
+ *
+ * Updates when the grant changes — on request, and (where the Permissions API is available) on an external
+ * grant or revoke. Inherits the module's never-throws contract: `request` resolves to a state, never rejects.
+ */
+export declare function useNotificationPermission(): NotificationPermissionControls;

package/dist/foundation/notifications/hooks/UsePermissionState.d.ts

@@ -0,0 +1,14 @@
+import { MaybeRefOrGetter, ShallowRef } from 'vue';
+import { PermissionQueryName, PermissionQueryState } from '../QueryPermission';
+/**
+ * Follows a permission's state reactively, updating when the user grants or revokes it — including from
+ * the browser's own site settings or another tab.
+ *
+ * Holds `null` while the first query is in flight (and during SSR), then a {@link PermissionQueryState}.
+ * Changing `name` resets to `null` and re-queries. Never throws.
+ *
+ * @param name The permission to follow — `'notifications'`, `'geolocation'`, `'camera'`, … A ref or getter
+ *   re-queries when it changes.
+ * @returns The current state, or `null` before the first answer.
+ */
+export declare function usePermissionState(name: MaybeRefOrGetter<PermissionQueryName>): Readonly<ShallowRef<PermissionQueryState | null>>;

package/dist/foundation/notifications/index.d.ts

@@ -1,6 +1,7 @@
 export { type NotificationPermissionState, getNotificationPermission, requestNotificationPermission, } from './NotificationPermission';
 export { canNotify } from './CanNotify';
-export { notify, type NotifyOptions, type NotifyResult, type NotifyStatus } from './Notify';
+export { notify, type NotificationFailure, type NotifyOptions, type NotificationShowResult, type NotifyStatus, } from './Notify';
 export { queryPermission, type PermissionQueryName, type PermissionQueryState } from './QueryPermission';
-export { usePermissionState } from './UsePermissionState';
-export { useNotificationPermission, type NotificationPermissionControls } from './UseNotificationPermission';
+export { usePermissionState } from './hooks/UsePermissionState';
+export { useNotificationPermission, type NotificationPermissionControls } from './hooks/UseNotificationPermission';
+export { NotificationFailureCode } from './NotificationFailureCode';

package/dist/foundation/notifications/index.js

@@ -1,7 +1,17 @@
-import { t as toError } from "../../chunks/ToError-CyTBsmLO.js";
-import { s as subscribeToPermissionChange } from "../../chunks/QueryPermission--OKfvS9c.js";
-import { q } from "../../chunks/QueryPermission--OKfvS9c.js";
+import { t as toError } from "../../chunks/ToError-vXncXe19.js";
+import { s as subscribeToPermissionChange } from "../../chunks/QueryPermission-BsLR2WRk.js";
+import { q } from "../../chunks/QueryPermission-BsLR2WRk.js";
 import { shallowRef, onMounted, watch, toValue, onScopeDispose, computed } from "vue";
+const NotificationPermissionState = {
+  /** Notifications will be shown. */
+  Granted: "granted",
+  /** The user refused. The prompt will not reappear; only browser settings can undo it. */
+  Denied: "denied",
+  /** Not decided yet — the only state where {@link requestNotificationPermission} shows a prompt. */
+  Default: "default",
+  /** No Notification API here: SSR, a non-supporting browser, or an unreadable implementation. */
+  Unsupported: "unsupported"
+};
 function isNotificationSupported() {
   try {
     return typeof Notification === "function";
@@ -17,8 +27,10 @@ function hasRequestPermission() {
   }
 }
 function normalizePermission(value) {
-  if (value === "granted" || value === "denied" || value === "default") return value;
-  return "default";
+  if (value === NotificationPermissionState.Granted || value === NotificationPermissionState.Denied || value === NotificationPermissionState.Default) {
+    return value;
+  }
+  return NotificationPermissionState.Default;
 }
 function isPromiseLike(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -45,15 +57,15 @@ function requestRawPermission() {
   });
 }
 function getNotificationPermission() {
-  if (!isNotificationSupported()) return "unsupported";
+  if (!isNotificationSupported()) return NotificationPermissionState.Unsupported;
   try {
     return normalizePermission(Notification.permission);
   } catch {
-    return "unsupported";
+    return NotificationPermissionState.Unsupported;
   }
 }
 async function requestNotificationPermission() {
-  if (!hasRequestPermission()) return "unsupported";
+  if (!hasRequestPermission()) return NotificationPermissionState.Unsupported;
   try {
     return normalizePermission(await requestRawPermission());
   } catch {
@@ -119,17 +131,17 @@ function wireLifecycle(notification, options) {
 }
 function notify(title, options) {
   const permission = getNotificationPermission();
-  if (permission === "unsupported") return { status: "unsupported" };
-  if (permission !== "granted") return { status: "denied" };
+  if (permission === "unsupported") return { ok: false, failure: { status: "unsupported" } };
+  if (permission !== "granted") return { ok: false, failure: { status: "denied" } };
   const settings = options ?? {};
   let notification;
   try {
     notification = new Notification(title, toNativeNotificationOptions(settings));
   } catch (error) {
-    return { status: "failed", error: toError(error) };
+    return { ok: false, failure: { status: "failed", error: toError(error) } };
   }
   wireLifecycle(notification, settings);
-  return { status: "shown", notification };
+  return { ok: true, value: notification };
 }
 function usePermissionState(name) {
   const state = shallowRef(null);
@@ -168,15 +180,19 @@ function useNotificationPermission() {
     unsubscribe?.();
     unsubscribe = void 0;
   });
-  const request = async () => {
+  let pending;
+  const request = () => {
+    if (pending !== void 0) return pending;
+    if (!active) return Promise.resolve(permission.value);
     requesting.value = true;
-    try {
-      const outcome = await requestNotificationPermission();
-      permission.value = outcome;
+    pending = requestNotificationPermission().then((outcome) => {
+      if (active) permission.value = outcome;
       return outcome;
-    } finally {
-      requesting.value = false;
-    }
+    }).finally(() => {
+      pending = void 0;
+      if (active) requesting.value = false;
+    });
+    return pending;
   };
   return {
     permission,
@@ -187,7 +203,13 @@ function useNotificationPermission() {
     request
   };
 }
+const NotificationFailureCode = {
+  Denied: "denied",
+  Unsupported: "unsupported",
+  Failed: "failed"
+};
 export {
+  NotificationFailureCode,
   canNotify,
   getNotificationPermission,
   notify,

package/dist/foundation/notifications/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/notifications/NotificationPermission.ts","../../../src/foundation/notifications/CanNotify.ts","../../../src/foundation/notifications/Notify.ts","../../../src/foundation/notifications/UsePermissionState.ts","../../../src/foundation/notifications/UseNotificationPermission.ts"],"sourcesContent":["// The permission half of the web-notification vector: read the current grant, ask for one. Two entry points,\n// one four-member union, no throw.\n//\n// `Notification.permission` is a synchronous static read, so the getter needs no promise. What it does need is a\n// fourth state the platform itself does not have: `unsupported`. Under SSR, and on a browser without the API,\n// there is nothing to grant — and a consumer must render that differently from `denied` (\"the user said no\",\n// which is recoverable only through browser settings) and from `default` (\"not asked yet\", the one state where\n// an enable button makes sense).\n//\n// `requestPermission` ships in two incompatible shapes. The modern one returns a promise; Safari before 16\n// returns `undefined` and invokes a callback instead. Passing the callback AND adopting a returned promise\n// covers both at once — modern engines still honour the deprecated callback, so both may fire, and a\n// settle-once latch keeps the second from mattering.\n\n/**\n * The state of this origin's notification grant.\n *\n * - `granted` — notifications will be shown.\n * - `denied` — the user refused. The prompt will not reappear; only browser settings can undo it.\n * - `default` — not decided yet. The only state where {@link requestNotificationPermission} shows a prompt.\n * - `unsupported` — no Notification API here: SSR, a non-supporting browser, or an unreadable implementation.\n */\nexport type NotificationPermissionState = 'granted' | 'denied' | 'default' | 'unsupported';\n\n/**\n * Whether the environment exposes a constructible `Notification`. False under SSR and on non-supporting\n * browsers. Exported for the sibling modules; absent from the barrel — callers ask\n * {@link getNotificationPermission} instead, whose `unsupported` answer carries the same information.\n */\nexport function isNotificationSupported(): boolean {\n  try {\n    // `typeof` on an undeclared identifier is safe, but a defined-with-a-throwing-getter global is not — hence\n    // the guard around what looks like it cannot fail.\n    return typeof Notification === 'function';\n  } catch {\n    return false;\n  }\n}\n\n/** Whether the platform's `requestPermission` static is callable at all. */\nfunction hasRequestPermission(): boolean {\n  try {\n    return isNotificationSupported() && typeof Notification.requestPermission === 'function';\n  } catch {\n    return false;\n  }\n}\n\n/** Maps whatever the platform answered onto the union, tolerating an off-spec implementation. */\nfunction normalizePermission(value: unknown): NotificationPermissionState {\n  if (value === 'granted' || value === 'denied' || value === 'default') return value;\n  // An answer we don't recognize tells us nothing about the grant. `default` is the one state where asking\n  // again is both harmless and useful, so an unreadable answer degrades to \"not decided yet\".\n  return 'default';\n}\n\n/** Narrows a value to something awaitable — the modern `requestPermission` return, or any thenable polyfill. */\nfunction isPromiseLike(value: unknown): value is PromiseLike<unknown> {\n  if (typeof value !== 'object' || value === null) return false;\n  try {\n    return typeof (value as { then?: unknown }).then === 'function';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Calls `Notification.requestPermission` in whichever shape the browser implements and resolves to its raw\n * answer. Rejects only when the platform call itself fails — the caller turns that into a state.\n */\nfunction requestRawPermission(): Promise<unknown> {\n  return new Promise<unknown>((resolve, reject) => {\n    let settled = false;\n    const settle = (value: unknown): void => {\n      if (settled) return;\n      settled = true;\n      resolve(value);\n    };\n\n    // The callback argument is what legacy Safari answers through; modern engines accept it too (deprecated,\n    // not removed) and additionally return a promise. Whichever arrives first wins.\n    const returned: unknown = Notification.requestPermission(settle);\n\n    if (isPromiseLike(returned)) {\n      returned.then(settle, reject);\n      return;\n    }\n    // A synchronous implementation that answers by return value rather than by callback.\n    if (returned !== undefined) settle(returned);\n    // Otherwise the callback is the only channel left: legacy Safari resolves this promise whenever the user\n    // decides. Deliberately un-timed — a prompt stays open as long as the user ignores it, and inventing a\n    // deadline would report `default` for a grant the user is about to give.\n  });\n}\n\n/**\n * Reads the current notification grant. Synchronous, SSR-safe, never throws.\n *\n * This is a static read, not a subscription — the platform fires no event when a grant changes. To re-render on\n * an external change, use `useNotificationPermission`, which pairs this read with a Permissions API signal.\n */\nexport function getNotificationPermission(): NotificationPermissionState {\n  if (!isNotificationSupported()) return 'unsupported';\n\n  try {\n    return normalizePermission(Notification.permission);\n  } catch {\n    // A throwing `permission` getter means the API is nominally present but unusable. Reported as `unsupported`\n    // so a consumer hides the enable affordance rather than offering one that cannot work.\n    return 'unsupported';\n  }\n}\n\n/**\n * Prompts for the notification grant and resolves to the resulting state. Never throws, never rejects.\n *\n * Call it from a user gesture — browsers increasingly refuse a prompt without one. Already-decided origins\n * resolve immediately with the standing answer instead of re-prompting; that is the platform's behaviour, not\n * a short-circuit here. When the platform call itself fails, the standing grant is read back and returned,\n * since that remains the truth of the matter.\n */\nexport async function requestNotificationPermission(): Promise<NotificationPermissionState> {\n  if (!hasRequestPermission()) return 'unsupported';\n\n  try {\n    return normalizePermission(await requestRawPermission());\n  } catch {\n    return getNotificationPermission();\n  }\n}\n","// Feature detection for the notification vector. Unlike `foundation/share`'s `canShare`, availability alone is\n// not the question: an origin can have the whole API and still be unable to show anything, because the user\n// never answered the prompt or refused it. So the check is the conjunction — API present AND grant held — and\n// the two halves stay separable through `getNotificationPermission`, whose `default` vs `denied` vs\n// `unsupported` distinction is what a consumer needs to decide between an enable button, a settings hint, and\n// hiding the feature entirely.\n\nimport { getNotificationPermission } from './NotificationPermission';\n\n/**\n * Whether `notify` would actually show something right now: the Notification API exists and this origin holds\n * the grant.\n *\n * Returns `false` under SSR, on a non-supporting browser, and — importantly — on a supporting browser that has\n * simply not been asked yet. A `false` here is therefore not a reason to hide the feature; check\n * `getNotificationPermission() === 'default'` first and offer the prompt.\n *\n * Never throws.\n */\nexport function canNotify(): boolean {\n  return getNotificationPermission() === 'granted';\n}\n","// The delivery half of the notification vector: one call, four outcomes, no throw.\n//\n// DEFINING CONTRACT: NOTHING HERE THROWS. This is called straight from a click handler or an effect, where a\n// throw is an unhandled error in the consumer's app — and the user, whose tab is in the background, sees\n// nothing at all. Every path resolves to a `NotifyResult` the caller switches on: a missing API, a missing\n// grant, a constructor that rejects the payload, even a hostile options getter.\n//\n// Synchronous by design, unlike `foundation/share`'s `share`: `new Notification()` is a synchronous call, and\n// returning the handle immediately is what lets a caller `close()` it, re-tag it, or keep it for later. The\n// permission prompt is the async part of this vector and lives in `NotificationPermission.ts`.\n//\n// `default` and `denied` both come back as `denied`. Not-granted is not-shown either way, and the distinction\n// that matters to a consumer — whether a prompt is still worth offering — is `getNotificationPermission`'s to\n// answer, not a delivery result's. Ask for the grant first; `notify` never prompts on its own, because a prompt\n// raised from a background timer is exactly the pattern browsers now punish.\n//\n// Auto-close is a convenience the platform lacks: `requireInteraction` aside, how long a notification lingers\n// is the OS's business, and a transient one often has to be closed by hand. The timer is cancelled the moment\n// the notification closes or is clicked, so a dismissed notification never leaves a pending `setTimeout`\n// holding its handle alive.\n\nimport { toError } from '../errors';\n\nimport { getNotificationPermission } from './NotificationPermission';\n\n/**\n * The outcome of a notification attempt.\n *\n * - `shown` — handed to the OS, carrying the live handle. \"Handed off\", not \"seen\": the platform reports\n *   neither whether it was rendered nor whether the user looked at it.\n * - `denied` — the API exists but this origin holds no grant (refused, or never asked).\n * - `unsupported` — no Notification API here: SSR, or a non-supporting browser.\n * - `failed` — construction threw, carrying the normalized `Error`.\n */\nexport type NotifyResult =\n  | { readonly status: 'shown'; readonly notification: Notification }\n  | { readonly status: 'denied' }\n  | { readonly status: 'unsupported' }\n  | { readonly status: 'failed'; readonly error: Error };\n\n/** The `status` discriminant of a {@link NotifyResult} — for a consumer's own switch or status→copy map. */\nexport type NotifyStatus = NotifyResult['status'];\n\n/** Tunes a notification. Every member is optional; a bare `notify(title)` is valid. */\nexport interface NotifyOptions {\n  /** Body text rendered under the title. */\n  readonly body?: string;\n\n  /** URL of an image to show as the notification's icon. */\n  readonly icon?: string;\n\n  /**\n   * Groups notifications: a new one carrying a `tag` replaces the visible one with the same `tag` instead of\n   * stacking. The way to update a progress or unread-count notification without spamming the OS.\n   */\n  readonly tag?: string;\n\n  /** Arbitrary payload carried on the notification and readable from the click handler via `notification.data`. */\n  readonly data?: unknown;\n\n  /** Suppresses sound and vibration. Some platforms require an explicit `false` to make noise at all. */\n  readonly silent?: boolean;\n\n  /** Keeps the notification on screen until the user acts on it. Honoured on desktop; widely ignored on mobile. */\n  readonly requireInteraction?: boolean;\n\n  /**\n   * Closes the notification this many milliseconds after it is shown. The timer is cancelled if the\n   * notification closes or is clicked first, so no pending timeout outlives it. Ignored when not a finite,\n   * non-negative number, and ignored by design alongside `requireInteraction` — the two contradict each other,\n   * and the platform decides which wins.\n   */\n  readonly autoCloseMs?: number;\n\n  /**\n   * Called when the user clicks the notification. The window is focused first — the reason a click handler is\n   * wanted at all is almost always \"bring me back to the app\" — so this callback only has to do the routing.\n   * A throw from it is swallowed. Note the notification is left open: most platforms dismiss it on click, and\n   * the caller holds the handle to `close()` it where they don't.\n   */\n  readonly onClick?: (event: Event) => void;\n}\n\n/**\n * Copies the caller's options into the mutable, defined-keys-only dictionary the constructor accepts. Members\n * the caller left unset never reach the platform as present-but-`undefined` keys — the same discipline as\n * `foundation/share`'s `toNativeSharePayload`. `autoCloseMs` and `onClick` are ours, not the platform's, and\n * are deliberately not forwarded.\n */\nfunction toNativeNotificationOptions(options: NotifyOptions): NotificationOptions {\n  const native: NotificationOptions = {};\n  if (options.body !== undefined) native.body = options.body;\n  if (options.icon !== undefined) native.icon = options.icon;\n  if (options.tag !== undefined) native.tag = options.tag;\n  if (options.data !== undefined) native.data = options.data;\n  if (options.silent !== undefined) native.silent = options.silent;\n  if (options.requireInteraction !== undefined) native.requireInteraction = options.requireInteraction;\n  return native;\n}\n\n/** Brings the app's window forward on a notification click. A refused focus is not an error worth raising. */\nfunction focusWindow(): void {\n  try {\n    if (typeof window === 'undefined' || typeof window.focus !== 'function') return;\n    window.focus();\n  } catch {\n    // Focus is a courtesy: a browser may refuse it without transient activation, or across origins. A refusal\n    // must not turn a delivered click into an exception.\n  }\n}\n\n/** Attaches a listener, tolerating a stand-in without a usable `EventTarget` surface. */\nfunction addListener(target: Notification, type: 'click' | 'close', listener: (event: Event) => void): void {\n  try {\n    target.addEventListener(type, listener);\n  } catch {\n    // A partial implementation or test double simply gets no wiring — never a throw out of `notify`.\n  }\n}\n\n/**\n * Wires the click convenience and the auto-close timer onto a freshly constructed notification.\n *\n * Guarded end-to-end, and deliberately not part of the caller's `try`: the notification is already on screen by\n * the time this runs, so a hostile `options` getter must not downgrade a `shown` result to `failed` and throw\n * away the handle. Listeners are added rather than assigned to `onclick` / `onclose`, so a consumer's own\n * handler on the returned notification survives.\n */\nfunction wireLifecycle(notification: Notification, options: NotifyOptions): void {\n  try {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    const cancelAutoClose = (): void => {\n      if (timer === undefined) return;\n      clearTimeout(timer);\n      timer = undefined;\n    };\n\n    addListener(notification, 'close', cancelAutoClose);\n\n    addListener(notification, 'click', (event) => {\n      cancelAutoClose();\n      focusWindow();\n      const { onClick } = options;\n      if (onClick === undefined) return;\n      try {\n        onClick(event);\n      } catch {\n        // The consumer's own handler failed. There is nothing useful left to do with that — and an\n        // `EventTarget` would otherwise surface it as an uncaught error at the dispatch site.\n      }\n    });\n\n    const { autoCloseMs } = options;\n    if (typeof autoCloseMs !== 'number' || !Number.isFinite(autoCloseMs) || autoCloseMs < 0) return;\n\n    timer = setTimeout(() => {\n      timer = undefined;\n      try {\n        notification.close();\n      } catch {\n        // Closing an already-gone notification is a no-op everywhere real; a stand-in may disagree.\n      }\n    }, autoCloseMs);\n  } catch {\n    // A throwing member on the caller's `options` object. The notification stays shown and unwired.\n  }\n}\n\n/**\n * Shows an OS-level notification and returns a {@link NotifyResult}. Never throws.\n *\n * Requires a granted permission — this call never prompts. Pair it with `getNotificationPermission` /\n * `requestNotificationPermission` (or the `useNotificationPermission` hook) and treat `denied` as \"ask first\",\n * not \"retry\".\n *\n * @param title The notification's headline. Some platforms truncate it aggressively.\n * @param options Body, icon, tag, and the {@link NotifyOptions.autoCloseMs} / {@link NotifyOptions.onClick}\n *   conveniences this module adds on top of the platform dictionary.\n */\nexport function notify(title: string, options?: NotifyOptions): NotifyResult {\n  const permission = getNotificationPermission();\n  if (permission === 'unsupported') return { status: 'unsupported' };\n  if (permission !== 'granted') return { status: 'denied' };\n\n  const settings = options ?? {};\n\n  let notification: Notification;\n  try {\n    notification = new Notification(title, toNativeNotificationOptions(settings));\n  } catch (error) {\n    // Construction is where the platform vetoes: a payload it rejects, a browser that only allows notifications\n    // from a service worker (mobile Chrome), a document that lost its permission mid-session.\n    return { status: 'failed', error: toError(error) };\n  }\n\n  wireLifecycle(notification, settings);\n  return { status: 'shown', notification };\n}\n","// The Vue binding of the Permissions API — a permission's state as reactive data, kept current by the\n// platform's `change` event and torn down when the scope is disposed.\n//\n// The state is `null` until the first answer arrives. The query is asynchronous and there is no synchronous\n// snapshot to read, so seeding the ref with a real-looking value would have to invent a server value and a\n// first-paint value — and any invented value here is a lie that flips a moment later: rendering \"Blocked\" or\n// \"Not supported\" for one frame before the real answer lands is worse than rendering nothing. `null` says\n// exactly what is true — not known yet — and covers the SSR pass unchanged.\n//\n// The subscription is attached in `onMounted`, never in an immediate watcher: `subscribeToPermissionChange`\n// reaches for `navigator`, which does not exist during a server render.\n\nimport { onMounted, onScopeDispose, shallowRef, toValue, watch, type MaybeRefOrGetter, type ShallowRef } from 'vue';\n\nimport {\n  subscribeToPermissionChange,\n  type PermissionQueryName,\n  type PermissionQueryState,\n} from './QueryPermission';\n\n/**\n * Follows a permission's state reactively, updating when the user grants or revokes it — including from\n * the browser's own site settings or another tab.\n *\n * Holds `null` while the first query is in flight (and during SSR), then a {@link PermissionQueryState}.\n * Changing `name` resets to `null` and re-queries. Never throws.\n *\n * @param name The permission to follow — `'notifications'`, `'geolocation'`, `'camera'`, … A ref or getter\n *   re-queries when it changes.\n * @returns The current state, or `null` before the first answer.\n */\nexport function usePermissionState(\n  name: MaybeRefOrGetter<PermissionQueryName>,\n): Readonly<ShallowRef<PermissionQueryState | null>> {\n  const state = shallowRef<PermissionQueryState | null>(null);\n\n  let unsubscribe: (() => void) | undefined;\n\n  function stop(): void {\n    unsubscribe?.();\n    unsubscribe = undefined;\n  }\n\n  function start(): void {\n    stop();\n    // A new `name` invalidates the previous answer immediately — showing the old permission's state under the\n    // new name's label would be simply wrong, where `null` is merely uninformative.\n    state.value = null;\n    unsubscribe = subscribeToPermissionChange(toValue(name), (next) => {\n      state.value = next;\n    });\n  }\n\n  onMounted(start);\n  // Non-immediate on purpose: an immediate watcher runs on the server, where `navigator` is absent.\n  watch(() => toValue(name), start);\n  onScopeDispose(stop);\n\n  return state;\n}\n","// The Vue binding of the permission half — the grant as reactive data, plus the one action that changes it,\n// so an \"Enable notifications\" button is a `permission` switch and a `request` call rather than four refs\n// re-declared per consumer.\n//\n// Two sources, one value. `Notification.permission` is authoritative but silent — it fires no event, so a\n// revoke from browser settings or a grant given in another tab would leave a mounted component stale forever.\n// The Permissions API fires that event but reports its own vocabulary (`prompt`, not `default`) and is absent\n// on older Safari. So the change event is used purely as a SIGNAL: every notification re-reads\n// `Notification.permission`, and the Permissions API's own state is never mapped or displayed. Where the API is\n// missing, the value is simply the mount-time read plus whatever `request` returns — which is what a consumer\n// would have written by hand anyway.\n//\n// The initial state is `unsupported` rather than a setup-time read, so the server pass and the first client\n// render agree and hydration is clean; `onMounted` syncs to the truth immediately after mount. Reading\n// `Notification.permission` during setup would throw on the server, where the global does not exist.\n\nimport { computed, onMounted, onScopeDispose, shallowRef, type ComputedRef, type ShallowRef } from 'vue';\n\nimport {\n  getNotificationPermission,\n  requestNotificationPermission,\n  type NotificationPermissionState,\n} from './NotificationPermission';\nimport { subscribeToPermissionChange } from './QueryPermission';\n\n/** What {@link useNotificationPermission} returns. */\nexport interface NotificationPermissionControls {\n  /** The current grant. `unsupported` during SSR and until mount, then the real value. */\n  readonly permission: Readonly<ShallowRef<NotificationPermissionState>>;\n\n  /** Convenience for `permission === 'granted'` — the gate a `notify` call sits behind. */\n  readonly granted: ComputedRef<boolean>;\n\n  /** Whether the Notification API exists at all: `false` only for `unsupported`. Hide the feature when false. */\n  readonly supported: ComputedRef<boolean>;\n\n  /** Whether a prompt is worth offering — `permission === 'default'`. False once the user has decided either way. */\n  readonly requestable: ComputedRef<boolean>;\n\n  /** Whether a {@link NotificationPermissionControls.request} call is in flight — the button's disabled flag. */\n  readonly requesting: Readonly<ShallowRef<boolean>>;\n\n  /**\n   * Prompts for the grant and resolves to the resulting state, which is also written to\n   * {@link NotificationPermissionControls.permission}. Never throws, never rejects.\n   */\n  readonly request: () => Promise<NotificationPermissionState>;\n}\n\n/**\n * Exposes the notification grant as reactive state, with a `request()` that prompts for it.\n *\n * Updates when the grant changes — on request, and (where the Permissions API is available) on an external\n * grant or revoke. Inherits the module's never-throws contract: `request` resolves to a state, never rejects.\n */\nexport function useNotificationPermission(): NotificationPermissionControls {\n  const permission = shallowRef<NotificationPermissionState>('unsupported');\n  const requesting = shallowRef(false);\n\n  let active = false;\n  let unsubscribe: (() => void) | undefined;\n\n  const sync = (): void => {\n    if (active) permission.value = getNotificationPermission();\n  };\n\n  onMounted(() => {\n    active = true;\n    sync();\n    // The delivered state is ignored on purpose — see the header: this subscription is a change signal, and\n    // `Notification.permission` is the value. Its immediate first emission is simply a redundant `sync`.\n    unsubscribe = subscribeToPermissionChange('notifications', sync);\n  });\n\n  onScopeDispose(() => {\n    active = false;\n    unsubscribe?.();\n    unsubscribe = undefined;\n  });\n\n  const request = async (): Promise<NotificationPermissionState> => {\n    requesting.value = true;\n    try {\n      const outcome = await requestNotificationPermission();\n      permission.value = outcome;\n      return outcome;\n    } finally {\n      // `requestNotificationPermission` is contractually throw-free, but a state machine that can strand itself\n      // at `requesting` would disable the button forever, so the reset does not depend on that holding.\n      requesting.value = false;\n    }\n  };\n\n  return {\n    permission,\n    granted: computed(() => permission.value === 'granted'),\n    supported: computed(() => permission.value !== 'unsupported'),\n    requestable: computed(() => permission.value === 'default'),\n    requesting,\n    request,\n  };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/notifications/NotificationPermission.ts","../../../src/foundation/notifications/CanNotify.ts","../../../src/foundation/notifications/Notify.ts","../../../src/foundation/notifications/hooks/UsePermissionState.ts","../../../src/foundation/notifications/hooks/UseNotificationPermission.ts","../../../src/foundation/notifications/NotificationFailureCode.ts"],"sourcesContent":["/**\n * The state of this origin's notification grant.\n *\n * - `granted` — notifications will be shown.\n * - `denied` — the user refused. The prompt will not reappear; only browser settings can undo it.\n * - `default` — not decided yet. The only state where {@link requestNotificationPermission} shows a prompt.\n * - `unsupported` — no Notification API here: SSR, a non-supporting browser, or an unreadable implementation.\n */\nexport const NotificationPermissionState = {\n  /** Notifications will be shown. */\n  Granted: 'granted',\n\n  /** The user refused. The prompt will not reappear; only browser settings can undo it. */\n  Denied: 'denied',\n\n  /** Not decided yet — the only state where {@link requestNotificationPermission} shows a prompt. */\n  Default: 'default',\n\n  /** No Notification API here: SSR, a non-supporting browser, or an unreadable implementation. */\n  Unsupported: 'unsupported',\n} as const;\n\n/** The state of this origin's notification grant. */\nexport type NotificationPermissionState =\n  (typeof NotificationPermissionState)[keyof typeof NotificationPermissionState];\n\n/**\n * Whether the environment exposes a constructible `Notification`. False under SSR and on non-supporting\n * browsers. Exported for the sibling modules; absent from the barrel — callers ask\n * {@link getNotificationPermission} instead, whose `unsupported` answer carries the same information.\n */\nexport function isNotificationSupported(): boolean {\n  try {\n    // `typeof` on an undeclared identifier is safe, but a defined-with-a-throwing-getter global is not — hence\n    // the guard around what looks like it cannot fail.\n    return typeof Notification === 'function';\n  } catch {\n    return false;\n  }\n}\n\n/** Whether the platform's `requestPermission` static is callable at all. */\nfunction hasRequestPermission(): boolean {\n  try {\n    return isNotificationSupported() && typeof Notification.requestPermission === 'function';\n  } catch {\n    return false;\n  }\n}\n\n/** Maps whatever the platform answered onto the union, tolerating an off-spec implementation. */\nfunction normalizePermission(value: unknown): NotificationPermissionState {\n  if (\n    value === NotificationPermissionState.Granted ||\n    value === NotificationPermissionState.Denied ||\n    value === NotificationPermissionState.Default\n  ) {\n    return value;\n  }\n  // An answer we don't recognize tells us nothing about the grant. `default` is the one state where asking\n  // again is both harmless and useful, so an unreadable answer degrades to \"not decided yet\".\n  return NotificationPermissionState.Default;\n}\n\n/** Narrows a value to something awaitable — the modern `requestPermission` return, or any thenable polyfill. */\nfunction isPromiseLike(value: unknown): value is PromiseLike<unknown> {\n  if (typeof value !== 'object' || value === null) return false;\n  try {\n    return typeof (value as { then?: unknown }).then === 'function';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Calls `Notification.requestPermission` in whichever shape the browser implements and resolves to its raw\n * answer. Rejects only when the platform call itself fails — the caller turns that into a state.\n */\nfunction requestRawPermission(): Promise<unknown> {\n  return new Promise<unknown>((resolve, reject) => {\n    let settled = false;\n    const settle = (value: unknown): void => {\n      if (settled) return;\n      settled = true;\n      resolve(value);\n    };\n\n    // The callback argument is what legacy Safari answers through; modern engines accept it too (deprecated,\n    // not removed) and additionally return a promise. Whichever arrives first wins.\n    const returned: unknown = Notification.requestPermission(settle);\n\n    if (isPromiseLike(returned)) {\n      returned.then(settle, reject);\n      return;\n    }\n    // A synchronous implementation that answers by return value rather than by callback.\n    if (returned !== undefined) settle(returned);\n    // Otherwise the callback is the only channel left: legacy Safari resolves this promise whenever the user\n    // decides. Deliberately un-timed — a prompt stays open as long as the user ignores it, and inventing a\n    // deadline would report `default` for a grant the user is about to give.\n  });\n}\n\n/**\n * Reads the current notification grant. Synchronous, SSR-safe, never throws.\n *\n * This is a static read, not a subscription — the platform fires no event when a grant changes. To re-render on\n * an external change, use `useNotificationPermission`, which pairs this read with a Permissions API signal.\n */\nexport function getNotificationPermission(): NotificationPermissionState {\n  if (!isNotificationSupported()) return NotificationPermissionState.Unsupported;\n\n  try {\n    return normalizePermission(Notification.permission);\n  } catch {\n    // A throwing `permission` getter means the API is nominally present but unusable. Reported as `unsupported`\n    // so a consumer hides the enable affordance rather than offering one that cannot work.\n    return NotificationPermissionState.Unsupported;\n  }\n}\n\n/**\n * Prompts for the notification grant and resolves to the resulting state. Never throws, never rejects.\n *\n * Call it from a user gesture — browsers increasingly refuse a prompt without one. Already-decided origins\n * resolve immediately with the standing answer instead of re-prompting; that is the platform's behaviour, not\n * a short-circuit here. When the platform call itself fails, the standing grant is read back and returned,\n * since that remains the truth of the matter.\n */\nexport async function requestNotificationPermission(): Promise<NotificationPermissionState> {\n  if (!hasRequestPermission()) return NotificationPermissionState.Unsupported;\n\n  try {\n    return normalizePermission(await requestRawPermission());\n  } catch {\n    return getNotificationPermission();\n  }\n}\n","import { getNotificationPermission } from './NotificationPermission';\n\n/**\n * Whether `notify` would actually show something right now: the Notification API exists and this origin holds\n * the grant.\n *\n * Returns `false` under SSR, on a non-supporting browser, and — importantly — on a supporting browser that has\n * simply not been asked yet. A `false` here is therefore not a reason to hide the feature; check\n * `getNotificationPermission() === 'default'` first and offer the prompt.\n *\n * Never throws.\n */\nexport function canNotify(): boolean {\n  return getNotificationPermission() === 'granted';\n}\n","import type { NotificationShowResult } from './models/NotificationShowResult';\nimport type { NotificationFailure } from './models/NotificationFailure';\n\nimport { toError } from '../errors';\n\nimport { getNotificationPermission } from './NotificationPermission';\nexport type { NotificationFailure } from './models/NotificationFailure';\nexport type { NotificationShowResult } from './models/NotificationShowResult';\nexport type NotifyStatus = 'shown' | NotificationFailure['status'];\n\n/** Tunes a notification. Every member is optional; a bare `notify(title)` is valid. */\nexport interface NotifyOptions {\n  /** Body text rendered under the title. */\n  readonly body?: string;\n\n  /** URL of an image to show as the notification's icon. */\n  readonly icon?: string;\n\n  /**\n   * Groups notifications: a new one carrying a `tag` replaces the visible one with the same `tag` instead of\n   * stacking. The way to update a progress or unread-count notification without spamming the OS.\n   */\n  readonly tag?: string;\n\n  /** Arbitrary payload carried on the notification and readable from the click handler via `notification.data`. */\n  readonly data?: unknown;\n\n  /** Suppresses sound and vibration. Some platforms require an explicit `false` to make noise at all. */\n  readonly silent?: boolean;\n\n  /** Keeps the notification on screen until the user acts on it. Honoured on desktop; widely ignored on mobile. */\n  readonly requireInteraction?: boolean;\n\n  /**\n   * Closes the notification this many milliseconds after it is shown. The timer is cancelled if the\n   * notification closes or is clicked first, so no pending timeout outlives it. Ignored when not a finite,\n   * non-negative number, and ignored by design alongside `requireInteraction` — the two contradict each other,\n   * and the platform decides which wins.\n   */\n  readonly autoCloseMs?: number;\n\n  /**\n   * Called when the user clicks the notification. The window is focused first — the reason a click handler is\n   * wanted at all is almost always \"bring me back to the app\" — so this callback only has to do the routing.\n   * A throw from it is swallowed. Note the notification is left open: most platforms dismiss it on click, and\n   * the caller holds the handle to `close()` it where they don't.\n   */\n  readonly onClick?: (event: Event) => void;\n}\n\n/**\n * Copies the caller's options into the mutable, defined-keys-only dictionary the constructor accepts. Members\n * the caller left unset never reach the platform as present-but-`undefined` keys — the same discipline as\n * `foundation/share`'s `toNativeSharePayload`. `autoCloseMs` and `onClick` are ours, not the platform's, and\n * are deliberately not forwarded.\n */\nfunction toNativeNotificationOptions(options: NotifyOptions): NotificationOptions {\n  const native: NotificationOptions = {};\n  if (options.body !== undefined) native.body = options.body;\n  if (options.icon !== undefined) native.icon = options.icon;\n  if (options.tag !== undefined) native.tag = options.tag;\n  if (options.data !== undefined) native.data = options.data;\n  if (options.silent !== undefined) native.silent = options.silent;\n  if (options.requireInteraction !== undefined) native.requireInteraction = options.requireInteraction;\n  return native;\n}\n\n/** Brings the app's window forward on a notification click. A refused focus is not an error worth raising. */\nfunction focusWindow(): void {\n  try {\n    if (typeof window === 'undefined' || typeof window.focus !== 'function') return;\n    window.focus();\n  } catch {\n    // Focus is a courtesy: a browser may refuse it without transient activation, or across origins. A refusal\n    // must not turn a delivered click into an exception.\n  }\n}\n\n/** Attaches a listener, tolerating a stand-in without a usable `EventTarget` surface. */\nfunction addListener(target: Notification, type: 'click' | 'close', listener: (event: Event) => void): void {\n  try {\n    target.addEventListener(type, listener);\n  } catch {\n    // A partial implementation or test double simply gets no wiring — never a throw out of `notify`.\n  }\n}\n\n/**\n * Wires the click convenience and the auto-close timer onto a freshly constructed notification.\n *\n * Guarded end-to-end, and deliberately not part of the caller's `try`: the notification is already on screen by\n * the time this runs, so a hostile `options` getter must not downgrade a `shown` result to `failed` and throw\n * away the handle. Listeners are added rather than assigned to `onclick` / `onclose`, so a consumer's own\n * handler on the returned notification survives.\n */\nfunction wireLifecycle(notification: Notification, options: NotifyOptions): void {\n  try {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    const cancelAutoClose = (): void => {\n      if (timer === undefined) return;\n      clearTimeout(timer);\n      timer = undefined;\n    };\n\n    addListener(notification, 'close', cancelAutoClose);\n\n    addListener(notification, 'click', (event) => {\n      cancelAutoClose();\n      focusWindow();\n      const { onClick } = options;\n      if (onClick === undefined) return;\n      try {\n        onClick(event);\n      } catch {\n        // The consumer's own handler failed. There is nothing useful left to do with that — and an\n        // `EventTarget` would otherwise surface it as an uncaught error at the dispatch site.\n      }\n    });\n\n    const { autoCloseMs } = options;\n    if (typeof autoCloseMs !== 'number' || !Number.isFinite(autoCloseMs) || autoCloseMs < 0) return;\n\n    timer = setTimeout(() => {\n      timer = undefined;\n      try {\n        notification.close();\n      } catch {\n        // Closing an already-gone notification is a no-op everywhere real; a stand-in may disagree.\n      }\n    }, autoCloseMs);\n  } catch {\n    // A throwing member on the caller's `options` object. The notification stays shown and unwired.\n  }\n}\n\n/**\n * Shows an OS-level notification and returns a {@link NotificationShowResult}. Never throws.\n *\n * Requires a granted permission — this call never prompts. Pair it with `getNotificationPermission` /\n * `requestNotificationPermission` (or the `useNotificationPermission` hook) and treat `denied` as \"ask first\",\n * not \"retry\".\n *\n * @param title The notification's headline. Some platforms truncate it aggressively.\n * @param options Body, icon, tag, and the {@link NotifyOptions.autoCloseMs} / {@link NotifyOptions.onClick}\n *   conveniences this module adds on top of the platform dictionary.\n */\nexport function notify(title: string, options?: NotifyOptions): NotificationShowResult {\n  const permission = getNotificationPermission();\n  if (permission === 'unsupported') return { ok: false, failure: { status: 'unsupported' } };\n  if (permission !== 'granted') return { ok: false, failure: { status: 'denied' } };\n\n  const settings = options ?? {};\n\n  let notification: Notification;\n  try {\n    notification = new Notification(title, toNativeNotificationOptions(settings));\n  } catch (error) {\n    // Construction is where the platform vetoes: a payload it rejects, a browser that only allows notifications\n    // from a service worker (mobile Chrome), a document that lost its permission mid-session.\n    return { ok: false, failure: { status: 'failed', error: toError(error) } };\n  }\n\n  wireLifecycle(notification, settings);\n  return { ok: true, value: notification };\n}\n","import { onMounted, onScopeDispose, shallowRef, toValue, watch, type MaybeRefOrGetter, type ShallowRef } from 'vue';\n\nimport { subscribeToPermissionChange, type PermissionQueryName, type PermissionQueryState } from '../QueryPermission';\n\n/**\n * Follows a permission's state reactively, updating when the user grants or revokes it — including from\n * the browser's own site settings or another tab.\n *\n * Holds `null` while the first query is in flight (and during SSR), then a {@link PermissionQueryState}.\n * Changing `name` resets to `null` and re-queries. Never throws.\n *\n * @param name The permission to follow — `'notifications'`, `'geolocation'`, `'camera'`, … A ref or getter\n *   re-queries when it changes.\n * @returns The current state, or `null` before the first answer.\n */\nexport function usePermissionState(\n  name: MaybeRefOrGetter<PermissionQueryName>,\n): Readonly<ShallowRef<PermissionQueryState | null>> {\n  const state = shallowRef<PermissionQueryState | null>(null);\n\n  let unsubscribe: (() => void) | undefined;\n\n  function stop(): void {\n    unsubscribe?.();\n    unsubscribe = undefined;\n  }\n\n  function start(): void {\n    stop();\n    // A new `name` invalidates the previous answer immediately — showing the old permission's state under the\n    // new name's label would be simply wrong, where `null` is merely uninformative.\n    state.value = null;\n    unsubscribe = subscribeToPermissionChange(toValue(name), (next) => {\n      state.value = next;\n    });\n  }\n\n  onMounted(start);\n  // Non-immediate on purpose: an immediate watcher runs on the server, where `navigator` is absent.\n  watch(() => toValue(name), start);\n  onScopeDispose(stop);\n\n  return state;\n}\n","import { computed, onMounted, onScopeDispose, shallowRef, type ComputedRef, type ShallowRef } from 'vue';\n\nimport {\n  getNotificationPermission,\n  requestNotificationPermission,\n  type NotificationPermissionState,\n} from '../NotificationPermission';\nimport { subscribeToPermissionChange } from '../QueryPermission';\n\n/** What {@link useNotificationPermission} returns. */\nexport interface NotificationPermissionControls {\n  /** The current grant. `unsupported` during SSR and until mount, then the real value. */\n  readonly permission: Readonly<ShallowRef<NotificationPermissionState>>;\n\n  /** Convenience for `permission === 'granted'` — the gate a `notify` call sits behind. */\n  readonly granted: ComputedRef<boolean>;\n\n  /** Whether the Notification API exists at all: `false` only for `unsupported`. Hide the feature when false. */\n  readonly supported: ComputedRef<boolean>;\n\n  /** Whether a prompt is worth offering — `permission === 'default'`. False once the user has decided either way. */\n  readonly requestable: ComputedRef<boolean>;\n\n  /** Whether a {@link NotificationPermissionControls.request} call is in flight — the button's disabled flag. */\n  readonly requesting: Readonly<ShallowRef<boolean>>;\n\n  /**\n   * Prompts for the grant and resolves to the resulting state, which is also written to\n   * {@link NotificationPermissionControls.permission}. Never throws, never rejects.\n   */\n  readonly request: () => Promise<NotificationPermissionState>;\n}\n\n/**\n * Exposes the notification grant as reactive state, with a `request()` that prompts for it.\n *\n * Updates when the grant changes — on request, and (where the Permissions API is available) on an external\n * grant or revoke. Inherits the module's never-throws contract: `request` resolves to a state, never rejects.\n */\nexport function useNotificationPermission(): NotificationPermissionControls {\n  const permission = shallowRef<NotificationPermissionState>('unsupported');\n  const requesting = shallowRef(false);\n\n  let active = false;\n  let unsubscribe: (() => void) | undefined;\n\n  const sync = (): void => {\n    if (active) permission.value = getNotificationPermission();\n  };\n\n  onMounted(() => {\n    active = true;\n    sync();\n    // The delivered state is ignored on purpose — see the header: this subscription is a change signal, and\n    // `Notification.permission` is the value. Its immediate first emission is simply a redundant `sync`.\n    unsubscribe = subscribeToPermissionChange('notifications', sync);\n  });\n\n  onScopeDispose(() => {\n    active = false;\n    unsubscribe?.();\n    unsubscribe = undefined;\n  });\n\n  let pending: Promise<NotificationPermissionState> | undefined;\n  const request = (): Promise<NotificationPermissionState> => {\n    if (pending !== undefined) return pending;\n    if (!active) return Promise.resolve(permission.value);\n    requesting.value = true;\n    pending = requestNotificationPermission()\n      .then((outcome) => {\n        if (active) permission.value = outcome;\n        return outcome;\n      })\n      .finally(() => {\n        pending = undefined;\n        if (active) requesting.value = false;\n      });\n    return pending;\n  };\n\n  return {\n    permission,\n    granted: computed(() => permission.value === 'granted'),\n    supported: computed(() => permission.value !== 'unsupported'),\n    requestable: computed(() => permission.value === 'default'),\n    requesting,\n    request,\n  };\n}\n","/** Closed failure vocabulary for NotificationFailure. */\nexport const NotificationFailureCode = {\n  Denied: 'denied',\n  Unsupported: 'unsupported',\n  Failed: 'failed',\n} as const;\n\nexport type NotificationFailureCode = (typeof NotificationFailureCode)[keyof typeof NotificationFailureCode];\n"],"names":[],"mappings":"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"}

package/dist/foundation/notifications/models/NotificationFailure.d.ts

@@ -0,0 +1,10 @@
+import { NotificationFailureCode } from '../NotificationFailureCode';
+/** Expected reasons the operation could not produce its requested value. */
+export type NotificationFailure = {
+    readonly status: typeof NotificationFailureCode.Denied;
+} | {
+    readonly status: typeof NotificationFailureCode.Unsupported;
+} | {
+    readonly status: typeof NotificationFailureCode.Failed;
+    readonly error: Error;
+};

package/dist/foundation/notifications/models/NotificationShowResult.d.ts

@@ -0,0 +1,4 @@
+import { Result } from '../../results';
+import { NotificationFailure } from './NotificationFailure';
+/** The completed operation, carrying either its value or its typed failure. */
+export type NotificationShowResult = Result<Notification, NotificationFailure>;

package/dist/foundation/numbers/ExactNumber.d.ts

@@ -0,0 +1,13 @@
+import { Result } from '../results';
+import { ExactNumber as ExactNumberValue } from './models/ExactNumber';
+import { NumberFailure } from './models/NumberFailure';
+export type ExactNumber = ExactNumberValue;
+declare function parse(text: string): Result<ExactNumberValue, NumberFailure>;
+/** Creates immutable exact decimal values without native-number conversion. */
+export declare const ExactNumber: Readonly<{
+    parse: typeof parse;
+    isExactNumber(value: unknown): value is ExactNumberValue;
+    fromBigInt(value: bigint): Result<ExactNumberValue, NumberFailure>;
+    fromSafeInteger(value: number): Result<ExactNumberValue, NumberFailure>;
+}>;
+export {};

package/dist/foundation/numbers/NumberLimits.d.ts

@@ -0,0 +1,7 @@
+/** Resource budgets, not a backend scalar range or a limit on exponent magnitude during parsing. */
+export declare const NumberLimits: Readonly<{
+    /** Excludes the optional leading minus so negation never invalidates a parsed value. */
+    maxTokenCharacters: 16384;
+    maxArithmeticPlaces: 32768;
+    maxDecimalPlaces: 4096;
+}>;

package/dist/foundation/numbers/adapters/bignumber/DecimalArithmetic.d.ts

@@ -0,0 +1,4 @@
+import { NumberRoundingOptions } from '../../models/NumberRoundingOptions';
+/** Private adapter; accepts and returns decimal text, never a vendor instance. */
+export declare function calculateDecimal(operation: 'add' | 'subtract' | 'multiply' | 'divide' | 'round' | 'modulo', left: string, right: string, options?: NumberRoundingOptions): string;
+export declare function decimalIntegerText(value: string): string;

package/dist/foundation/numbers/enums/NumberFailureCode.d.ts

@@ -0,0 +1,10 @@
+/** Actionable failures of exact decimal operations. */
+export declare const NumberFailureCode: {
+    readonly InvalidSyntax: "InvalidSyntax";
+    readonly ResourceLimit: "ResourceLimit";
+    readonly DivisionByZero: "DivisionByZero";
+    readonly InvalidRounding: "InvalidRounding";
+    readonly NonInteger: "NonInteger";
+    readonly UnsafeConversion: "UnsafeConversion";
+};
+export type NumberFailureCode = (typeof NumberFailureCode)[keyof typeof NumberFailureCode];

package/dist/foundation/numbers/enums/NumberRounding.d.ts

@@ -0,0 +1,13 @@
+/** Explicit rounding direction; Half modes resolve an exact tie as named. */
+export declare const NumberRounding: {
+    readonly AwayFromZero: "AwayFromZero";
+    readonly TowardZero: "TowardZero";
+    readonly Ceiling: "Ceiling";
+    readonly Floor: "Floor";
+    readonly HalfAwayFromZero: "HalfAwayFromZero";
+    readonly HalfTowardZero: "HalfTowardZero";
+    readonly HalfEven: "HalfEven";
+    readonly HalfCeiling: "HalfCeiling";
+    readonly HalfFloor: "HalfFloor";
+};
+export type NumberRounding = (typeof NumberRounding)[keyof typeof NumberRounding];

package/dist/foundation/numbers/index.d.ts

@@ -0,0 +1,6 @@
+export { ExactNumber } from './ExactNumber';
+export { NumberLimits } from './NumberLimits';
+export { NumberFailureCode } from './enums/NumberFailureCode';
+export { NumberRounding } from './enums/NumberRounding';
+export type { NumberFailure } from './models/NumberFailure';
+export type { NumberRoundingOptions } from './models/NumberRoundingOptions';

package/dist/foundation/numbers/index.js

@@ -0,0 +1,8 @@
+import { E, N, a, b } from "../../chunks/ExactNumber-CboRl3_0.js";
+export {
+  E as ExactNumber,
+  N as NumberFailureCode,
+  a as NumberLimits,
+  b as NumberRounding
+};
+//# sourceMappingURL=index.js.map

package/dist/foundation/numbers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/foundation/numbers/models/ExactNumber.d.ts

@@ -0,0 +1,47 @@
+import { Result } from '../../results';
+import { NumberFailure } from './NumberFailure';
+import { NumberRoundingOptions } from './NumberRoundingOptions';
+declare const ExactNumberBrand: unique symbol;
+/** Immutable finite decimal value; use the ExactNumber factory to create one. */
+export interface ExactNumber {
+    readonly [ExactNumberBrand]: true;
+    /** Adds without rounding; fails if the work/output resource budget is exceeded. */
+    add(other: ExactNumber): Result<ExactNumber, NumberFailure>;
+    /** Subtracts without rounding, including cancellation of large values. */
+    subtract(other: ExactNumber): Result<ExactNumber, NumberFailure>;
+    /** Multiplies without rounding within the documented work budget. */
+    multiply(other: ExactNumber): Result<ExactNumber, NumberFailure>;
+    /** Divides using the caller-specified decimal places and rounding mode. */
+    divide(other: ExactNumber, options: NumberRoundingOptions): Result<ExactNumber, NumberFailure>;
+    /** Rounds to the caller-specified decimal places and rounding mode. */
+    round(options: NumberRoundingOptions): Result<ExactNumber, NumberFailure>;
+    /** Truncating remainder: result has the dividend's sign, matching JS %. */
+    modulo(other: ExactNumber): Result<ExactNumber, NumberFailure>;
+    /** Compares any accepted tokens using bounded lexical work without expanding exponents. */
+    compare(other: ExactNumber): Result<-1 | 0 | 1, NumberFailure>;
+    /** Compares numeric value, independent of identity, spelling and zero sign. */
+    equals(other: ExactNumber): Result<boolean, NumberFailure>;
+    /** Toggles the leading sign, including signed zero, preserving magnitude spelling. */
+    negate(): ExactNumber;
+    /** Removes a negative sign without changing magnitude spelling. */
+    absolute(): ExactNumber;
+    /** Tests numeric zero regardless of scale or exponent spelling. */
+    isZero(): boolean;
+    /** Tests whether the exact value has no fractional part without native conversion. */
+    isInteger(): boolean;
+    /** Tests whether a zero token retains a leading minus. */
+    isNegativeZero(): boolean;
+    /** Converts an integral value exactly; fractional values and resource excess fail. */
+    toBigInt(): Result<bigint, NumberFailure>;
+    /** Converts exactly inside the native safe-integer range; retains negative zero. */
+    toSafeInteger(): Result<number, NumberFailure>;
+    /** Explicit approximation; rejects overflow and nonzero underflow. */
+    toApproximateNumber(): Result<number, NumberFailure>;
+    /** Returns the original JSON numeric token; arithmetic produces canonical tokens. */
+    toString(): string;
+    /** Native JSON.stringify is deliberately rejected. Use LosslessJson. */
+    toJSON(): never;
+    /** Allows string interpolation; numeric/default coercion throws TypeError. */
+    [Symbol.toPrimitive](hint: string): string;
+}
+export {};

package/dist/foundation/numbers/models/NumberFailure.d.ts

@@ -0,0 +1,6 @@
+import { NumberFailureCode } from '../enums/NumberFailureCode';
+/** Safe, transport-independent failure of a decimal operation. */
+export interface NumberFailure {
+    readonly code: NumberFailureCode;
+    readonly message: string;
+}

package/dist/foundation/numbers/models/NumberRoundingOptions.d.ts

@@ -0,0 +1,6 @@
+import { NumberRounding } from '../enums/NumberRounding';
+/** Precision is decimal places after the decimal point, never significant digits. */
+export interface NumberRoundingOptions {
+    readonly decimalPlaces: number;
+    readonly rounding: NumberRounding;
+}

package/dist/foundation/oauth/GoogleIdentity.d.ts

@@ -0,0 +1,98 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+/** Defines the load state of the Google Identity Services client. */
+export declare const GoogleIdentityStatus: {
+    /** No client id configured — nothing was loaded, and the caller renders nothing. */
+    readonly Unresolved: "unresolved";
+    /** The GIS script is in flight. */
+    readonly Loading: "loading";
+    /** The GIS client is initialized and can render a button or raise a prompt. */
+    readonly Ready: "ready";
+    /** The script failed to load, or `initialize` threw. */
+    readonly Failed: "failed";
+};
+/** Defines the load state of the Google Identity Services client. */
+export type GoogleIdentityStatus = (typeof GoogleIdentityStatus)[keyof typeof GoogleIdentityStatus];
+/** Defines the credential GIS hands back after a successful sign-in. */
+export interface GoogleCredentialResponse {
+    /** The signed JWT ID token to send to the backend for verification. Absent on a dismissed prompt. */
+    readonly credential?: string;
+    /** How the credential was selected (`btn`, `auto`, …) — GIS's own vocabulary, passed through unmapped. */
+    readonly select_by?: string;
+}
+/** Defines the appearance options GIS accepts when rendering its own sign-in button. */
+export interface GoogleButtonOptions {
+    /** The button surface — `outline` · `filled_blue` · `filled_black`. Default `outline`. */
+    readonly theme?: 'outline' | 'filled_blue' | 'filled_black';
+    /** The button height band — `large` · `medium` · `small`. Default `large`. */
+    readonly size?: 'large' | 'medium' | 'small';
+    /** The label wording — `signin_with` · `signup_with` · `continue_with` · `signin`. */
+    readonly text?: 'signin_with' | 'signup_with' | 'continue_with' | 'signin';
+    /** The button outline — `rectangular` · `pill` · `circle` · `square`. */
+    readonly shape?: 'rectangular' | 'pill' | 'circle' | 'square';
+    /** The rendered width in px. GIS caps this at 400. */
+    readonly width?: number;
+    /** The logo placement — `left` · `center`. */
+    readonly logo_alignment?: 'left' | 'center';
+    /** The BCP-47 locale for the button copy. Defaults to the browser's. */
+    readonly locale?: string;
+}
+/** Defines the subset of `window.google.accounts.id` this module drives. */
+interface GoogleAccountsId {
+    initialize(config: Record<string, unknown>): void;
+    renderButton(target: HTMLElement, options: GoogleButtonOptions): void;
+    prompt(): void;
+    disableAutoSelect(): void;
+}
+declare global {
+    var google: {
+        accounts?: {
+            id?: GoogleAccountsId;
+        };
+    } | undefined;
+}
+/**
+ * Loads the Google Identity Services client, returning the shared `accounts.id` namespace.
+ *
+ * Resolves immediately when the script is already present. Rejects (and clears the cache) when the
+ * script fails to load, so the next caller retries. Throws under SSR — call it from `onMounted`.
+ */
+export declare function loadGoogleIdentity(): Promise<GoogleAccountsId>;
+/** Defines the options {@link useGoogleIdentity} takes. */
+export interface UseGoogleIdentityOptions {
+    /** OAuth client id. Empty / undefined keeps the status `unresolved` and loads nothing — app stays guest-only. */
+    readonly clientId: MaybeRefOrGetter<string | undefined>;
+    /** Receives the ID token on a successful sign-in. */
+    readonly onCredential: (credential: string, response: GoogleCredentialResponse) => void;
+    /** Receives a load / initialize failure. The status is `failed` by the time this fires. */
+    readonly onError?: (error: Error) => void;
+    /** Whether GIS may sign a returning user in without a click. Default `false`. */
+    readonly autoSelect?: MaybeRefOrGetter<boolean | undefined>;
+    /** Whether a click outside the One Tap prompt dismisses it. Default `true`. */
+    readonly cancelOnTapOutside?: MaybeRefOrGetter<boolean | undefined>;
+}
+/** Defines the handle {@link useGoogleIdentity} returns. */
+export interface GoogleIdentityApi {
+    /** The current load state. */
+    readonly status: Readonly<Ref<GoogleIdentityStatus>>;
+    /** The load / initialize failure, or `null`. */
+    readonly error: Readonly<Ref<Error | null>>;
+    /** Renders the Google-owned sign-in button into the host element. No-op until the status is `ready`. */
+    readonly renderButton: (target: HTMLElement, options?: GoogleButtonOptions) => void;
+    /** Raises the One Tap prompt. No-op until the status is `ready`. */
+    readonly prompt: () => void;
+    /** Clears the auto-select grant — call on sign-out so the next visit asks again. */
+    readonly disableAutoSelect: () => void;
+}
+/**
+ * Manages the Google Identity Services client for one component — script load, `initialize`, and the
+ * credential callback.
+ *
+ * Headless by design: this module renders nothing, and never talks to the backend. The ID token is
+ * handed to `onCredential`, and posting it (to `/api/auth/google` or wherever the product's identity
+ * endpoint lives) stays app-side, the same boundary the rest of `auth` keeps.
+ *
+ * The client id is a `MaybeRefOrGetter` — pass a getter (`() => props.clientId`) to keep it reactive;
+ * a change re-initializes against the new id.
+ */
+export declare function useGoogleIdentity(options: UseGoogleIdentityOptions): GoogleIdentityApi;
+export {};

package/dist/foundation/oauth/index.d.ts

@@ -0,0 +1 @@
+export { GoogleIdentityStatus, loadGoogleIdentity, useGoogleIdentity, type GoogleButtonOptions, type GoogleCredentialResponse, type GoogleIdentityApi, type UseGoogleIdentityOptions, } from './GoogleIdentity';

package/dist/foundation/oauth/index.js

@@ -0,0 +1,7 @@
+import { G, l, u } from "../../chunks/GoogleIdentity-D12Kr334.js";
+export {
+  G as GoogleIdentityStatus,
+  l as loadGoogleIdentity,
+  u as useGoogleIdentity
+};
+//# sourceMappingURL=index.js.map

package/dist/foundation/oauth/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/foundation/observers/ObserveIntersection.d.ts

@@ -14,7 +14,7 @@ export interface IntersectionOptions {
      * Visible fraction(s), each `0`–`1`, at which the callback fires. A single number fires on crossing it in
      * either direction; an array fires at every listed step. Defaults to `0` (any pixel).
      */
-    readonly threshold?: number | readonly number[];
+    readonly threshold?: number | ReadonlyArray<number>;
 }
 /** A disposer that is safe to call more than once. */
 export type Disposer = () => void;

package/dist/foundation/observers/ObserveMutation.d.ts

@@ -12,7 +12,7 @@ export interface MutationOptions {
      * Restrict attribute watching to these names, e.g. `['data-state', 'aria-expanded']`. Narrowing this is the
      * cheapest win available: an unfiltered `attributes: true` on a busy node reports every class toggle.
      */
-    readonly attributeFilter?: readonly string[];
+    readonly attributeFilter?: ReadonlyArray<string>;
     /** Include the previous value on each attribute record. */
     readonly attributeOldValue?: boolean;
     /** Include the previous value on each character-data record. */
@@ -49,4 +49,4 @@ export declare function mutationSignature(options?: MutationOptions): string;
  * @param options Which mutation kinds to report; defaults to `{ childList: true }`.
  * @returns An idempotent disposer. A no-op when `MutationObserver` is unavailable.
  */
-export declare function observeMutation(node: Node, callback: (records: readonly MutationRecord[], observer: MutationObserver) => void, options?: MutationOptions): Disposer;
+export declare function observeMutation(node: Node, callback: (records: ReadonlyArray<MutationRecord>, observer: MutationObserver) => void, options?: MutationOptions): Disposer;

package/dist/foundation/observers/VisibilitySteps.d.ts

@@ -11,4 +11,4 @@
  * @param steps How many intervals to divide `0`–`1` into. `steps: 4` ⇒ `[0, 0.25, 0.5, 0.75, 1]`.
  * @returns A frozen ascending ladder of `steps + 1` thresholds, first `0` and last `1`.
  */
-export declare function visibilityThresholds(steps: number): readonly number[];
+export declare function visibilityThresholds(steps: number): ReadonlyArray<number>;