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

package/dist/foundation/selection/UseFilters.d.ts

@@ -1,34 +0,0 @@
-import { ComputedRef, MaybeRefOrGetter } from 'vue';
-import { FilterDescriptor } from './Filter';
-/** Options accepted by {@link useFilters}. All are optional; the default is an uncontrolled empty filter set. */
-export interface UseFiltersOptions<TField extends string = string> {
-    /** The controlled clause list. Pass to own the filter state; omit for uncontrolled. */
-    filters?: MaybeRefOrGetter<readonly FilterDescriptor<TField>[] | undefined>;
-    /** The initial clause list when uncontrolled. Read once; ignored while `filters` is passed. */
-    defaultFilters?: MaybeRefOrGetter<readonly FilterDescriptor<TField>[] | undefined>;
-    /** Fires with the next clause list whenever it changes. */
-    onFiltersChange?: (filters: readonly FilterDescriptor<TField>[]) => void;
-}
-/** The filter state and bound operations returned by {@link useFilters}. */
-export interface FilterControls<TField extends string = string> {
-    /** The current clauses, AND-ed. Feed to `applyFilters` / `filterPredicate`. */
-    readonly filters: ComputedRef<readonly FilterDescriptor<TField>[]>;
-    /** Replaces the whole clause list — the escape hatch for several clauses on one field. */
-    readonly setFilters: (filters: readonly FilterDescriptor<TField>[]) => void;
-    /** Upserts a clause by field, keeping its position when it already exists. */
-    readonly setFilter: (filter: FilterDescriptor<TField>) => void;
-    /** Drops every clause on a field. */
-    readonly removeFilter: (field: TField) => void;
-    /** Drops every clause. */
-    readonly clear: () => void;
-    /** The first clause on a field, or `undefined` — what a filter-bar control reads to render its value. */
-    readonly filterFor: (field: TField) => FilterDescriptor<TField> | undefined;
-}
-/**
- * Binds the filter model to reactive state, controlled or uncontrolled.
- *
- * Controlled when `filters` resolves to a defined value: the composable stores nothing and only calls
- * `onFiltersChange` — the shape a server-side filtered list wants, where the clauses round-trip through a
- * query.
- */
-export declare function useFilters<TField extends string = string>(options?: UseFiltersOptions<TField>): FilterControls<TField>;

package/dist/foundation/selection/UseSelection.d.ts

@@ -1,54 +0,0 @@
-import { ComputedRef, MaybeRefOrGetter } from 'vue';
-import { SelectionMode, SelectionKey, SelectionState, SelectionStatus, SelectRangeOptions } from './Selection';
-/** Options accepted by {@link useSelection}. All are optional; the default is an uncontrolled multi-select. */
-export interface UseSelectionOptions<TKey extends SelectionKey> {
-    /** The selection mode. Defaults to `'multiple'`. */
-    mode?: MaybeRefOrGetter<SelectionMode | undefined>;
-    /** The controlled selected keys. Pass to own the selection; omit for uncontrolled. */
-    selectedKeys?: MaybeRefOrGetter<ReadonlyArray<TKey> | undefined>;
-    /** The initial selected keys when uncontrolled. Read once; ignored while `selectedKeys` is passed. */
-    defaultSelectedKeys?: MaybeRefOrGetter<ReadonlyArray<TKey> | undefined>;
-    /** Fires with the next key list whenever the selection actually changes. */
-    onSelectionChange?: (keys: readonly TKey[]) => void;
-}
-/** The selection state and bound operations returned by {@link useSelection}. */
-export interface SelectionControls<TKey extends SelectionKey> {
-    /** The current immutable snapshot — pass to the pure model for anything not covered here. */
-    readonly state: ComputedRef<SelectionState<TKey>>;
-    /** The selected keys in insertion order. */
-    readonly keys: ComputedRef<readonly TKey[]>;
-    /** The mode in force. */
-    readonly mode: ComputedRef<SelectionMode>;
-    /** The number of selected keys. */
-    readonly count: ComputedRef<number>;
-    /** Reports whether a key is selected. */
-    readonly isSelected: (key: TKey) => boolean;
-    /** The tri-state for a header checkbox over the given (usually filtered) keys. */
-    readonly status: (keys: Iterable<TKey>) => SelectionStatus;
-    /** Selects a key and anchors on it. */
-    readonly select: (key: TKey) => void;
-    /** Deselects a key and anchors on it. */
-    readonly deselect: (key: TKey) => void;
-    /** Flips a key and anchors on it — the plain click. */
-    readonly toggle: (key: TKey) => void;
-    /** Adds every given key to the selection. */
-    readonly selectAll: (keys: Iterable<TKey>) => void;
-    /** Empties the selection and drops the anchor. */
-    readonly clear: () => void;
-    /** Flips every given key, leaving keys outside the set alone. */
-    readonly invert: (keys: Iterable<TKey>) => void;
-    /** The header-checkbox click over the given keys. */
-    readonly toggleAll: (keys: Iterable<TKey>) => void;
-    /** Selects the run between an explicit anchor and a target, in the surface's visual order. */
-    readonly selectRange: (anchor: TKey, target: TKey, orderedKeys: readonly TKey[], options?: SelectRangeOptions) => void;
-    /** The shift-click — extends from the tracked anchor to the target. */
-    readonly extend: (target: TKey, orderedKeys: readonly TKey[], options?: SelectRangeOptions) => void;
-}
-/**
- * Binds the selection model to reactive state, controlled or uncontrolled.
- *
- * Controlled when `selectedKeys` resolves to a defined value: the composable never stores keys, it only calls
- * `onSelectionChange` with the next list. Uncontrolled otherwise, seeded from `defaultSelectedKeys`, with
- * `onSelectionChange` still firing so a consumer can observe without owning.
- */
-export declare function useSelection<TKey extends SelectionKey>(options?: UseSelectionOptions<TKey>): SelectionControls<TKey>;

