@wow-two-beta/ui-vue 0.0.2

package/dist/chunks/useRecentItems-DFnt5CBy.js

@@ -0,0 +1,137 @@
+import { onScopeDispose, watch, toValue, shallowRef, computed, onMounted } from "vue";
+import { l as localStorageStorageBroker } from "./StorageBroker-COC81ZGB.js";
+function isPrintableKey(event) {
+  if (event.ctrlKey || event.metaKey || event.altKey) return false;
+  return event.key.length === 1;
+}
+function isAllSameChar(buffer) {
+  return buffer.length > 0 && [...buffer].every((c) => c === buffer[0]);
+}
+function useTypeahead(options) {
+  let buffer = "";
+  let timer = null;
+  const isEnabled = () => toValue(options.enabled ?? true);
+  function clearTimer() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function reset() {
+    buffer = "";
+    clearTimer();
+  }
+  onScopeDispose(clearTimer);
+  function onKeyDown(event) {
+    if (!isEnabled()) return false;
+    if (!isPrintableKey(event)) return false;
+    const isSpace = event.key === " ";
+    const hasBuffer = buffer.length > 0;
+    if (isSpace && !hasBuffer) return false;
+    const list = toValue(options.items);
+    if (list.length === 0) return false;
+    const nextBuffer = buffer + event.key;
+    buffer = nextBuffer;
+    clearTimer();
+    timer = setTimeout(() => {
+      buffer = "";
+      timer = null;
+    }, toValue(options.timeout ?? 500));
+    const labelOf = (item) => options.getLabel(item).toLowerCase();
+    const disabledOf = (item) => options.isDisabled ? options.isDisabled(item) : false;
+    const startFrom = options.getActiveIndex ? options.getActiveIndex() : -1;
+    let matchIndex = -1;
+    if (isAllSameChar(nextBuffer)) {
+      const char = nextBuffer[0].toLowerCase();
+      for (let step = 1; step <= list.length; step += 1) {
+        const idx = (startFrom + step + list.length) % list.length;
+        const item = list[idx];
+        if (!disabledOf(item) && labelOf(item).startsWith(char)) {
+          matchIndex = idx;
+          break;
+        }
+      }
+    } else {
+      const prefix = nextBuffer.toLowerCase();
+      const begin = startFrom < 0 ? 0 : startFrom;
+      for (let step = 0; step < list.length; step += 1) {
+        const idx = (begin + step) % list.length;
+        const item = list[idx];
+        if (!disabledOf(item) && labelOf(item).startsWith(prefix)) {
+          matchIndex = idx;
+          break;
+        }
+      }
+    }
+    if (matchIndex >= 0) {
+      options.onMatch(list[matchIndex], matchIndex);
+      return true;
+    }
+    return true;
+  }
+  watch(isEnabled, (nowEnabled) => {
+    if (!nowEnabled) reset();
+  });
+  return { onKeyDown, reset };
+}
+function canSyncAcrossTabs(broker) {
+  return broker === localStorageStorageBroker && typeof window !== "undefined";
+}
+function usePersistentState(key, initial, options) {
+  const broker = options?.broker ?? localStorageStorageBroker;
+  const state = shallowRef(initial);
+  const setValue = (next) => {
+    const resolved = typeof next === "function" ? next(state.value) : next;
+    broker.write(toValue(key), resolved);
+    state.value = resolved;
+  };
+  const value = computed({
+    get: () => state.value,
+    set: setValue
+  });
+  function hydrate() {
+    const persisted = broker.read(toValue(key));
+    if (persisted !== null) state.value = persisted;
+  }
+  onMounted(hydrate);
+  watch(() => toValue(key), hydrate);
+  let detachStorage = null;
+  onMounted(() => {
+    if (!canSyncAcrossTabs(broker)) return;
+    function onStorage(event) {
+      const currentKey = toValue(key);
+      if (event.key !== currentKey) return;
+      state.value = event.newValue === null ? initial : broker.read(currentKey) ?? initial;
+    }
+    window.addEventListener("storage", onStorage);
+    detachStorage = () => window.removeEventListener("storage", onStorage);
+  });
+  onScopeDispose(() => {
+    detachStorage?.();
+    detachStorage = null;
+  });
+  return { value, setValue };
+}
+const DefaultMax = 24;
+function prependRecent(items, item, identify, max) {
+  const id = identify(item);
+  const withoutDuplicate = items.filter((existing) => identify(existing) !== id);
+  return [item, ...withoutDuplicate].slice(0, Math.max(0, max));
+}
+function useRecentItems(key, options) {
+  const { identify, max = DefaultMax, broker } = options;
+  const state = usePersistentState(key, [], { broker });
+  const recents = computed(() => state.value.value);
+  const push = (item) => {
+    state.setValue((previous) => prependRecent(previous, item, identify, toValue(max)));
+  };
+  const clear = () => state.setValue([]);
+  return { recents, push, clear };
+}
+export {
+  useRecentItems as a,
+  useTypeahead as b,
+  prependRecent as p,
+  usePersistentState as u
+};
+//# sourceMappingURL=useRecentItems-DFnt5CBy.js.map

