@mkbabb/glass-ui 6.0.0 → 8.0.0

package/dist/composables/motion/useSelectionGroup.d.ts

@@ -1,83 +0,0 @@
-import { type ComputedRef, type Ref } from "vue";
-import { type SelectionOption } from "./useSelectionIndicator";
-/**
- * useSelectionGroup — the library's ONE headless selection engine
- * (BI.W-DOCK-CONTROLS). The dock control run, `<SegmentedTabs>`, and
- * `<ToggleGroup type="single">` are the SAME thing — a roving-focus selection
- * strip with a traveling indicator. This composable assembles that ONE engine
- * from the parts that already exist (PASS-1 §2.4), reka-FREE + engine-free so it
- * ships on `/motion-core`:
- *
- *   • the SELECTION MODEL — `single` (a `string`) | `multiple` (a `string[]`),
- *     driven off a caller-owned `model` ref (no shadow registry — the ONE
- *     registry discipline);
- *   • the ROVING MACHINE — `useTabRovingFocus` composed VERBATIM (exactly-one-
- *     tabstop, axis-derived arrows, Home/End, wrap, disabled-skip);
- *   • the ONE TRAVELING-INDICATOR WRITER — `useSelectionIndicator` (the
- *     center-anchored ResizeObserver measure + the `--stretch` squish), so the
- *     dock/tabs/toggle-group indicator is Safari-identical by construction;
- *   • the RECENTER CALL — `el.scrollIntoView({inline:'nearest', block:'nearest'})`
- *     on every select (the FACILITY is W-DOCK-OVERFLOW's; the CALL lives here in
- *     the engine so a selection past the fold pulls itself into view).
- *
- * ROLE-PER-MODE rides the engine (the WAI-ARIA contract):
- *   • `radiogroup` — a single-select CHOOSER: `role="radio"` + `aria-checked`;
- *   • `tablist` — panel navigation: `role="tab"` + `aria-selected`;
- *   • `group` — N independent toggles: `aria-pressed` (no item `role`).
- */
-export type SelectionMode = "single" | "multiple";
-export type SelectionRole = "radiogroup" | "tablist" | "group";
-export interface UseSelectionGroupParams<O extends SelectionOption> {
-    /** The selectable options (index-aligned to `buttonRefs`). */
-    options: ComputedRef<O[]>;
-    /**
-     * The caller-owned selection model — the ONE registry (no shadow state). A
-     * `single`-mode group reads/writes a `string`; a `multiple`-mode group a
-     * `string[]`.
-     */
-    model: Ref<string | string[] | undefined>;
-    /** `single` (default) | `multiple`. */
-    mode?: ComputedRef<SelectionMode> | SelectionMode;
-    /**
-     * The ARIA role register — `radiogroup` (single chooser), `tablist` (panel
-     * navigation), or `group` (N toggles). Defaults to `radiogroup` for `single`
-     * and `group` for `multiple`.
-     */
-    role?: ComputedRef<SelectionRole> | SelectionRole;
-    /** True for the vertical (block-axis) orientation. */
-    vertical?: ComputedRef<boolean>;
-    /** The container scroller root (observed by the indicator's ResizeObserver). */
-    containerRef: Ref<HTMLElement | null>;
-    /**
-     * The traveling-indicator element (the `--stretch` squish target). Omit (or
-     * leave null) for a group with no glide indicator (e.g. a paper-hairline
-     * strip or a plain toggle row) — the squish/measure then no-ops.
-     */
-    indicatorRef?: Ref<HTMLElement | null>;
-    /** Per-option item refs, index-aligned to `options`. */
-    buttonRefs: Ref<HTMLElement[]>;
-}
-export interface UseSelectionGroupReturn {
-    /** The active option values (one for `single`, N for `multiple`). */
-    activeValues: ComputedRef<string[]>;
-    /** True when `value` is currently selected. */
-    isSelected: (value: string) => boolean;
-    /**
-     * Commit a selection at `idx` — writes the model (toggle in `multiple`),
-     * fires the travel-squish, and recenters the item via `scrollIntoView`.
-     */
-    select: (value: string, idx: number) => void;
-    /** The roving tabindex for option `idx` (`0` for the tabstop, `-1` else). */
-    rovingTabindex: (idx: number) => number;
-    /** The strip-root keydown handler (axis-derived arrows + Home/End). */
-    onKeydown: (e: KeyboardEvent) => void;
-    /** Inline style for the single-select traveling indicator (the ONE writer). */
-    singleSliderStyle: Ref<Record<string, string>>;
-    /** Imperatively kick the travel-squish on a selection at `idx`. */
-    squishOnTravel: (toIdx: number) => void;
-    /** The resolved group `role` (`radiogroup` | `tablist` | `group`). */
-    groupRole: ComputedRef<SelectionRole>;
-    /** The per-item ARIA attributes for `value`, role-per-mode. */
-    itemAttrs: (value: string) => Record<string, string>;
-}
-export declare function useSelectionGroup<O extends SelectionOption>(params: UseSelectionGroupParams<O>): UseSelectionGroupReturn;