package/dist/foundation/selection/UseSort.d.ts

@@ -1,36 +0,0 @@
-import { ComputedRef, MaybeRefOrGetter } from 'vue';
-import { SortDescriptor, SortDirection } from './Sort';
-/** Options accepted by {@link useSort}. All are optional; the default is an uncontrolled single-field sort. */
-export interface UseSortOptions<TField extends string = string> {
-    /** The controlled ordering. Pass to own the sort state; omit for uncontrolled. */
-    sort?: MaybeRefOrGetter<readonly SortDescriptor<TField>[] | undefined>;
-    /** The initial ordering when uncontrolled. Read once; ignored while `sort` is passed. */
-    defaultSort?: MaybeRefOrGetter<readonly SortDescriptor<TField>[] | undefined>;
-    /** Fires with the next ordering whenever it changes. */
-    onSortChange?: (sort: readonly SortDescriptor<TField>[]) => void;
-    /** The multi-field behaviour of {@link SortControls.toggle}. Defaults to `false` (one sorted field). */
-    isMulti?: MaybeRefOrGetter<boolean | undefined>;
-}
-/** The sort state and bound operations returned by {@link useSort}. */
-export interface SortControls<TField extends string = string> {
-    /** The current ordering — array order is precedence. Feed to `applySort` / `sortComparator`. */
-    readonly descriptors: ComputedRef<readonly SortDescriptor<TField>[]>;
-    /** Advances a field through `asc → desc → none` — the header click. */
-    readonly toggle: (field: TField) => void;
-    /** Replaces the whole ordering — for a "sort by" menu that sets state outright. */
-    readonly setSort: (descriptors: readonly SortDescriptor<TField>[]) => void;
-    /** Drops all ordering. */
-    readonly clear: () => void;
-    /** The direction applied to a field, or `null` when unsorted — drives the header's arrow and `aria-sort`. */
-    readonly directionFor: (field: TField) => SortDirection | null;
-    /** The 0-based precedence of a field, or `-1` — the multi-sort header's order badge. */
-    readonly indexFor: (field: TField) => number;
-}
-/**
- * Binds the sort model to reactive state, controlled or uncontrolled.
- *
- * Controlled when `sort` resolves to a defined value: the composable stores nothing and only calls
- * `onSortChange` — the shape a server-side sorted table wants, where the ordering round-trips through a query
- * rather than local state.
- */
-export declare function useSort<TField extends string = string>(options?: UseSortOptions<TField>): SortControls<TField>;

package/dist/foundation/shortcuts/UseHotkeys.d.ts