package/dist/chunks/useRecentItems-DFnt5CBy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRecentItems-DFnt5CBy.js","sources":["../../src/foundation/hooks/useTypeahead/useTypeahead.ts","../../src/foundation/hooks/usePersistentState/usePersistentState.ts","../../src/foundation/hooks/useRecentItems/useRecentItems.ts"],"sourcesContent":["import { onScopeDispose, toValue, watch, type MaybeRefOrGetter } from 'vue';\n\n/** Resolves the typeahead item pool — a static array, a ref, or a getter read lazily on each keystroke. */\ntype ItemSource<T> = MaybeRefOrGetter<readonly T[]>;\n\n/** Configures {@link useTypeahead}. `T` is the item type the caller stores per option. */\nexport interface UseTypeaheadOptions<T> {\n  /** Supplies the items to match against; a ref or function is re-read on every keystroke (live lists). */\n  items: ItemSource<T>;\n\n  /** Extracts the comparable label from an item. Matching is case-insensitive on this string. */\n  getLabel: (item: T) => string;\n\n  /** Reports whether an item is disabled; disabled items are skipped during matching. */\n  isDisabled?: (item: T) => boolean;\n\n  /** Fires with the matched item and its index in the (live) item array when a keystroke resolves. */\n  onMatch: (item: T, index: number) => void;\n\n  /** Returns the index of the currently-active item — same-letter cycling starts after it. */\n  getActiveIndex?: () => number;\n\n  /** Disables the matcher when `false`; every key falls through unhandled. Defaults to `true`. */\n  enabled?: MaybeRefOrGetter<boolean>;\n\n  /** Idle time (ms) after which the typed buffer resets. Defaults to `500`. */\n  timeout?: MaybeRefOrGetter<number>;\n}\n\n/** The keyboard handler + manual reset returned by {@link useTypeahead}. */\nexport interface UseTypeaheadReturn {\n  /** Feeds a keydown into the matcher. Returns `true` when consumed (caller should stop), else `false`. */\n  onKeyDown: (event: KeyboardEvent) => boolean;\n\n  /** Clears the typed buffer immediately (e.g. on blur / close). */\n  reset: () => void;\n}\n\n/** Reports whether a key event carries a single printable character (and no command modifier). */\nfunction isPrintableKey(event: KeyboardEvent): boolean {\n  if (event.ctrlKey || event.metaKey || event.altKey) return false;\n  // Printable keys surface as a single char in `key`; named keys (Enter, ArrowDown…) are multi-char.\n  return event.key.length === 1;\n}\n\n/** Reports whether every char in the buffer is the same letter — the \"cycle\" case (e.g. \"aaa\"). */\nfunction isAllSameChar(buffer: string): boolean {\n  return buffer.length > 0 && [...buffer].every((c) => c === buffer[0]);\n}\n\n/**\n * APG-correct type-to-select matcher (WAI-ARIA listbox/combobox typeahead). Accumulates printable\n * chars into a buffer (resets after `timeout` ms idle): a repeated single char cycles to the next\n * label starting with it (after `getActiveIndex()`, wrap-around), else prefix-matches the whole\n * buffer case-insensitively; disabled items skipped. On a hit `onMatch(item, index)` fires; consumed\n * keys return `true`, others `false` to fall through. Space is typeable only while buffering (a\n * leading Space reaches the caller). SSR-safe; reset timer cleared when the scope is disposed.\n *\n * `items`, `enabled` and `timeout` may each be a ref or getter and are read per keystroke, so the\n * matcher tracks a live list without the original's options-in-a-ref indirection. The callbacks\n * (`getLabel`, `onMatch`, …) are read off the options object at call time — pass a `reactive`\n * options object if they must be swappable.\n */\nexport function useTypeahead<T>(options: UseTypeaheadOptions<T>): UseTypeaheadReturn {\n  let buffer = '';\n  let timer: ReturnType<typeof setTimeout> | null = null;\n\n  const isEnabled = (): boolean => toValue(options.enabled ?? true);\n\n  function clearTimer(): void {\n    if (timer !== null) {\n      clearTimeout(timer);\n      timer = null;\n    }\n  }\n\n  function reset(): void {\n    buffer = '';\n    clearTimer();\n  }\n\n  /* Clears the pending reset timer on teardown (no stale fire after the scope is gone). */\n  onScopeDispose(clearTimer);\n\n  function onKeyDown(event: KeyboardEvent): boolean {\n    if (!isEnabled()) return false;\n    if (!isPrintableKey(event)) return false;\n\n    const isSpace = event.key === ' ';\n    const hasBuffer = buffer.length > 0;\n    /* Reserve Space: with no active buffer, hand it back so the caller can select; while typing,\n       a Space is a real character (matches labels with spaces) and is consumed. */\n    if (isSpace && !hasBuffer) return false;\n\n    const list = toValue(options.items);\n    if (list.length === 0) return false;\n\n    const nextBuffer = buffer + event.key;\n    buffer = nextBuffer;\n\n    /* Restart the idle window on every accepted keystroke. */\n    clearTimer();\n    timer = setTimeout(() => {\n      buffer = '';\n      timer = null;\n    }, toValue(options.timeout ?? 500));\n\n    const labelOf = (item: T): string => options.getLabel(item).toLowerCase();\n    const disabledOf = (item: T): boolean => (options.isDisabled ? options.isDisabled(item) : false);\n    const startFrom = options.getActiveIndex ? options.getActiveIndex() : -1;\n\n    let matchIndex = -1;\n    if (isAllSameChar(nextBuffer)) {\n      /* Same-letter repeat → cycle to the next label starting with that letter, after the active one. */\n      const char = nextBuffer[0]!.toLowerCase();\n      for (let step = 1; step <= list.length; step += 1) {\n        const idx = (startFrom + step + list.length) % list.length;\n        const item = list[idx]!;\n        if (!disabledOf(item) && labelOf(item).startsWith(char)) {\n          matchIndex = idx;\n          break;\n        }\n      }\n    } else {\n      /* Multi-char buffer → prefix-match the whole buffer; scan from the current item forward so a\n         refining sequence stays put when the active item still matches. */\n      const prefix = nextBuffer.toLowerCase();\n      const begin = startFrom < 0 ? 0 : startFrom;\n      for (let step = 0; step < list.length; step += 1) {\n        const idx = (begin + step) % list.length;\n        const item = list[idx]!;\n        if (!disabledOf(item) && labelOf(item).startsWith(prefix)) {\n          matchIndex = idx;\n          break;\n        }\n      }\n    }\n\n    if (matchIndex >= 0) {\n      options.onMatch(list[matchIndex]!, matchIndex);\n      return true;\n    }\n    /* No label matched, but the char was consumed into the buffer (and Space, once buffering,\n       must not double as select) — report handled so the caller doesn't also act on it. */\n    return true;\n  }\n\n  /* `enabled` toggling off mid-type should not leave a stale buffer/timer armed. */\n  watch(isEnabled, (nowEnabled) => {\n    if (!nowEnabled) reset();\n  });\n\n  return { onKeyDown, reset };\n}\n","import {\n  computed,\n  onMounted,\n  onScopeDispose,\n  shallowRef,\n  toValue,\n  watch,\n  type MaybeRefOrGetter,\n  type ShallowRef,\n  type WritableComputedRef,\n} from 'vue';\n\nimport { localStorageStorageBroker, type StorageBroker } from '../../storage';\n\n/** Defines the options that tune where and how `usePersistentState` persists. */\nexport interface PersistentStateOptions {\n  /** The persistence seam to read and write through; defaults to `localStorageStorageBroker`. */\n  readonly broker?: StorageBroker;\n}\n\n/** A setter that accepts a next value or an updater fn, mirroring the original's `useState` dispatch. */\nexport type SetPersistentState<T> = (next: T | ((previous: T) => T)) => void;\n\n/** The persistent-state handle — a writable value plus the updater-accepting setter it delegates to. */\nexport interface PersistentState<T> {\n  /**\n   * The live value. Writable: `value.value = next` runs the same write-through path as `setValue(next)`.\n   * A writable computed rather than a plain ref, so persistence is driven by the assignment itself —\n   * mutating a nested field in place does not persist, exactly as the original required a setter call.\n   */\n  readonly value: WritableComputedRef<T>;\n\n  /** Sets the next value — or derives it from the previous one — and writes it through the broker. */\n  readonly setValue: SetPersistentState<T>;\n}\n\n/** Resolves whether cross-tab sync is available — the `storage` event only fires for the shared `localStorage`, and only in a browser. */\nfunction canSyncAcrossTabs(broker: StorageBroker): boolean {\n  return broker === localStorageStorageBroker && typeof window !== 'undefined';\n}\n\n/**\n * Manages a piece of state mirrored into a `StorageBroker` under `key`. Hydrates from the broker on\n * mount (SSR-safe: the first render always uses `initial`, then a mount hook adopts any persisted value, so\n * server and client markup match), writes through on every set, and — when backed by `localStorage` —\n * adopts writes from other tabs via the window `storage` event.\n *\n * Returns `{ value, setValue }` rather than a tuple: `value` is writable (`state.value = next`), and\n * `setValue` is kept because it additionally accepts an updater fn. `key` may be a ref or getter — changing\n * it re-hydrates from the new slot.\n */\nexport function usePersistentState<T>(\n  key: MaybeRefOrGetter<string>,\n  initial: T,\n  options?: PersistentStateOptions,\n): PersistentState<T> {\n  const broker = options?.broker ?? localStorageStorageBroker;\n\n  // `initial` is the first-paint value on both server and client; a mount hook reconciles it with storage,\n  // so hydration never diverges. Cast: `shallowRef`'s return type is a conditional over an unresolved `T`.\n  const state = shallowRef(initial) as ShallowRef<T>;\n\n  const setValue: SetPersistentState<T> = (next) => {\n    const resolved =\n      typeof next === 'function' ? (next as (previous: T) => T)(state.value) : (next as T);\n    broker.write(toValue(key), resolved);\n    state.value = resolved;\n  };\n\n  const value = computed<T>({\n    get: () => state.value,\n    set: setValue,\n  });\n\n  /** Adopts the persisted value for the current key — a hit wins over what is held, a miss leaves it alone. */\n  function hydrate(): void {\n    const persisted = broker.read<T>(toValue(key));\n    if (persisted !== null) state.value = persisted;\n  }\n\n  onMounted(hydrate);\n  // A key swap re-reads from the new slot. Adoption assigns `state` directly, never through `setValue`, so\n  // reading a value never writes it back.\n  watch(() => toValue(key), hydrate);\n\n  // Adopt writes made under the same key in another tab. Guarded so a non-localStorage or SSR context attaches\n  // no listener. `event.newValue === null` means the key was removed elsewhere — fall back to `initial`.\n  let detachStorage: (() => void) | null = null;\n\n  onMounted(() => {\n    if (!canSyncAcrossTabs(broker)) return;\n\n    function onStorage(event: StorageEvent): void {\n      const currentKey = toValue(key);\n      if (event.key !== currentKey) return;\n      state.value = event.newValue === null ? initial : (broker.read<T>(currentKey) ?? initial);\n    }\n\n    window.addEventListener('storage', onStorage);\n    detachStorage = () => window.removeEventListener('storage', onStorage);\n  });\n\n  // Registered at setup level — `onScopeDispose` only binds to the component's effect scope while that scope\n  // is current, which it is not inside `onMounted`.\n  onScopeDispose(() => {\n    detachStorage?.();\n    detachStorage = null;\n  });\n\n  return { value, setValue };\n}\n","import { computed, toValue, type ComputedRef, type MaybeRefOrGetter } from 'vue';\n\nimport { type StorageBroker } from '../../storage';\nimport { usePersistentState } from '../usePersistentState';\n\n/** The default cap on retained recents, applied when `max` is omitted. */\nconst DefaultMax = 24;\n\n/** Defines the options that configure a recent-items list — identity, cap, and the persistence seam. */\nexport interface RecentItemsOptions<T> {\n  /** Derives a stable de-duplication key for an item; re-pushing a matching item moves it to the front. */\n  readonly identify: (item: T) => string;\n\n  /** The maximum number of items retained, most-recent-first; defaults to 24. */\n  readonly max?: MaybeRefOrGetter<number>;\n\n  /** The persistence seam to store the list through; defaults to `localStorageStorageBroker` via `usePersistentState`. */\n  readonly broker?: StorageBroker;\n}\n\n/** Represents a most-recently-used list plus the operations that mutate it. */\nexport interface RecentItems<T> {\n  /** The retained items, most-recent-first. */\n  readonly recents: ComputedRef<ReadonlyArray<T>>;\n\n  /** Records `item` as the most recent — de-duplicated by identity and capped at `max`. */\n  readonly push: (item: T) => void;\n\n  /** Empties the list. */\n  readonly clear: () => void;\n}\n\n/**\n * Prepends `item` to `items` as the most recent, de-duplicating by `identify` (an existing match is removed so\n * the item resurfaces at the front) and capping the result to `max`. Pure — the reducer the composable writes\n * through its adapter.\n */\nexport function prependRecent<T>(\n  items: ReadonlyArray<T>,\n  item: T,\n  identify: (item: T) => string,\n  max: number,\n): ReadonlyArray<T> {\n  const id = identify(item);\n  const withoutDuplicate = items.filter((existing) => identify(existing) !== id);\n  return [item, ...withoutDuplicate].slice(0, Math.max(0, max));\n}\n\n/**\n * Manages a persisted most-recently-used list under `key`, layered on `usePersistentState`. `push` records an\n * item at the front, de-duplicated by `identify` and capped at `max` (default 24); `clear` empties it. The list\n * inherits the underlying composable's hydrate-on-mount, write-through, and cross-tab sync.\n *\n * `recents` is a read-only computed — mutate the list through `push` / `clear`, never in place.\n */\nexport function useRecentItems<T>(\n  key: MaybeRefOrGetter<string>,\n  options: RecentItemsOptions<T>,\n): RecentItems<T> {\n  const { identify, max = DefaultMax, broker } = options;\n\n  const state = usePersistentState<ReadonlyArray<T>>(key, [], { broker });\n\n  const recents = computed<ReadonlyArray<T>>(() => state.value.value);\n\n  const push = (item: T): void => {\n    state.setValue((previous) => prependRecent(previous, item, identify, toValue(max)));\n  };\n\n  const clear = (): void => state.setValue([]);\n\n  return { recents, push, clear };\n}\n"],"names":[],"mappings":"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"}

package/dist/chunks/useReducedMotion-B9LqQ3UT.js

@@ -0,0 +1,8 @@
+import { u as useMediaQuery } from "./useMediaQuery-DwVcSgGk.js";
+function useReducedMotion() {
+  return useMediaQuery("(prefers-reduced-motion: reduce)");
+}
+export {
+  useReducedMotion as u
+};
+//# sourceMappingURL=useReducedMotion-B9LqQ3UT.js.map

package/dist/chunks/useReducedMotion-B9LqQ3UT.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReducedMotion-B9LqQ3UT.js","sources":["../../src/foundation/hooks/useReducedMotion/useReducedMotion.ts"],"sourcesContent":["import type { ShallowRef } from 'vue';\n\nimport { useMediaQuery } from '../useMediaQuery';\n\n/**\n * Returns a ref that is `true` when the user has requested reduced motion via\n * OS settings. Components should short-circuit looping/transitional animations\n * to a static final state when it is `true`.\n */\nexport function useReducedMotion(): Readonly<ShallowRef<boolean>> {\n  return useMediaQuery('(prefers-reduced-motion: reduce)');\n}\n"],"names":[],"mappings":";AASO,SAAS,mBAAkD;AAChE,SAAO,cAAc,kCAAkC;AACzD;"}

package/dist/chunks/useResizeObserver-BUU7lC-n.js

@@ -0,0 +1,17 @@
+import { watchPostEffect, toValue } from "vue";
+function useResizeObserver(target, callback, enabled = true) {
+  watchPostEffect((onCleanup) => {
+    const element = toValue(target);
+    if (!toValue(enabled) || !element || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (entry) callback(entry);
+    });
+    observer.observe(element);
+    onCleanup(() => observer.disconnect());
+  });
+}
+export {
+  useResizeObserver as u
+};
+//# sourceMappingURL=useResizeObserver-BUU7lC-n.js.map