package/dist/composables/motion/useSelectionIndicator.d.ts

@@ -1,90 +0,0 @@
-import { type Ref, type ComputedRef } from "vue";
-/**
- * useSelectionIndicator — the library's ONE traveling-indicator writer
- * (BI.W-DOCK-CONTROLS, promoted from the package-private `tabs/composables/
- * useTabIndicator.ts`). The dock IS SegmentedTabs/ToggleGroup wearing chrome
- * (PASS-1 §1 DOCK-D verdict), so the indicator that glides under the active
- * selection is factored ONCE here on `/motion-core` and consumed by every
- * selection surface (SegmentedTabs pill, the dock control run, the
- * ToggleGroup single-select arm) — never re-forked.
- *
- * THE ONE WRITER, SAFARI-IDENTICAL BY CONSTRUCTION (the C2 fold). The prior
- * dual path — a CSS `position-anchor` branch on supporting engines OR a JS
- * measured slider on the rest — meant Chrome and Safari rendered the indicator
- * through DIFFERENT code. This promotion RETIRES the CSS-anchor branch: the
- * indicator ALWAYS measures via `ResizeObserver` + a center-anchored transform,
- * so the same code paints the same pixels on every engine. There is exactly ONE
- * indicator writer in the library.
- *
- * It owns the JS-measured single-select slider style (the slider geometry, the
- * offset measure, the model/options re-measure watchers, the RO lifecycle) AND
- * the AX.W53 travel-squish: a velocity-driven, volume-preserving `--stretch`
- * scalar the active indicator reads so it STRETCHES along its travel axis as it
- * glides and settles to fit (the Material-3 ELASTIC / Apple Liquid-Glass
- * register, capped LOW). Honors `prefers-reduced-motion` (no squish under
- * reduce). The underline material SLIDES (no squish — a hairline does not
- * deform), gated by the caller passing no `indicatorRef` element.
- *
- * AXIS-DERIVED (the `vertical` param): the writer emits width/translateX on the
- * inline axis (horizontal) OR height/translateY on the block axis (vertical),
- * CENTER-ANCHORED (translate = buttonCenter − size/2) so the squish (which
- * scales from `transform-origin: center`) keeps the indicator center pinned to
- * the item center.
- *
- * Generic over the minimal `SelectionOption` shape (`value` + optional
- * `disabled`), so it is decoupled from any consumer's option type — the
- * `/motion-core` home carries no component-tree import.
- */
-/** The minimal option shape the indicator measures against. */
-export interface SelectionOption {
-    value: string;
-    disabled?: boolean;
-}
-/**
- * Fallback for `--tab-indicator-max-stretch` when the cascade leaves it unset —
- * the default travel-squish cap. `--stretch = 1 + frac · (cap − 1)`, so a
- * full-width jump reaches the cap and a tiny hop stays near 1. The token is the
- * authority; this is the no-token floor (the SOLE cap source, shared by the
- * click travel-squish AND the drag pull-morph — the constant + the token in
- * lockstep, never a fork).
- */
-export declare const DEFAULT_INDICATOR_MAX_STRETCH = 1.11;
-/**
- * Fallback for `--tab-indicator-blob-max` when the cascade leaves it unset: the
- * 5-beat blob's area-inflation overshoot peak. The 2nd `useLiquidFlex` channel
- * drives `--tab-blob` toward this on the grow-overshoot beat, then de-inflates
- * to 1 at arrival (shrink-to-fit). Kept LOW so the COMPOSED bbox area
- * (`blob × stretch` ≈ blob², the squish being volume-preserving) clears the
- * ≤ ~1.14 anti-taffy fence.
- */
-export declare const DEFAULT_INDICATOR_BLOB_MAX = 1.045;
-/**
- * The travel-progress fraction at which the squish RELEASES — the Material
- * "grow then shrink" close, keyed to ARRIVAL. The squish opens with the glide
- * and releases when the indicator is within this fraction of its target, so the
- * stretch peaks DURING travel and shrinks to fit AT arrival, never before.
- */
-export declare const INDICATOR_RELEASE_AT_ARRIVAL = 0.82;
-export interface UseSelectionIndicatorParams<O extends SelectionOption> {
-    /** The container scroller root (observed by the ResizeObserver). */
-    containerRef: Ref<HTMLElement | null>;
-    /** The active indicator element (the squish `--stretch` write target). */
-    indicatorRef: Ref<HTMLElement | null>;
-    /** Per-option item refs, index-aligned to `options`. */
-    buttonRefs: Ref<HTMLElement[]>;
-    /** The selectable options (re-measure on change). */
-    options: ComputedRef<O[]>;
-    /** The active value (re-measure on change). */
-    model: Ref<string | undefined>;
-    /** The active option values (used by the initial squish seed). */
-    activeValues: ComputedRef<string[]>;
-    /** True for the vertical (block-axis) orientation. */
-    vertical: ComputedRef<boolean>;
-}
-export interface UseSelectionIndicatorReturn {
-    /** Inline style for the single-select JS slider — the ONE writer. */
-    singleSliderStyle: Ref<Record<string, string>>;
-    /** Imperatively kick the travel-squish on a selection at `idx`. */
-    squishOnTravel: (toIdx: number) => void;
-}
-export declare function useSelectionIndicator<O extends SelectionOption>(params: UseSelectionIndicatorParams<O>): UseSelectionIndicatorReturn;