@@ -1,34 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { ChordPlatformOptions } from './Chord';
-/** Tunes how a hotkey binding listens. */
-export interface HotkeyOptions extends ChordPlatformOptions {
-    /** Whether the binding is active. Defaults to `true`. */
-    readonly enabled?: MaybeRefOrGetter<boolean>;
-    /** Whether a match calls `event.preventDefault()`. Defaults to `true`. */
-    readonly preventDefault?: MaybeRefOrGetter<boolean>;
-    /**
-     * Whether to ignore keystrokes while a text input / textarea / select / `contenteditable` has focus.
-     * Defaults to `true` — but a chord carrying Ctrl or Meta still fires (so `mod+k` works inside a field).
-     */
-    readonly ignoreInputs?: MaybeRefOrGetter<boolean>;
-    /** The element to bind to; defaults to `window`. Pass a template ref to scope the shortcut to a subtree. */
-    readonly target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
-    /** Which key phase to listen on. Defaults to `keydown`. */
-    readonly eventType?: 'keydown' | 'keyup';
-}
-/**
- * Binds one or more chord strings to a single handler. Multiple chords act as an OR (`['mod+k', 'ctrl+k']`).
- * The chords are parsed in a `computed`, so an inline array literal costs one parse; the handler and the
- * behavioural options are read at event time, so passing fresh closures is fine — the listener is attached
- * once per `target`/`eventType`/platform and reused.
- */
-export declare function useHotkeys(chords: MaybeRefOrGetter<string | readonly string[]>, handler: (event: KeyboardEvent) => void, options?: HotkeyOptions): void;
-/** The per-chord handler a keymap holds; a falsy entry is a row the caller has disabled. */
-type HotkeyMapHandler = ((event: KeyboardEvent) => void) | false | null | undefined;
-/**
- * Binds a map of `chord → handler` — the ergonomic shape for a command palette or editor keymap. Each entry is
- * an independent binding sharing the same `options`. A `false`/`null`/`undefined` handler entry is skipped, so a
- * caller can conditionally disable one row without restructuring the map.
- */
-export declare function useHotkeyMap(map: MaybeRefOrGetter<Readonly<Record<string, HotkeyMapHandler>>>, options?: HotkeyOptions): void;
-export {};

package/dist/foundation/speech/UseSpeechRecognition.d.ts

@@ -1,45 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { RecognizerStartResult, SpeechRecognizerOptions } from './CreateSpeechRecognizer';
-import { SpeechRecognitionFailure } from './SpeechRecognitionResult';
-/** Options for {@link useSpeechRecognition} — the recognizer's own, with the composable layering state on top. */
-export type UseSpeechRecognitionOptions = SpeechRecognizerOptions;
-/** What {@link useSpeechRecognition} returns. */
-export interface SpeechRecognitionControls {
-    /** Whether this browser can transcribe at all. `false` under SSR and in Firefox — gate the button on it. */
-    readonly supported: Readonly<ShallowRef<boolean>>;
-    /** Whether the engine is listening. `false` in the gap between `start()` and the engine actually opening the microphone. */
-    readonly listening: Readonly<ShallowRef<boolean>>;
-    /** Every committed phrase of the session, space-joined. Survives an ended session; cleared by `reset`. */
-    readonly transcript: Readonly<ShallowRef<string>>;
-    /** The current uncommitted text. Requires `interimResults`; cleared when the phrase commits or the session ends. */
-    readonly interimTranscript: Readonly<ShallowRef<string>>;
-    /** The last classified failure, or `null`. Cleared when a new session starts. `no-speech` lands here too. */
-    readonly error: Readonly<ShallowRef<SpeechRecognitionFailure | null>>;
-    /** Begins a session. Safe to call twice — the second answers `already-started`. */
-    readonly start: () => RecognizerStartResult;
-    /** Ends the session, keeping what the engine already recognized. */
-    readonly stop: () => void;
-    /** Ends the session immediately, discarding pending results. */
-    readonly abort: () => void;
-    /** Clears `transcript`, `interimTranscript`, and `error`. Does not touch the session. */
-    readonly reset: () => void;
-}
-/**
- * Transcribes speech into accumulating reactive state, aborting the session when the scope is disposed.
- *
- * ```vue
- * const dictation = useSpeechRecognition({ interimResults: true, continuous: true });
- * <button :disabled="!dictation.supported.value" @click="dictation.start()">
- *   {{ dictation.listening.value ? 'Listening…' : 'Dictate' }}
- * </button>
- * <p>{{ dictation.transcript.value }} <em>{{ dictation.interimTranscript.value }}</em></p>
- * ```
- *
- * `lang` defaults to the active `LocaleProvider` locale, so a localized app transcribes the language its user is
- * reading. Nothing throws.
- *
- * @param options Session shape and pass-through callbacks — each is called in addition to the state updates.
- *   A ref or getter is read at call time, so a reactive options source is followed.
- * @returns The transcript state plus the four controls.
- */
-export declare function useSpeechRecognition(options?: MaybeRefOrGetter<UseSpeechRecognitionOptions | undefined>): SpeechRecognitionControls;