package/dist/chunks/useResizeObserver-BUU7lC-n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResizeObserver-BUU7lC-n.js","sources":["../../src/foundation/hooks/useResizeObserver/useResizeObserver.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\n/**\n * Run `callback` whenever the referenced element's size changes. The effect is\n * post-flush, so the element is in the DOM (and laid out) before the observer\n * attaches. Disconnects automatically when the element changes, `enabled`\n * flips, or the scope is disposed.\n *\n * Takes the element as a ref or getter rather than handing one back, so the\n * caller keeps ownership of its `useTemplateRef`.\n */\nexport function useResizeObserver<T extends HTMLElement = HTMLElement>(\n  target: MaybeRefOrGetter<T | null | undefined>,\n  callback: (entry: ResizeObserverEntry) => void,\n  enabled: MaybeRefOrGetter<boolean> = true,\n): void {\n  watchPostEffect((onCleanup) => {\n    const element = toValue(target);\n    if (!toValue(enabled) || !element || typeof ResizeObserver === 'undefined') return;\n    const observer = new ResizeObserver((entries) => {\n      const entry = entries[0];\n      if (entry) callback(entry);\n    });\n    observer.observe(element);\n    onCleanup(() => observer.disconnect());\n  });\n}\n"],"names":[],"mappings":";AAWO,SAAS,kBACd,QACA,UACA,UAAqC,MAC/B;AACN,kBAAgB,CAAC,cAAc;AAC7B,UAAM,UAAU,QAAQ,MAAM;AAC9B,QAAI,CAAC,QAAQ,OAAO,KAAK,CAAC,WAAW,OAAO,mBAAmB,YAAa;AAC5E,UAAM,WAAW,IAAI,eAAe,CAAC,YAAY;AAC/C,YAAM,QAAQ,QAAQ,CAAC;AACvB,UAAI,gBAAgB,KAAK;AAAA,IAC3B,CAAC;AACD,aAAS,QAAQ,OAAO;AACxB,cAAU,MAAM,SAAS,YAAY;AAAA,EACvC,CAAC;AACH;"}