package/dist/composables/motion/useStaggerReveal.d.ts

@@ -1,52 +0,0 @@
-interface StaggerRevealConfig {
-    /** Delay between each target becoming `revealed`. Default 60ms. */
-    staggerMs?: number;
-    /** When true (default), a target stays revealed after first entering the viewport. */
-    once?: boolean;
-    /** IntersectionObserver rootMargin. Default `0px`. */
-    rootMargin?: string;
-    /** IntersectionObserver threshold. Default 0.15. */
-    threshold?: number;
-}
-/**
- * Sequence entrance animations for a list/grid. Each registered target
- * gets a staggered `revealed` flag once it crosses the viewport threshold.
- * Consumers bind the flag to a Tailwind class (e.g. `opacity-100 translate-y-0`)
- * and let CSS transitions handle the visual entry.
- *
- * AQ.W5: on an engine with native `view()` timelines, no `IntersectionObserver`
- * is constructed — prefer the `[data-scroll-reveal]` CSS recipe
- * (scroll-driven.css). This composable is the feature-detected fallback (the
- * sole writer when the native feature is absent); under native, `register()`
- * reveals immediately so the terminal state is correct and the CSS animates.
- */
-export declare function useStaggerReveal(options?: StaggerRevealConfig): {
-    targets: import("vue").Ref<HTMLElement[], HTMLElement[]>;
-    register: (el: HTMLElement | null, index?: number) => void;
-    revealed: Record<number, boolean>;
-};
-/**
- * The `[data-scroll-reveal-once]` latch — BC.W-MOTION-PRESETS.
- *
- * The `scroll-driven.css` `[data-scroll-reveal]` recipe rides a native `view()`
- * timeline that RE-FIRES its entrance every time a child re-enters the entry range
- * — wrong for a virtualized/teleporting list (a row scrolls out + back and re-plays
- * the fade-lift). A `view()` timeline cannot latch "play once" (the CSS limit), so
- * the `[data-scroll-reveal-once]` opt-in plays the entrance ONCE: this directive
- * adds `data-revealed=""` to each child on its FIRST cross and `unobserve`s it (the
- * SAME `once: true` discipline `useStaggerReveal` runs above — `if (once)
- * observer?.unobserve(el)`); the CSS plays the one-shot `gl-reveal-once` keyframe
- * keyed off `[data-revealed]`, NOT the live `view()` range. NO second observer
- * engine — the same `IntersectionObserver` the composable speaks for the `once`
- * case, packaged as a Vue directive a consumer binds on the scroller.
- *
- * On an engine without `IntersectionObserver` (SSR/old) it reveals immediately so
- * the terminal state is correct (the CSS animation simply never plays). Under PRM
- * the scroll-driven.css `@media` outer gate drops the entrance and the row paints
- * in-place (a flourish — the reveal carve, not a legibility cue).
- */
-export declare const vScrollRevealOnce: {
-    mounted(scroller: HTMLElement): void;
-    unmounted(scroller: HTMLElement): void;
-};
-export {};