package/dist/foundation/speech/UseSpeechSynthesis.d.ts

@@ -1,37 +0,0 @@
-import { ShallowRef } from 'vue';
-import { SpeakOptions } from './Speak';
-import { SpeakResult } from './SpeechResult';
-/** What {@link useSpeechSynthesis} returns. */
-export interface SpeechSynthesisControls {
-    /** Whether this browser can speak. `false` under SSR — render the button only once this is `true`. */
-    readonly supported: Readonly<ShallowRef<boolean>>;
-    /** The installed voices. Starts empty and fills in asynchronously; see `ListVoices` for why that is normal. */
-    readonly voices: Readonly<ShallowRef<readonly SpeechSynthesisVoice[]>>;
-    /** Whether this composable has an utterance in flight. Not the engine's global flag — another component's speech is not this one's. */
-    readonly speaking: Readonly<ShallowRef<boolean>>;
-    /** Whether this composable paused the engine. */
-    readonly paused: Readonly<ShallowRef<boolean>>;
-    /** Speaks text, resolving to the outcome. Never throws. Defaults `lang` to the active locale. */
-    readonly speak: (text: string, options?: SpeakOptions) => Promise<SpeakResult>;
-    /** Stops all speech in the document — the platform has no narrower cancel. In-flight `speak` calls settle as `cancelled`. */
-    readonly cancel: () => void;
-    /** Pauses the engine. See `SpeechControls` for Chrome-on-Android's pause-is-cancel behaviour. */
-    readonly pause: () => void;
-    /** Resumes a paused engine. */
-    readonly resume: () => void;
-}
-/**
- * Speaks text and owns the lifecycle — cancelling this composable's in-flight speech when the scope is disposed.
- *
- * ```vue
- * const speech = useSpeechSynthesis();
- * <button :disabled="!speech.supported.value" @click="speech.speak(article)">
- *   {{ speech.speaking.value ? 'Stop' : 'Read aloud' }}
- * </button>
- * ```
- *
- * Inherits the slice's never-throws contract — a rejected promise is not one of the outcomes.
- *
- * @returns The state plus the four controls.
- */
-export declare function useSpeechSynthesis(): SpeechSynthesisControls;

package/dist/foundation/storage/zustand/ZustandPersist.d.ts

@@ -1,36 +0,0 @@
-import { StorageBroker } from '../StorageBroker';
-/** The persisted envelope zustand writes — the store state plus zustand's own persist version. Mirrors `zustand/middleware`. */
-export interface StorageValue<S> {
-    /** The persisted store state. */
-    readonly state: S;
-    /** zustand's persist schema version (owned by the store's `persist` options), if set. */
-    readonly version?: number;
-}
-/**
- * The post-JSON storage contract zustand's `persist` reads and writes through (mirror of zustand v5's
- * `PersistStorage<S>`). Values are already-parsed `StorageValue` objects — no string encoding here, since the
- * backing `StorageBroker` owns JSON serialization.
- */
-export interface PersistStorage<S> {
-    /** Reads the persisted envelope for `name`, or null when absent or unreadable. */
-    getItem(name: string): StorageValue<S> | null;
-    /** Persists `value` under `name`. */
-    setItem(name: string, value: StorageValue<S>): void;
-    /** Removes any persisted value under `name`. */
-    removeItem(name: string): void;
-}
-/**
- * Adapts `broker` into a zustand `PersistStorage<S>`. Because the broker already serializes to and from JSON,
- * the returned storage hands zustand the parsed `StorageValue` directly (no `createJSONStorage` wrapper needed).
- * It inherits the broker's failure-tolerance: an absent, malformed, or blocked read yields null, which zustand
- * treats as "no persisted state" and falls back to the store's initial state.
- *
- * @example
- * import { create } from 'zustand';
- * import { persist } from 'zustand/middleware';
- * import { localStorageStorageBroker } from '@wow-two-beta/ui-vue/foundation/storage';
- * import { brokerPersistStorage } from '@wow-two-beta/ui-vue/foundation/storage/zustand';
- *
- * const useStore = create(persist(init, { name: 'app', storage: brokerPersistStorage(localStorageStorageBroker) }));
- */
-export declare function brokerPersistStorage<S>(broker: StorageBroker): PersistStorage<S>;