package/dist/chunks/useScrollLock-d6YIGUcs.js

@@ -0,0 +1,37 @@
+import { watchPostEffect, toValue } from "vue";
+let lockCount = 0;
+let originalOverflow = null;
+let originalPaddingRight = null;
+function getScrollbarWidth() {
+  return window.innerWidth - document.documentElement.clientWidth;
+}
+function useScrollLock(enabled = true) {
+  watchPostEffect((onCleanup) => {
+    if (!toValue(enabled) || typeof document === "undefined") return;
+    if (lockCount === 0) {
+      const body = document.body;
+      const scrollbarWidth = getScrollbarWidth();
+      originalOverflow = body.style.overflow;
+      originalPaddingRight = body.style.paddingRight;
+      body.style.overflow = "hidden";
+      if (scrollbarWidth > 0) {
+        body.style.paddingRight = `${scrollbarWidth}px`;
+      }
+    }
+    lockCount += 1;
+    onCleanup(() => {
+      lockCount -= 1;
+      if (lockCount === 0) {
+        const body = document.body;
+        body.style.overflow = originalOverflow ?? "";
+        body.style.paddingRight = originalPaddingRight ?? "";
+        originalOverflow = null;
+        originalPaddingRight = null;
+      }
+    });
+  });
+}
+export {
+  useScrollLock as u
+};
+//# sourceMappingURL=useScrollLock-d6YIGUcs.js.map