package/dist/composables/motion/useTextHighlight.d.ts

@@ -1,41 +0,0 @@
-/** Match a query against a text-node's content, returning matched char ranges. */
-export type HighlightMatcher = (
-/** The text-node's full string content. */
-text: string, 
-/** The active query (already passed through to the matcher unchanged). */
-query: string) => Array<{
-    start: number;
-    end: number;
-}>;
-export interface UseTextHighlightControls {
-    /** Replace the highlight's range set. Empty array clears the paint. */
-    set: (ranges: Range[]) => void;
-    /**
-     * Walk every text node under `container`, run `matcher` per node, and
-     * highlight the returned `[start, end)` char spans. Replaces the prior set.
-     * The default matcher is a case-insensitive substring scan over `query`.
-     */
-    setFromMatches: (container: HTMLElement, query: string, matcher?: HighlightMatcher) => void;
-    /** Drop every range — the named highlight stops painting. */
-    clear: () => void;
-    /** True when the CSS Custom Highlight API is available (else every op no-ops). */
-    readonly supported: boolean;
-}
-/**
- * Drive a named CSS Custom Highlight reactively.
- *
- * @param name registry key — must match a caller-owned
- *   `::highlight(<name>)` style rule. This low-level API does not inject CSS.
- *   Instances sharing a name multiplex: each contributes its own ranges and
- *   the shared paint is their union (last to dispose drops the registry entry).
- *
- * @example
- * const hl = useTextHighlight("fuzzy-search");
- * watch([query, listEl], ([q, el]) => {
- *     if (el) hl.setFromMatches(el, q, fuzzyRanges);
- * });
- *
- * // Or hand it pre-built ranges directly:
- * hl.set([range]);
- */
-export declare function useTextHighlight(name: string): UseTextHighlightControls;

package/dist/composables/motion/useViewTransition.d.ts

@@ -1,81 +0,0 @@
-/** Options for `startViewTransition`. `types` (Chrome 140+, absent on Firefox
- *  144) tag the active transition so `:active-view-transition-type(<t>)` CSS can
- *  author DIRECTION-specific curves. Feature-detected — when the engine lacks the
- *  object-with-`types` overload the call degrades to the plain-callback form
- *  (one symmetric curve), which is functionally identical (the swap still runs). */
-export interface ViewTransitionOptions {
-    types?: string[];
-    /**
-     * BA.W-ATLAS-RECONCILE A-4b — take the JS-level INSTANT path under
-     * `prefers-reduced-motion: reduce` (run `mutate` directly, NO snapshot
-     * captured). The HEAD default pushes PRM to CSS only (`view-transition.css`
-     * sets `animation: none` on the VT pseudos) — but that STILL captures a
-     * snapshot. For the navigation case a reduced-motion user wants the swap to
-     * happen with no transition machinery at all; `navigate()` sets this true.
-     * Defaults to `false` so the existing sync-VT consumers (muster J.W5 row
-     * re-rank) keep their exact CSS-handled PRM behaviour. @default false
-     */
-    instantUnderReducedMotion?: boolean;
-}
-export interface ViewTransitionResult {
-    /**
-     * Resolves when the transition's `finished` promise settles (or
-     * immediately in the fallback path). Use to route focus per the a11y
-     * MANDATORY: `await startViewTransition(mutate).finished; el.focus()`.
-     * Never rejects — a skipped/aborted transition settles cleanly.
-     */
-    finished: Promise<void>;
-    /** True when the native API ran; false when the instant fallback ran. */
-    transitioned: boolean;
-}
-/**
- * True when `document.startViewTransition` is available — the feature-detected
- * predicate consumers gate optional VT-only styling on.
- */
-export declare function supportsViewTransitions(): boolean;
-/**
- * Wrap a synchronous DOM mutation in `document.startViewTransition` with an
- * instant fallback. `mutate` performs the DOM/state change and is called
- * synchronously in BOTH paths (native and fallback), so the post-mutation DOM
- * is identical regardless of support.
- *
- * @param mutate the synchronous DOM/state change to animate between.
- * @param options optional `{ types }` — directional transition types tagged on
- *   the active transition for `:active-view-transition-type(<t>)` CSS curves
- *   (Chrome 140+; feature-detected, degrades to one symmetric curve elsewhere).
- * @returns `{ finished, transitioned }` — await `finished` to route focus.
- *
- * @example
- *   const { finished } = startViewTransition(() => { rows.value = reranked });
- *   await finished;            // animation done
- *   firstRow.value?.focus();   // consumer routes focus (the a11y MANDATORY)
- *
- * @example
- *   // directional intent — snappier exit on collapse, softer entry on expand
- *   startViewTransition(() => mutate(), { types: ["dock-expand"] });
- */
-export declare function startViewTransition(mutate: () => void | Promise<void>, options?: ViewTransitionOptions): ViewTransitionResult;
-/** Options for `navigate` — the directional transition `types` (Chrome 140+,
- *  feature-detected; tag `["forward"]`/`["back"]` off the navigation direction). */
-export type NavigateOptions = ViewTransitionOptions;
-/**
- * Run a (possibly ASYNC) navigation callback wrapped in a View Transition, with
- * the reduced-motion + unsupported instant-paths. The navigation ALWAYS runs
- * (awaited); the morph is conditional on support + motion preference. Returns the
- * same `{ finished, transitioned }` contract — `await navigate(go).finished` then
- * route focus (the a11y MANDATORY).
- *
- * @example  the card → masthead route morph
- *   // both the card title + masthead title carry
- *   //   view-transition-class: gl-shared-element; view-transition-name: dash-title
- *   await navigate(() => router.push(`/${slug}`), { types: ["forward"] }).finished;
- *   mastheadTitle.value?.focus();
- */
-export declare function navigate(nav: () => void | Promise<void>, options?: NavigateOptions): ViewTransitionResult;
-/**
- * True when the route-transition morph can run (native VT available). A consumer
- * gates VT-only navigation styling on this (alias of `supportsViewTransitions`
- * named for the navigation call site). Under reduced motion the `navigate` helper
- * still takes the instant path even when this is `true`.
- */
-export declare function supportsRouteTransitions(): boolean;