package/dist/foundation/storage/zustand/index.d.ts

@@ -1 +0,0 @@
-export { type StorageValue, type PersistStorage, brokerPersistStorage, } from './ZustandPersist';

package/dist/foundation/storage/zustand/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../../../../src/foundation/storage/zustand/ZustandPersist.ts"],"sourcesContent":["// zustand-persist adapter. Bridges a `StorageBroker` into the storage seam zustand's `persist` middleware\n// expects, so a zustand store persists through the SAME swappable broker as the rest of the SDK: the in-memory\n// double in tests, a `namespacedBroker` for isolation, or the SSR-safe `localStorage` broker in production — with\n// no store change. Versioning/migration stays with zustand's own `version`/`migrate` persist options (this\n// adapter is the *storage* seam, not a second migration system — use `createVersionedStore` for plain values).\n//\n// zustand is NOT a dependency here: the `PersistStorage`/`StorageValue` shapes below are a structural mirror of\n// zustand v5's (`zustand/middleware`). The object returned by `brokerPersistStorage` is structurally assignable\n// to zustand's real `PersistStorage<S>` on the consumer side, so the consumer simply brings zustand and passes\n// this in: `persist(init, { name, storage: brokerPersistStorage(broker) })`. Keep these types in sync with zustand v5.\n\nimport type { StorageBroker } from '../StorageBroker';\n\n/** The persisted envelope zustand writes — the store state plus zustand's own persist version. Mirrors `zustand/middleware`. */\nexport interface StorageValue<S> {\n  /** The persisted store state. */\n  readonly state: S;\n\n  /** zustand's persist schema version (owned by the store's `persist` options), if set. */\n  readonly version?: number;\n}\n\n/**\n * The post-JSON storage contract zustand's `persist` reads and writes through (mirror of zustand v5's\n * `PersistStorage<S>`). Values are already-parsed `StorageValue` objects — no string encoding here, since the\n * backing `StorageBroker` owns JSON serialization.\n */\nexport interface PersistStorage<S> {\n  /** Reads the persisted envelope for `name`, or null when absent or unreadable. */\n  getItem(name: string): StorageValue<S> | null;\n\n  /** Persists `value` under `name`. */\n  setItem(name: string, value: StorageValue<S>): void;\n\n  /** Removes any persisted value under `name`. */\n  removeItem(name: string): void;\n}\n\n/**\n * Adapts `broker` into a zustand `PersistStorage<S>`. Because the broker already serializes to and from JSON,\n * the returned storage hands zustand the parsed `StorageValue` directly (no `createJSONStorage` wrapper needed).\n * It inherits the broker's failure-tolerance: an absent, malformed, or blocked read yields null, which zustand\n * treats as \"no persisted state\" and falls back to the store's initial state.\n *\n * @example\n * import { create } from 'zustand';\n * import { persist } from 'zustand/middleware';\n * import { localStorageStorageBroker } from '@wow-two-beta/ui-vue/foundation/storage';\n * import { brokerPersistStorage } from '@wow-two-beta/ui-vue/foundation/storage/zustand';\n *\n * const useStore = create(persist(init, { name: 'app', storage: brokerPersistStorage(localStorageStorageBroker) }));\n */\nexport function brokerPersistStorage<S>(broker: StorageBroker): PersistStorage<S> {\n  return {\n    getItem: (name) => broker.read<StorageValue<S>>(name),\n    setItem: (name, value) => broker.write(name, value),\n    removeItem: (name) => broker.remove(name),\n  };\n}\n"],"names":[],"mappings":"AAoDO,SAAS,qBAAwB,QAA0C;AAChF,SAAO;AAAA,IACL,SAAS,CAAC,SAAS,OAAO,KAAsB,IAAI;AAAA,IACpD,SAAS,CAAC,MAAM,UAAU,OAAO,MAAM,MAAM,KAAK;AAAA,IAClD,YAAY,CAAC,SAAS,OAAO,OAAO,IAAI;AAAA,EAAA;AAE5C;"}

package/dist/foundation/sync/LeaderElection.d.ts