package/dist/chunks/useScrollLock-d6YIGUcs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScrollLock-d6YIGUcs.js","sources":["../../src/foundation/hooks/useScrollLock/useScrollLock.ts"],"sourcesContent":["import { toValue, watchPostEffect, type MaybeRefOrGetter } from 'vue';\n\nlet lockCount = 0;\nlet originalOverflow: string | null = null;\nlet originalPaddingRight: string | null = null;\n\nfunction getScrollbarWidth(): number {\n  return window.innerWidth - document.documentElement.clientWidth;\n}\n\n/**\n * Prevent body scroll while at least one consumer has the lock active.\n * Internally counted — multiple overlays may lock; only the last unlock restores.\n * Compensates for scrollbar width to avoid layout shift.\n *\n * `enabled` may be a ref or a getter (`() => props.isEnabled`), so the lock\n * follows a prop without the consumer re-invoking anything. The counter is\n * module-level and shared, exactly as in the original.\n */\nexport function useScrollLock(enabled: MaybeRefOrGetter<boolean> = true): void {\n  watchPostEffect((onCleanup) => {\n    if (!toValue(enabled) || typeof document === 'undefined') return;\n    if (lockCount === 0) {\n      const body = document.body;\n      const scrollbarWidth = getScrollbarWidth();\n      originalOverflow = body.style.overflow;\n      originalPaddingRight = body.style.paddingRight;\n      body.style.overflow = 'hidden';\n      if (scrollbarWidth > 0) {\n        body.style.paddingRight = `${scrollbarWidth}px`;\n      }\n    }\n    lockCount += 1;\n\n    onCleanup(() => {\n      lockCount -= 1;\n      if (lockCount === 0) {\n        const body = document.body;\n        body.style.overflow = originalOverflow ?? '';\n        body.style.paddingRight = originalPaddingRight ?? '';\n        originalOverflow = null;\n        originalPaddingRight = null;\n      }\n    });\n  });\n}\n"],"names":[],"mappings":";AAEA,IAAI,YAAY;AAChB,IAAI,mBAAkC;AACtC,IAAI,uBAAsC;AAE1C,SAAS,oBAA4B;AACnC,SAAO,OAAO,aAAa,SAAS,gBAAgB;AACtD;AAWO,SAAS,cAAc,UAAqC,MAAY;AAC7E,kBAAgB,CAAC,cAAc;AAC7B,QAAI,CAAC,QAAQ,OAAO,KAAK,OAAO,aAAa,YAAa;AAC1D,QAAI,cAAc,GAAG;AACnB,YAAM,OAAO,SAAS;AACtB,YAAM,iBAAiB,kBAAA;AACvB,yBAAmB,KAAK,MAAM;AAC9B,6BAAuB,KAAK,MAAM;AAClC,WAAK,MAAM,WAAW;AACtB,UAAI,iBAAiB,GAAG;AACtB,aAAK,MAAM,eAAe,GAAG,cAAc;AAAA,MAC7C;AAAA,IACF;AACA,iBAAa;AAEb,cAAU,MAAM;AACd,mBAAa;AACb,UAAI,cAAc,GAAG;AACnB,cAAM,OAAO,SAAS;AACtB,aAAK,MAAM,WAAW,oBAAoB;AAC1C,aAAK,MAAM,eAAe,wBAAwB;AAClD,2BAAmB;AACnB,+BAAuB;AAAA,MACzB;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;"}

package/dist/domain/color/Gradient.d.ts

@@ -0,0 +1,60 @@
+import { GradientType } from './GradientType';
+/** Defines one color stop of a foreground gradient (the start / end of a two-stop fill). */
+export interface GradientStop {
+    /** The stop color, `#RRGGBB`. */
+    color: string;
+    /** The stop's position along the gradient, `0..1`. */
+    offset: number;
+}
+/** Defines the shared gradient data — the color stops, independent of projection. */
+interface GradientBase {
+    /** The ordered color stops (two: start, end). */
+    stops: ReadonlyArray<GradientStop>;
+}
+/** Defines a linear (directional) gradient. */
+export interface LinearGradient extends GradientBase {
+    /** Discriminant — a linear projection. */
+    type: typeof GradientType.Linear;
+    /** Direction in degrees; `0` = left→right, `90` = top→bottom. */
+    angle: number;
+}
+/** Defines a radial (center-out) gradient. */
+export interface RadialGradient extends GradientBase {
+    /** Discriminant — a radial projection. */
+    type: typeof GradientType.Radial;
+    /** Extent as a fraction (`0..1`) of the canvas half-size — smaller is tighter. */
+    radius: number;
+}
+/** Defines a foreground gradient — a linear or radial projection over shared stops. */
+export type Gradient = LinearGradient | RadialGradient;
+/** Returns the gradient with one stop's color replaced (by index). */
+declare function withStop(gradient: Gradient, index: number, color: string): Gradient;
+/** Returns the gradient with its stop colors mirrored end-to-end, each offset kept — a symmetric flip for any stop count. */
+declare function reverseStops(gradient: Gradient): Gradient;
+/** Returns the gradient with its linear angle set (no-op on a radial gradient). */
+declare function withAngle(gradient: Gradient, angle: number): Gradient;
+/** Returns the gradient with its radial radius set (no-op on a linear gradient). */
+declare function withRadius(gradient: Gradient, radius: number): Gradient;
+/** Returns the gradient switched to `type` (keeping stops; the target's own field seeds from `defaults`); a no-op if already that type. */
+declare function withType(gradient: Gradient, type: GradientType, defaults: {
+    angle: number;
+    radius: number;
+}): Gradient;
+/** Creates a linear gradient from `stops` + `angle` (degrees). */
+declare function linear(stops: ReadonlyArray<GradientStop>, angle: number): LinearGradient;
+/** Creates a radial gradient from `stops` + `radius` (0..1 extent). */
+declare function radial(stops: ReadonlyArray<GradientStop>, radius: number): RadialGradient;
+/** Creates a two-stop linear gradient from a start + end color (offsets `0` and `1`). */
+declare function twoStop(start: string, end: string, angle: number): LinearGradient;
+/** Operations over a `Gradient` value — the companion to the `Gradient` type. */
+export declare const Gradient: {
+    linear: typeof linear;
+    twoStop: typeof twoStop;
+    radial: typeof radial;
+    withStop: typeof withStop;
+    reverseStops: typeof reverseStops;
+    withAngle: typeof withAngle;
+    withRadius: typeof withRadius;
+    withType: typeof withType;
+};
+export {};