package/dist/composables/virtual/index.d.ts

@@ -1,4 +0,0 @@
-export { useVirtualSectionWindow, clearSessionHeightCache, } from "./useVirtualSectionWindow";
-export { useWindowedStore } from "./useWindowedStore";
-export { buildSectionLayout, findSectionOffset, resolveActiveSection, resolveSectionWindow, } from "./virtualSectionLayout";
-export type { FlatSection, SectionLayout, SectionWindowRange, ForcedSectionWindowRange, } from "./virtualSectionLayout";

package/dist/composables/virtual/useVirtualSectionWindow.d.ts

@@ -1,72 +0,0 @@
-import { type MaybeRefOrGetter, type Ref } from "vue";
-import type { FlatSection } from "./virtualSectionLayout";
-/**
- * Lineage: a glass-ui primitive at v0.9.4, retired at v1.0 (MIGRATION.md §3.2),
- * carried on as a verbatim transposed copy in the words app, and HOME again at
- * BC (the live words consumer + the dock-search results list overturn the
- * no-consumer retirement verdict). Byte-faithful to the proven words copy save
- * the recorded refinements: the container/content ResizeObservers route through
- * the house `useResizeObserver` leaf (cleanup discipline) instead of raw
- * `new ResizeObserver`, and `findSectionOffset` is the binary-search variant.
- */
-interface VirtualWindowConfig<T extends FlatSection = FlatSection> {
-    /** The flat list of section items to virtualize. */
-    items: MaybeRefOrGetter<readonly T[]>;
-    /**
-     * The element whose scroll position drives the window.
-     * `null` = use `window` / document scroll.
-     */
-    scrollContainer: Ref<HTMLElement | null>;
-    /**
-     * The wrapper element around the virtualized content.
-     * When provided, scroll offset is computed relative to this element's
-     * position in the page, so content above it (headers, images, etc.)
-     * is correctly excluded from the layout calculation.
-     */
-    contentEl?: Ref<HTMLElement | null>;
-    /** Overscan before the viewport in pixels. Default: viewport height. */
-    overscanBeforePx?: number;
-    /** Overscan after the viewport in pixels. Default: 2x viewport height. */
-    overscanAfterPx?: number;
-    /** Number of items to warm before a target when using `ensureTargetWindow`. Default: 2. */
-    warmTargetBefore?: number;
-    /** Number of items to warm after a target when using `ensureTargetWindow`. Default: 3. */
-    warmTargetAfter?: number;
-}
-/**
- * Evict every cached measured section height. The documented escape for a
- * consumer that wants to drop the module-global `SESSION_HEIGHT_CACHE` (a
- * font-size change, a layout reflow that invalidates prior measurements).
- */
-export declare function clearSessionHeightCache(): void;
-/**
- * Scroll-based virtual windowing composable for section lists.
- *
- * Renders only the items visible in (or near) the scroll viewport,
- * using spacer divs to maintain correct scroll height. Supports:
- *
- * - Measured heights: call `measureSection(id, el)` from a template ref
- *   to replace estimated heights with real DOM measurements.
- * - Warm targeting: call `ensureTargetWindow(id)` to force an item into
- *   the render window before scrolling to it (auto-releases after 320ms).
- * - Active tracking: `activeId` / `activeRootId` report which section
- *   is currently at the 20% viewport mark. NOTE — this is the windowing-LOCAL
- *   render-active reader; a ToC/sidebar consumer reads `useScrollTracker`'s
- *   `activeId` (the deepest-visible reader) for the binding highlight. The two
- *   serve distinct concerns and are deliberately NOT one function
- *   (BC.W-VIRTUAL-WINDOW active-section reconcile).
- * - Content offset: provide `contentEl` to correctly handle non-virtualized
- *   content (headers, banners) above the virtual list.
- */
-export declare function useVirtualSectionWindow<T extends FlatSection>(options: VirtualWindowConfig<T>): {
-    visibleItems: import("vue").ComputedRef<T[]>;
-    topSpacerPx: import("vue").ComputedRef<number>;
-    bottomSpacerPx: import("vue").ComputedRef<number>;
-    measureSection: (id: string, el: HTMLElement | null) => void;
-    ensureTargetWindow: (id: string) => void;
-    getOffsetFor: (id: string) => number | null;
-    activeId: import("vue").ComputedRef<any>;
-    activeRootId: import("vue").ComputedRef<any>;
-    recalculate: () => void;
-};
-export {};