@@ -1,88 +0,0 @@
-import { Guid } from '../identifiers';
-import { SyncChannel, SyncChannelOptions } from './SyncChannel';
-/**
- * Carries the election's traffic. Each signal repeats its sender's id in the payload rather than relying on the
- * envelope, so the messages stay self-describing when read in devtools or replayed through another transport.
- */
-export type LeaderSignal = 
-/** Asserts live leadership; resets every follower's expiry watchdog. */
-{
-    readonly kind: 'heartbeat';
-    readonly id: Guid;
-}
-/** Announces a bid for the empty throne; a live leader answers it with a heartbeat. */
- | {
-    readonly kind: 'claim';
-    readonly id: Guid;
-}
-/** Surrenders leadership deliberately, so peers re-elect at once instead of waiting out the expiry. */
- | {
-    readonly kind: 'resign';
-    readonly id: Guid;
-};
-/** Names a participant's position in the election. */
-export type LeaderRole = 'follower' | 'candidate' | 'leader';
-/** Defines the options that tune an election's timing and transport. */
-export interface LeaderElectionOptions {
-    /** Sets how often the leader re-asserts, in milliseconds; defaults to 1000. */
-    readonly heartbeatInterval?: number;
-    /** Sets how long a follower tolerates silence before claiming, in milliseconds; defaults to 3500. */
-    readonly timeout?: number;
-    /** Sets how long a candidate collects rival claims, in milliseconds; defaults to 150. */
-    readonly claimWindow?: number;
-    /**
-     * Supplies the channel to run on instead of opening one — the seam tests use to join a `memorySyncHub`. An
-     * injected channel is NOT closed by `close`; its owner keeps that duty.
-     */
-    readonly channel?: SyncChannel<LeaderSignal>;
-    /** Tunes the channel opened when `channel` is omitted; ignored when one is supplied. */
-    readonly channelOptions?: SyncChannelOptions;
-}
-/** Represents this tab's participation in a named election. */
-export interface LeaderElection {
-    /** Identifies this participant — the same id as the underlying channel's endpoint. */
-    readonly id: Guid;
-    /** Reports whether this tab currently holds the lease. */
-    readonly isLeader: boolean;
-    /** Reports this tab's position — `candidate` is the transient state inside a claim window. */
-    readonly role: LeaderRole;
-    /**
-     * Registers `listener` for the moment this tab takes leadership. Fires IMMEDIATELY and synchronously if it is
-     * already the leader when subscribing, so a late subscriber cannot miss the transition it was waiting for.
-     *
-     * @param listener - Invoked on becoming leader; a throw is swallowed.
-     * @returns An idempotent disposer.
-     */
-    onBecomeLeader(listener: () => void): () => void;
-    /**
-     * Registers `listener` for the moment this tab loses leadership — superseded by a lower id, or after
-     * `release`. Not fired by `close`, which is a teardown rather than a state change.
-     *
-     * @param listener - Invoked on losing leadership; a throw is swallowed.
-     * @returns An idempotent disposer.
-     */
-    onLoseLeader(listener: () => void): () => void;
-    /**
-     * Surrenders leadership deliberately and tells peers to re-elect at once. This tab stays in the election and
-     * may win again later — typically after `timeout`, by which point a peer has long since taken over.
-     */
-    release(): void;
-    /**
-     * Leaves the election entirely: resigns first if leading, then drops every timer and listener. Idempotent.
-     * Does not fire `onLoseLeader`. Closes the underlying channel only when this election opened it.
-     */
-    close(): void;
-}
-/**
- * Joins the named election, in which exactly one participating tab holds leadership at a time.
- *
- * Leadership is a lease kept alive by a heartbeat, so a tab that dies without resigning is superseded once its
- * lease expires — the reclaim path is the reason this exists. Ties are broken by lowest id, which for the
- * time-ordered v7 ids minted here means the longest-open tab wins. Starts campaigning immediately; nothing
- * throws, and under SSR or with no cross-tab transport the sole participant simply becomes leader.
- *
- * @param name - Election name; tabs sharing it on the origin compete for one leadership.
- * @param options - Timing, and the channel to run on.
- * @returns The participant handle: state, transition events, `release`, and `close`.
- */
-export declare function createLeaderElection(name: string, options?: LeaderElectionOptions): LeaderElection;

package/dist/foundation/sync/SyncChannel.d.ts