package/dist/domain/color/GradientType.d.ts

@@ -0,0 +1,8 @@
+/** Defines the foreground gradient projection — linear or radial. */
+export declare const GradientType: {
+    /** Refers to a linear (directional) gradient. */
+    readonly Linear: "linear";
+    /** Refers to a radial (center-out) gradient. */
+    readonly Radial: "radial";
+};
+export type GradientType = (typeof GradientType)[keyof typeof GradientType];

package/dist/domain/color/index.d.ts

@@ -0,0 +1,3 @@
+export { GradientType } from './GradientType';
+export { Gradient } from './Gradient';
+export type { GradientStop, LinearGradient, RadialGradient, } from './Gradient';

package/dist/domain/color/index.js

@@ -0,0 +1,6 @@
+import { G, a } from "../../chunks/index-KL15HQew.js";
+export {
+  G as Gradient,
+  a as GradientType
+};
+//# sourceMappingURL=index.js.map

package/dist/domain/color/index.js.map

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

package/dist/domain/emoji/EmojiCatalog.d.ts

@@ -0,0 +1,29 @@
+import { EmojiCategory } from './EmojiCategory';
+/** Represents one catalog emoji — its glyph, display label, search tags, and display category. */
+export interface EmojiCatalogEntry {
+    /** The emoji glyph (a base emoji, no skin-tone variant). */
+    glyph: string;
+    /** The human-readable display name. */
+    label: string;
+    /** The lowercase keywords the search matches against. */
+    tags: readonly string[];
+    /** The top-level category the entry is grouped under. */
+    category: EmojiCategory;
+}
+/** Returns every catalog emoji in `category`, preserving display order. */
+declare function byCategory(category: EmojiCategory): readonly EmojiCatalogEntry[];
+/**
+ * Searches the catalog by a free-text keyword, case-insensitively.
+ * Matches on label and tags; ranks label matches above tag-only matches, and a
+ * label-prefix hit above a label-substring hit. Ties keep display order. A blank
+ * keyword returns the whole catalog.
+ */
+declare function search(keyword: string): readonly EmojiCatalogEntry[];
+/** Provides the standard emoji set (base emoji only) plus its category + search lookups — the companion to `EmojiCatalogEntry`. */
+export declare const EmojiCatalog: {
+    /** Every catalog emoji, in display order. */
+    all: readonly EmojiCatalogEntry[];
+    byCategory: typeof byCategory;
+    search: typeof search;
+};
+export {};

package/dist/domain/emoji/EmojiCatalogData.d.ts

@@ -0,0 +1,3 @@
+import { EmojiCatalogEntry } from './EmojiCatalog';
+/** Maps every catalog emoji to its char, label, search tags, and display category, in display order. */
+export declare const emojiCatalogData: readonly EmojiCatalogEntry[];

package/dist/domain/emoji/EmojiCategory.d.ts

@@ -0,0 +1,20 @@
+/** Defines a top-level emoji picker category, in display order (Telegram / Windows-keyboard parity). */
+export declare const EmojiCategory: {
+    /** Refers to smileys, emotion, and people. */
+    readonly SmileysPeople: "smileys-people";
+    /** Refers to animals and nature. */
+    readonly AnimalsNature: "animals-nature";
+    /** Refers to food and drink. */
+    readonly FoodDrink: "food-drink";
+    /** Refers to activities, sport, and events. */
+    readonly Activity: "activity";
+    /** Refers to travel and places. */
+    readonly TravelPlaces: "travel-places";
+    /** Refers to objects. */
+    readonly Objects: "objects";
+    /** Refers to symbols. */
+    readonly Symbols: "symbols";
+    /** Refers to flags. */
+    readonly Flags: "flags";
+};
+export type EmojiCategory = (typeof EmojiCategory)[keyof typeof EmojiCategory];

package/dist/domain/emoji/index.d.ts

@@ -0,0 +1,3 @@
+export { EmojiCategory } from './EmojiCategory';
+export { EmojiCatalog } from './EmojiCatalog';
+export type { EmojiCatalogEntry } from './EmojiCatalog';

package/dist/domain/emoji/index.js

@@ -0,0 +1,6 @@
+import { E, a } from "../../chunks/EmojiCatalog-CR4Lcm43.js";
+export {
+  E as EmojiCatalog,
+  a as EmojiCategory
+};
+//# sourceMappingURL=index.js.map

package/dist/domain/emoji/index.js.map

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

package/dist/feedback/FeedbackBus.d.ts