package/dist/composables/virtual/useWindowedStore.d.ts

@@ -1,43 +0,0 @@
-import { type Ref, type ShallowRef } from "vue";
-/**
- * Lineage: a glass-ui primitive at v0.9.4, retired at v1.0 (MIGRATION.md §3.3),
- * carried on as a verbatim transposed copy in the words app, and HOME again at
- * BC (the words wordlist store is the live consumer the no-consumer retirement
- * verdict missed). Byte-faithful to the proven words copy — the
- * generation-counter stale-append rejection is the load-bearing concurrency
- * primitive, preserved verbatim.
- */
-interface ResidentWindowConfig {
-    /** Maximum items to keep in memory. Default: 200. */
-    maxResident?: number;
-}
-interface ResidentWindowState<T> {
-    /** Currently loaded items (a sliding window of the full list). */
-    items: ShallowRef<T[]>;
-    /** Logical offset of `items[0]` in the full list. */
-    windowStart: Ref<number>;
-    /** Generation counter -- increments on each reset. Used to reject stale appends. */
-    generation: Ref<number>;
-    /** Append or replace items. `replace=true` resets window; `replace=false` appends with eviction from front. */
-    set(newItems: T[], replace?: boolean): void;
-    /** Prepend items before the current window. Evicts from the end if over `maxResident`. */
-    prepend(newItems: T[], newWindowStart: number): void;
-    /** Clear all items and reset window. */
-    clear(): void;
-    /**
-     * Append items only if the generation matches (i.e., no reset happened since the fetch started).
-     * Returns `true` if the append was accepted, `false` if rejected (stale).
-     */
-    appendIfCurrent(newItems: T[], expectedGeneration: number): boolean;
-}
-/**
- * Sliding-window store primitive for paginated / infinite-scroll data.
- *
- * Supports both forward (append) and backward (prepend) loading.
- * When items exceed `maxResident`, trims from the opposite end.
- *
- * Uses a generation counter to reject stale appends after a backward reset,
- * preventing race conditions between concurrent page fetches.
- */
-export declare function useWindowedStore<T>(options?: ResidentWindowConfig): ResidentWindowState<T>;
-export {};

package/dist/composables/virtual/virtualSectionLayout.d.ts