@@ -1,65 +0,0 @@
-import { Guid } from '../identifiers';
-import { StorageBroker } from '../storage';
-/**
- * Wraps one posted payload with the metadata the dispatch path needs — who sent it, in what order, and when.
- * Written to the wire by both real transports so the receiving rules are identical across them.
- */
-export interface SyncEnvelope<TMessage> {
-    /** Identifies the tab that posted the message; the receiver drops an envelope whose sender is itself. */
-    readonly sender: Guid;
-    /** Counts posts from this sender, starting at 0 — makes each fallback write unique and each delivery de-dupable. */
-    readonly seq: number;
-    /** Records the post time in epoch milliseconds, as read from the channel's clock. */
-    readonly timestamp: number;
-    /** Carries the caller's payload, unvalidated at runtime — see this file's header. */
-    readonly message: TMessage;
-}
-/**
- * Receives a message from another tab. The payload comes first because it is what nearly every caller wants;
- * the envelope follows for the rare consumer that needs the sender or the ordering metadata.
- */
-export type SyncListener<TMessage> = (message: TMessage, envelope: SyncEnvelope<TMessage>) => void;
-/**
- * Names the delivery mechanisms a channel can sit on. `auto` picks the best one available and is the default;
- * the explicit values exist for tests and for a consumer that deliberately wants the weaker path.
- */
-export type SyncTransport = 'auto' | 'broadcast' | 'storage' | 'inert';
-/** Names the transport a channel actually resolved to — `auto` is a request, never an answer. */
-export type ResolvedSyncTransport = Exclude<SyncTransport, 'auto'>;
-/** Defines the options that tune how a sync channel finds its peers. */
-export interface SyncChannelOptions {
-    /**
-     * Selects the delivery mechanism; defaults to `auto` (`broadcast` → `storage` → `inert`). An explicit choice
-     * that is unavailable in this environment degrades to the next one down rather than throwing.
-     */
-    readonly transport?: SyncTransport;
-    /** Supplies the persistence seam the `storage` fallback writes through; defaults to `localStorageStorageBroker`. */
-    readonly broker?: StorageBroker;
-    /** Prefixes the `storage` fallback's key, isolating one app's channels from another's; defaults to `wow-two.sync`. */
-    readonly keyPrefix?: string;
-    /** Pins this endpoint's tab id instead of minting one — for deterministic tie-breaks in tests. */
-    readonly id?: Guid;
-    /** Supplies the clock stamped onto each envelope; defaults to `Date.now`. */
-    readonly now?: () => number;
-}
-/**
- * Represents one tab's endpoint on a named cross-tab channel. Every method is total: posting on a closed
- * channel, subscribing after close, or running with no browser APIs at all are ordinary states that answer
- * quietly instead of throwing.
- */
-export interface SyncChannel<TMessage> {
-    /** Names the channel; every endpoint sharing this name on the origin is a peer. */
-    readonly name: string;
-    /** Identifies this endpoint (this tab) — stable for the channel's lifetime. */
-    readonly id: Guid;
-    /** Reports the mechanism this endpoint resolved to; `inert` means no peer will ever be reached. */
-    readonly transport: ResolvedSyncTransport;
-    /** Reports whether `close` has run — a closed channel neither sends nor delivers. */
-    readonly closed: boolean;
-    /** Sends `message` to every OTHER endpoint on the channel; never delivers to this one, and never throws. */
-    post(message: TMessage): void;
-    /** Registers `listener` for messages from other tabs; returns an idempotent disposer that unsubscribes it. */
-    subscribe(listener: SyncListener<TMessage>): () => void;
-    /** Detaches every listener and releases the underlying transport; idempotent. */
-    close(): void;
-}

package/dist/foundation/sync/UseBroadcastState.d.ts