@@ -0,0 +1,71 @@
+import { VNode } from 'vue';
+/** Defines the tone of a notice — the house `Severity` vocabulary minus `neutral` (a notice always carries intent). */
+export declare const NoticeTone: {
+    /** Refers to an informational notice. */
+    readonly Info: "info";
+    /** Refers to a positive / success notice. */
+    readonly Success: "success";
+    /** Refers to a caution / warning notice. */
+    readonly Warning: "warning";
+    /** Refers to a destructive / error notice. */
+    readonly Danger: "danger";
+};
+export type NoticeTone = (typeof NoticeTone)[keyof typeof NoticeTone];
+/**
+ * A renderable slice of a notice. React's `ReactNode` becomes `string | VNode`
+ * for the same reason the `Toaster` payload did: notices travel as data through
+ * `notify()`, not through a slot, so a caller who wants markup builds it with
+ * `h()`. Structurally identical to `presentation/feedback`'s `ToastNode` — the
+ * adapter's assignment is what keeps the two from drifting, and this module
+ * cannot import that one (boundaries: `feedback` never reaches into
+ * `presentation`).
+ */
+export type NoticeNode = string | VNode;
+/** Defines a feedback notice published on the bus — the headless payload a presentation adapter renders (toast, banner, notification center…). */
+export interface FeedbackNotice {
+    /** The semantic tone — maps 1:1 onto the toast `severity` vocabulary. */
+    readonly tone: NoticeTone;
+    /** The headline. */
+    readonly title: NoticeNode;
+    /** The optional supporting body. */
+    readonly description?: NoticeNode;
+    /** An optional action slot (e.g. a retry button) — passed through to the rendering surface. */
+    readonly action?: NoticeNode;
+    /** An optional stable identity — assigned by the bus (`n_<seq>`) when omitted; callers set it for future dedupe / notification-center use. */
+    readonly id?: string;
+    /** ms before the rendering surface auto-dismisses. Surface default when omitted; `Infinity` = sticky. */
+    readonly durationMs?: number;
+}
+/** Defines a notice as delivered to subscribers — identity always assigned. */
+export interface PublishedNotice extends FeedbackNotice {
+    readonly id: string;
+}
+/** Defines a listener notified on every published notice. */
+export type NoticeListener = (notice: PublishedNotice) => void;
+/**
+ * Defines the module-scope feedback hub wiring app code to whatever surface renders notices.
+ * Fire-and-forget pub/sub (no replay): a notice published with no subscriber is dropped, so mount
+ * the adapter (`<FeedbackToasts/>`) before publishing. Nothing subscribes automatically — GWDNBM,
+ * every wire is explicit:
+ *
+ * - **Notices in** — `notify({ tone, title })` from anywhere (composables, api client code, stores);
+ *   `feedbackQueryErrors(bus)` plugs a `/query` global error seam in.
+ * - **Toasts out** — `<FeedbackToasts/>` (`/presentation/feedback`) subscribes and forwards each
+ *   notice into the imperative `toaster.toast()` API.
+ *
+ * Plain module state rather than a Vue plugin / `provide`: the bus is publisher-agnostic, and a
+ * publisher is rarely inside a component's `setup()` (an interceptor, a store action). The
+ * `bus` prop on the adapter is the isolation seam an app needs instead.
+ */
+export interface FeedbackBus {
+    /** Publishes a notice to all subscribers — safe to call with none mounted (no-op); returns the notice id. */
+    notify(notice: FeedbackNotice): string;
+    /** Subscribes to published notices; returns an unsubscribe. */
+    subscribe(listener: NoticeListener): () => void;
+}
+/** Creates a {@link FeedbackBus} — one per app, module scope, shared by publishers and the rendering adapter. Apps that don't need isolation use the default {@link feedbackBus}. */
+export declare function createFeedbackBus(): FeedbackBus;
+/** The default app-wide bus — what `notify` and the adapters bind to unless handed an explicit bus. */
+export declare const feedbackBus: FeedbackBus;
+/** Publishes a notice on the default {@link feedbackBus} — the everyday `notify({ tone: 'success', title: 'Saved' })` entry point. */
+export declare function notify(notice: FeedbackNotice): string;

package/dist/feedback/FeedbackQueryErrors.d.ts

@@ -0,0 +1,21 @@
+import { ApiError } from '../foundation/http';
+import { FeedbackBus, FeedbackNotice } from './FeedbackBus';
+/**
+ * Maps a coerced `ApiError` onto a danger notice — title from the problem body (`problem.title`,
+ * else a status-shaped fallback), description from `problem.detail`. Network failures (status `0`)
+ * title as "Network error" and surface the wrapped transport message as the description. Exported
+ * for apps composing their own error callback on top of the house mapping.
+ */
+export declare function toErrorNotice(error: ApiError): FeedbackNotice;
+/**
+ * Produces the global query error callback — plug into the existing seam:
+ * `createQueryClient({ onError: feedbackQueryErrors() })`. Lives here (not in `/query`) so the
+ * query module keeps its TanStack-optional isolation and never depends on the bus; the callback
+ * shape (`(error: ApiError) => void`) also fits a hand-rolled `QueryCache` / `MutationCache`
+ * `onError` after `toApiError` coercion. Explicit opt-in wiring — nothing toasts until an app
+ * passes this.
+ *
+ * The Vue port's `/query` subpath has landed, so `createQueryClient({ onError: … })` is the
+ * primary seam; the callback also stays usable against `@tanstack/vue-query`'s own cache options.
+ */
+export declare function feedbackQueryErrors(bus?: FeedbackBus): (error: ApiError) => void;

package/dist/feedback/index.d.ts

@@ -0,0 +1,2 @@
+export { NoticeTone, createFeedbackBus, feedbackBus, notify, type NoticeNode, type FeedbackNotice, type PublishedNotice, type NoticeListener, type FeedbackBus, } from './FeedbackBus';
+export { feedbackQueryErrors, toErrorNotice } from './FeedbackQueryErrors';

package/dist/feedback/index.js

@@ -0,0 +1,20 @@
+import { f as feedbackBus, N as NoticeTone } from "../chunks/FeedbackBus-BRbyOMCn.js";
+import { c, n } from "../chunks/FeedbackBus-BRbyOMCn.js";
+function toErrorNotice(error) {
+  const isNetwork = error.status === 0;
+  const title = error.problem?.title ?? (isNetwork ? "Network error" : `Request failed (${error.status})`);
+  const description = error.problem?.detail ?? (isNetwork && error.message !== title ? error.message : void 0);
+  return { tone: NoticeTone.Danger, title, description };
+}
+function feedbackQueryErrors(bus = feedbackBus) {
+  return (error) => void bus.notify(toErrorNotice(error));
+}
+export {
+  NoticeTone,
+  c as createFeedbackBus,
+  feedbackBus,
+  feedbackQueryErrors,
+  n as notify,
+  toErrorNotice
+};
+//# sourceMappingURL=index.js.map