@@ -1,103 +0,0 @@
-/**
- * Pure layout computation functions for virtual section scrolling.
- *
- * These are stateless — they take data in, return layout info out.
- * No Vue reactivity, no DOM access.
- *
- * Lineage: this engine was a glass-ui primitive at v0.9.4, retired at v1.0
- * (MIGRATION.md §3.4 — "0 production consumers, demo-only"), and lived on as
- * a verbatim transposed copy in the words app. The retirement is REVERSED at
- * BC: the live words consumer + the dock-search results list overturn the
- * no-consumer verdict, so the windowing engine comes HOME. Byte-faithful to
- * the proven words copy except the one functional refinement recorded below
- * (`findSectionOffset` binary search) and the shared-hierarchy type-reconcile.
- */
-import type { SectionHierarchy } from "../sidebar/types";
-/**
- * A flattened section item with hierarchy metadata for virtual scrolling.
- *
- * The four hierarchy fields (`depth`/`rootId`/`parentId`/`rootIndex`) come
- * from the shared `SectionHierarchy` base (`composables/sidebar/types`) — the
- * same fields the sidebar's `TreeIndexEntry` carries, declared ONCE. The
- * producer (`flattenPaperSections` in latex-paper, the dock-search result
- * flattener) builds these in the consumer; glass-ui owns only the contract.
- */
-export interface FlatSection extends SectionHierarchy {
-    id: string;
-    index: number;
-    estimatedHeight: number;
-}
-/** A single entry in a computed section layout with resolved position. */
-interface VirtualLayoutEntry<T extends FlatSection = FlatSection> {
-    item: T;
-    height: number;
-    top: number;
-    bottom: number;
-}
-/** Complete layout for a list of sections — entries plus total height. */
-export interface SectionLayout<T extends FlatSection = FlatSection> {
-    entries: VirtualLayoutEntry<T>[];
-    totalHeight: number;
-    /**
-     * Entry slots sorted ascending by `item.id`, so `findSectionOffset` can
-     * binary-search an arbitrary string id in O(log n) (the words copy
-     * linear-scanned `entries` — `virtualSectionLayout.ts:244-252`). Built
-     * once in `buildSectionLayout`; the `top` is read straight off the matched
-     * entry, so the offset answer is byte-identical to the linear scan.
-     */
-    byId: VirtualLayoutEntry<T>[];
-}
-/** The visible window range with spacer sizes for virtual scrolling. */
-export interface SectionWindowRange {
-    startIndex: number;
-    endIndex: number;
-    topSpacerPx: number;
-    bottomSpacerPx: number;
-}
-/** A forced index range that must be included in the visible window. */
-export interface ForcedSectionWindowRange {
-    startIndex: number;
-    endIndex: number;
-}
-/**
- * Build a layout from a flat list of sections using a height resolver.
- *
- * Each entry gets an absolute `top` and `bottom` offset in pixels,
- * computed sequentially from index 0. Heights are rounded and clamped >= 1.
- */
-export declare function buildSectionLayout<T extends FlatSection>(items: readonly T[], getHeight: (item: T) => number): SectionLayout<T>;
-/**
- * Resolve which section indices are visible given scroll state.
- *
- * Uses binary search for O(log n) lookup. Overscan extends the window
- * before and after the viewport. An optional `forcedRange` guarantees
- * certain indices are always included (used for warm-up targeting).
- */
-export declare function resolveSectionWindow<T extends FlatSection>(layout: SectionLayout<T>, scrollTopPx: number, viewportHeightPx: number, overscanBeforePx: number, overscanAfterPx: number, forcedRange?: ForcedSectionWindowRange | null): SectionWindowRange;
-/**
- * Find the section that is "active" at a given scroll offset.
- *
- * Returns the last section whose top edge is at or before `activeOffsetPx`.
- *
- * NOTE — this is the windowing-LOCAL render-active reader (the section at the
- * 20%-viewport mark, used to label the current render window). It is NOT the
- * ToC's binding active-section reader: a sidebar/ToC consumer reads
- * `useScrollTracker.activeId` (the deepest-visible reader) for the highlight.
- * The two serve distinct concerns and are deliberately NOT one function
- * (BC.W-VIRTUAL-WINDOW active-section reconcile).
- */
-export declare function resolveActiveSection<T extends FlatSection>(layout: SectionLayout<T>, activeOffsetPx: number): T | null;
-/**
- * Find the pixel offset of a section by its `id`.
- * Returns `null` if the section is not in the layout.
- *
- * REFINEMENT (BC.W-VIRTUAL-WINDOW): the words copy linear-scans `entries`
- * matching on `id` (O(n), `virtualSectionLayout.ts:244-252`). Here we binary
- * search `layout.byId` — the entries sorted ascending by `item.id` in
- * `buildSectionLayout` — which is a total order over the string ids, so the
- * search is correct + O(log n). The `top` is read straight off the matched
- * entry, so the answer is byte-identical to the linear scan (the fixture pins
- * this over a 1000-item layout).
- */
-export declare function findSectionOffset<T extends FlatSection>(layout: SectionLayout<T>, id: string): number | null;
-export {};