@@ -1,31 +0,0 @@
-import { MaybeRefOrGetter, WritableComputedRef } from 'vue';
-import { SyncChannelOptions } from './SyncChannel';
-/** A setter accepting a next value or an updater fn. */
-export type SetBroadcastState<T> = (next: T | ((previous: T) => T)) => void;
-/** The mirrored-state handle — a writable value plus the explicit setter it delegates to. */
-export interface BroadcastStateControls<T> {
-    /**
-     * The mirrored value. Writable: `value.value = next` runs the same path as `setValue(next)`, so it drops
-     * straight into `v-model`. The updater-fn form is `setValue`'s alone — a `v-model` write is always a value.
-     */
-    readonly value: WritableComputedRef<T>;
-    /** Sets the next value locally and announces it to every peer. Accepts a value or an updater fn. */
-    readonly setValue: SetBroadcastState<T>;
-}
-/**
- * Manages a piece of reactive state mirrored live across every open tab, without persisting it anywhere.
- *
- * Setting the value here sets it in every other tab holding the same `key`; a tab that opens later asks its
- * peers for the current value on mount. Nothing is written to storage, so the value vanishes when the last tab
- * closes — read this file's header for the split with `usePersistentState`, which is the durable counterpart.
- *
- * SSR-safe: no channel is opened on the server, so the value is simply `initial` and the setter is local.
- *
- * @typeParam T - The mirrored value; must survive the transport (JSON-only on the `storage` fallback).
- * @param key - Identifies the shared value; tabs sharing it on this origin mirror each other. A ref or getter
- *   re-opens the channel on change.
- * @param initial - The value before any peer answers, and the value when no other tab is open. Read once.
- * @param options - Channel configuration, read once when the channel opens.
- * @returns The writable value and its setter.
- */
-export declare function useBroadcastState<T>(key: MaybeRefOrGetter<string>, initial: T, options?: SyncChannelOptions): BroadcastStateControls<T>;

package/dist/foundation/sync/UseLeaderElection.d.ts

@@ -1,25 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { Guid } from '../identifiers';
-import { LeaderElectionOptions } from './LeaderElection';
-/** Reports this tab's standing in an election, as reactive state. */
-export interface LeaderElectionState {
-    /** Reports whether this tab currently holds leadership; false before mount and under SSR. */
-    readonly isLeader: Readonly<ShallowRef<boolean>>;
-    /** Identifies this participant, or null before the election is joined (pre-mount, SSR). */
-    readonly id: Readonly<ShallowRef<Guid | null>>;
-    /** Surrenders leadership deliberately, handing over to a peer; a no-op when not leading. */
-    readonly release: () => void;
-}
-/**
- * Joins the named leader election for the lifetime of the scope, updating when this tab gains or loses
- * leadership.
- *
- * Exactly one participating tab leads at a time; a tab that dies is superseded once its lease expires. Use it to
- * elect the single tab that opens the socket, runs the poll, or shows the notification.
- *
- * @param name - Election name; tabs sharing it on this origin compete for one leadership. A ref or getter
- *   re-joins on change.
- * @param options - Timing and channel configuration, read once when the election is joined.
- * @returns The current standing plus `release`.
- */
-export declare function useLeaderElection(name: MaybeRefOrGetter<string>, options?: LeaderElectionOptions): LeaderElectionState;

package/dist/foundation/sync/UseSyncChannel.d.ts

@@ -1,16 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { SyncChannelOptions, SyncListener } from './SyncChannel';
-/**
- * Opens a cross-tab channel for the lifetime of the scope and subscribes `onMessage` to it.
- *
- * The returned `post` sends to every OTHER tab on the channel, never back into this one. Before mount and after
- * disposal — and under SSR, where no channel is ever opened — `post` is a silent no-op, so a handler firing at
- * an awkward moment needs no guard.
- *
- * @typeParam TMessage - The payload shape agreed between tabs.
- * @param name - Channel name; every tab using it on this origin is a peer. A ref or getter re-opens on change.
- * @param onMessage - Invoked for each message from another tab.
- * @param options - Transport and storage configuration, read once when the channel opens.
- * @returns The `post` function.
- */
-export declare function useSyncChannel<TMessage>(name: MaybeRefOrGetter<string>, onMessage?: SyncListener<TMessage>, options?: SyncChannelOptions): (message: TMessage) => void;

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

@@ -1,7 +0,0 @@
-export type { ResolvedSyncTransport, SyncChannel, SyncChannelOptions, SyncEnvelope, SyncListener, SyncTransport, } from './SyncChannel';
-export { createSyncChannel } from './CreateSyncChannel';
-export { memorySyncHub, type MemorySyncHub } from './MemorySyncHub';
-export { createLeaderElection, type LeaderElection, type LeaderElectionOptions, type LeaderRole, type LeaderSignal, } from './LeaderElection';
-export { useSyncChannel } from './UseSyncChannel';
-export { useLeaderElection, type LeaderElectionState } from './UseLeaderElection';
-export { useBroadcastState, type SetBroadcastState, type BroadcastStateControls } from './UseBroadcastState';