package/dist/feedback/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../src/feedback/FeedbackQueryErrors.ts"],"sourcesContent":["import type { ApiError } from '../foundation/http';\n\nimport { feedbackBus, NoticeTone, type FeedbackBus, type FeedbackNotice } from './FeedbackBus';\n\n/**\n * Maps a coerced `ApiError` onto a danger notice — title from the problem body (`problem.title`,\n * else a status-shaped fallback), description from `problem.detail`. Network failures (status `0`)\n * title as \"Network error\" and surface the wrapped transport message as the description. Exported\n * for apps composing their own error callback on top of the house mapping.\n */\nexport function toErrorNotice(error: ApiError): FeedbackNotice {\n  const isNetwork = error.status === 0;\n  const title = error.problem?.title ?? (isNetwork ? 'Network error' : `Request failed (${error.status})`);\n  const description =\n    error.problem?.detail ?? (isNetwork && error.message !== title ? error.message : undefined);\n\n  return { tone: NoticeTone.Danger, title, description };\n}\n\n/**\n * Produces the global query error callback — plug into the existing seam:\n * `createQueryClient({ onError: feedbackQueryErrors() })`. Lives here (not in `/query`) so the\n * query module keeps its TanStack-optional isolation and never depends on the bus; the callback\n * shape (`(error: ApiError) => void`) also fits a hand-rolled `QueryCache` / `MutationCache`\n * `onError` after `toApiError` coercion. Explicit opt-in wiring — nothing toasts until an app\n * passes this.\n *\n * The Vue port's `/query` subpath has landed, so `createQueryClient({ onError: … })` is the\n * primary seam; the callback also stays usable against `@tanstack/vue-query`'s own cache options.\n */\nexport function feedbackQueryErrors(bus: FeedbackBus = feedbackBus): (error: ApiError) => void {\n  return (error) => void bus.notify(toErrorNotice(error));\n}\n"],"names":[],"mappings":";;AAUO,SAAS,cAAc,OAAiC;AAC7D,QAAM,YAAY,MAAM,WAAW;AACnC,QAAM,QAAQ,MAAM,SAAS,UAAU,YAAY,kBAAkB,mBAAmB,MAAM,MAAM;AACpG,QAAM,cACJ,MAAM,SAAS,WAAW,aAAa,MAAM,YAAY,QAAQ,MAAM,UAAU;AAEnF,SAAO,EAAE,MAAM,WAAW,QAAQ,OAAO,YAAA;AAC3C;AAaO,SAAS,oBAAoB,MAAmB,aAAwC;AAC7F,SAAO,CAAC,UAAU,KAAK,IAAI,OAAO,cAAc,KAAK,CAAC;AACxD;"}

package/dist/flags/FlagClient.d.ts

@@ -0,0 +1,72 @@
+import { FlagProvider } from './FlagProvider';
+import { EvaluationContext, FlagErrorInfo, FlagEvaluation, FlagValue, JsonObject } from './FlagTypes';
+/** Defines the listener handed each evaluation fault — the reporting channel, evaluation has already fallen back. */
+export type FlagErrorListener = (error: FlagErrorInfo) => void;
+/** Defines the listener notified after the evaluation context changes — how the Vue seam knows to re-evaluate. */
+export type FlagContextListener = (context: EvaluationContext) => void;
+/** Defines the options for {@link createFlagClient}. */
+export interface CreateFlagClientOptions {
+    /** The flag source. Defaults to an empty {@link staticFlagProvider} — every flag returns the caller's default. */
+    readonly provider?: FlagProvider;
+    /** The initial evaluation context (targeting subject + attributes). */
+    readonly context?: EvaluationContext;
+    /** Receives every evaluation fault (type mismatch, provider error). Misses and disabled flags are not faults and never arrive here. */
+    readonly onError?: FlagErrorListener;
+}
+/**
+ * Defines the app-facing evaluation API. `get*` returns just the value — the everyday call; `evaluate*`
+ * returns the full {@link FlagEvaluation} when the reason or variant matters (exposure logging,
+ * debugging a rollout). Both are total: on any miss or fault the caller's `defaultValue` comes back.
+ *
+ * Each call takes an optional context that is merged over the client-wide one for that call only.
+ */
+export interface FlagClient {
+    /** The flag source behind this client. */
+    readonly provider: FlagProvider;
+    /** Evaluates a boolean flag, returning its value. */
+    getBoolean(key: string, defaultValue: boolean, context?: EvaluationContext): boolean;
+    /** Evaluates a string flag, returning its value. */
+    getString(key: string, defaultValue: string, context?: EvaluationContext): string;
+    /** Evaluates a number flag, returning its value. */
+    getNumber(key: string, defaultValue: number, context?: EvaluationContext): number;
+    /** Evaluates a JSON object flag, returning its payload. Object-ness is verified at runtime; the payload's inner shape is the caller's assertion. */
+    getObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue;
+    /** Evaluates a boolean flag, returning the full outcome. */
+    evaluateBoolean(key: string, defaultValue: boolean, context?: EvaluationContext): FlagEvaluation<boolean>;
+    /** Evaluates a string flag, returning the full outcome. */
+    evaluateString(key: string, defaultValue: string, context?: EvaluationContext): FlagEvaluation<string>;
+    /** Evaluates a number flag, returning the full outcome. */
+    evaluateNumber(key: string, defaultValue: number, context?: EvaluationContext): FlagEvaluation<number>;
+    /** Evaluates a JSON object flag, returning the full outcome. */
+    evaluateObject<TValue extends JsonObject>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue>;
+    /** Evaluates any flag, picking the typed path from the runtime type of `defaultValue` — what `useFlag` is built on. */
+    getValue<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): TValue;
+    /** Evaluates any flag, picking the typed path from the runtime type of `defaultValue`, returning the full outcome. */
+    evaluate<TValue extends FlagValue>(key: string, defaultValue: TValue, context?: EvaluationContext): FlagEvaluation<TValue>;
+    /** Reads the current client-wide evaluation context. */
+    getContext(): EvaluationContext;
+    /**
+     * Merges attributes into the client-wide evaluation context — an attribute set to `undefined` is
+     * removed. A merge that changes nothing is a no-op: no listener runs and the provider is not
+     * re-notified, so a context literal rebuilt on every parent render costs nothing (a remote adapter
+     * would otherwise refetch, and every flag consumer re-evaluate, once per parent render).
+     */
+    setContext(context: EvaluationContext): void;
+    /** Subscribes to context changes; returns an unsubscribe. */
+    subscribe(listener: FlagContextListener): () => void;
+}
+/**
+ * Creates a flag client over a {@link FlagProvider} — one per app, module scope, shared by the Vue
+ * seam ({@link FlagsProvider}) and any non-Vue caller (route guards, api-client wiring, sagas).
+ *
+ * ```ts
+ * export const flags = createFlagClient({
+ *   provider: staticFlagProvider({ newNav: { value: false, rules: [{ when: { plan: 'pro' }, value: true }] } }),
+ *   onError: (error) => notify({ tone: NoticeTone.Warning, title: `flag ${error.key}: ${error.message}` }),
+ * });
+ *
+ * flags.setContext({ targetingKey: user.id, plan: user.plan });
+ * flags.getBoolean('newNav', false);
+ * ```
+ */
+export declare function createFlagClient(options?: CreateFlagClientOptions): FlagClient;