package/dist/controls.d.ts

@@ -1 +0,0 @@
-export * from "./components/controls";

package/dist/controls.js

@@ -1,83 +0,0 @@
-import { t as e } from "./class-names-5jotTFzp.js";
-import { t } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { i as n } from "./dark-DIH-blY1.js";
-import { computed as r, createElementBlock as i, createStaticVNode as a, defineComponent as o, mergeProps as s, onBeforeUnmount as c, openBlock as l, ref as u, useAttrs as d, watch as f, watchEffect as p } from "vue";
-import { useMediaQuery as m } from "@vueuse/core";
-//#region src/components/controls/DarkModeToggle.vue?vue&type=script&setup=true&lang.ts
-var h = ["data-size", "data-eclipsing"], g = /* @__PURE__ */ t(/* @__PURE__ */ o({
-	inheritAttrs: !1,
-	__name: "DarkModeToggle",
-	props: {
-		size: { default: "md" },
-		disableTransitions: {
-			type: Boolean,
-			default: !1
-		},
-		eclipse: {
-			type: Boolean,
-			default: !1
-		}
-	},
-	setup(t) {
-		let o = t, g = d(), _ = u(!1), v = m("(prefers-reduced-motion: reduce)"), y = null, b = null, x = !1;
-		function S() {
-			y !== null && (clearTimeout(y), y = null);
-		}
-		function C() {
-			b !== null && (clearTimeout(b), b = null), _.value = !1;
-		}
-		function w() {
-			o.eclipse && (x = !1, S(), y = setTimeout(() => {
-				x = !0, y = null, v.value || (_.value = !0, b = window.setTimeout(C, 1700)), j();
-			}, 460));
-		}
-		function T() {
-			S();
-		}
-		function E(e) {
-			e.key === " " && !e.repeat && w();
-		}
-		function D(e) {
-			e.key === " " && T();
-		}
-		function O(e) {
-			if (o.eclipse && x) {
-				e.preventDefault(), e.stopPropagation(), x = !1;
-				return;
-			}
-			j();
-		}
-		f(v, (e) => {
-			e && C();
-		}), c(() => {
-			S(), C();
-		});
-		let k = r(() => e("dark-mode-toggle-button", "relative isolate inline-flex shrink-0 items-center justify-center", "cursor-pointer border-0 bg-transparent", "rounded-pill", "opacity-80", "focus-ring", g.class)), { isDark: A, toggleDark: j, setDisableTransitions: M } = n(), N = r(() => {
-			let { class: e, type: t, ...n } = g;
-			return {
-				"aria-label": A.value ? "Switch to light mode" : "Switch to dark mode",
-				"aria-pressed": A.value,
-				...n
-			};
-		});
-		return p(() => {
-			M(o.disableTransitions);
-		}), (e, n) => (l(), i("button", s({
-			type: "button",
-			class: k.value,
-			"data-size": o.size,
-			"data-eclipsing": t.eclipse && _.value ? "true" : void 0
-		}, N.value, {
-			onClick: O,
-			onPointerdown: w,
-			onPointerup: T,
-			onPointerleave: T,
-			onPointercancel: T,
-			onKeydown: E,
-			onKeyup: D,
-			onBlur: T
-		}), [...n[0] ||= [a("<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 472.39 472.39\" class=\"block h-full w-full fill-foreground\" data-v-82cc93de><g class=\"toggle-sun\" data-allow-motion data-v-82cc93de><path d=\"M403.21,167V69.18H305.38L236.2,0,167,69.18H69.18V167L0,236.2l69.18,69.18v97.83H167l69.18,69.18,69.18-69.18h97.83V305.38l69.18-69.18Zm-167,198.17a129,129,0,1,1,129-129A129,129,0,0,1,236.2,365.19Z\" data-v-82cc93de></path></g><g class=\"toggle-circle\" data-allow-motion data-v-82cc93de><circle cx=\"236.2\" cy=\"236.2\" r=\"90\" data-v-82cc93de></circle></g></svg>", 1)]], 16, h));
-	}
-}), [["__scopeId", "data-v-82cc93de"]]);
-//#endregion
-export { g as DarkModeToggle };