@astralarium/repo-ui 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Astralarium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,7 @@
-# Temporary Holding Version
+# `@astralarium/repo-ui`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Headless React UI following Base UI patterns.
+
+App setup:
+
+- `themeScript(cookie)` in `<head>` to apply theme pre-paint.

package/dist/dev-route.d.ts

@@ -0,0 +1,29 @@
+import { type RouteComponent } from "@tanstack/react-router";
+import type { ReactNode } from "react";
+/** A dev page module: its default export renders the page. */
+export interface DevPageModule {
+    default: () => ReactNode;
+}
+/**
+ * The page module's loader, or `false` once the build compiled it out.
+ * Call sites write `import.meta.env.DEV && (() => import("~dev/…"))`: the
+ * literal guard satisfies `dev-only/imports`, and `vite build` folds it
+ * to `false`.
+ */
+export type DevPageLoad = false | (() => Promise<DevPageModule>);
+/** How a dev page renders. */
+export interface DevRouteOptions {
+    /** Render in the browser only (`ssr: false`): canvas scenes. */
+    clientOnly?: boolean;
+}
+/** TanStack route options; spread beside `validateSearch` and the like. */
+export interface DevRoute {
+    /** Throws `notFound()` where the page was compiled out. */
+    beforeLoad: () => void;
+    /** The lazily loaded page; renders nothing where compiled out. */
+    component: RouteComponent;
+    /** `false` with `clientOnly`; absent otherwise. */
+    ssr?: false;
+}
+/** Route options for the dev page `load` loads; a 404 where compiled out. */
+export declare function devRoute(load: DevPageLoad, { clientOnly }?: DevRouteOptions): DevRoute;

package/dist/dev-route.js

@@ -0,0 +1,15 @@
+import { lazyRouteComponent, notFound } from "@tanstack/react-router";
+/** Route options for the dev page `load` loads; a 404 where compiled out. */
+export function devRoute(load, {
+  clientOnly = false
+} = {}) {
+  return {
+    beforeLoad: () => {
+      if (!load) throw notFound();
+    },
+    component: load ? lazyRouteComponent(load) : () => null,
+    ...(clientOnly ? {
+      ssr: false
+    } : {})
+  };
+}

package/dist/error-boundary.d.ts

@@ -0,0 +1,29 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+/** `ErrorBoundary` props. */
+export interface ErrorBoundaryProps {
+    /** A change clears a caught fault and renders `children` afresh. */
+    resetKey: string;
+    /** Shown in place of `children` after a fault. */
+    fallback: ReactNode;
+    /** Reports each caught fault. */
+    onCatch?: (error: unknown, info: ErrorInfo) => void;
+    children: ReactNode;
+}
+interface ErrorBoundaryState {
+    /** The caught fault, boxed: a thrown value may be falsy. */
+    caught: {
+        error: unknown;
+    } | null;
+    /** The `resetKey` the fault belongs to. */
+    resetKey: string;
+}
+/** Catches render faults below, showing `fallback` until `resetKey`
+ *  changes. */
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: unknown): Partial<ErrorBoundaryState>;
+    static getDerivedStateFromProps(props: ErrorBoundaryProps, state: ErrorBoundaryState): Partial<ErrorBoundaryState> | null;
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+export {};

package/dist/error-boundary.js

@@ -0,0 +1,30 @@
+"use client";
+
+import { Component } from "react";
+/** Catches render faults below, showing `fallback` until `resetKey`
+ *  changes. */
+export class ErrorBoundary extends Component {
+  state = {
+    caught: null,
+    resetKey: this.props.resetKey
+  };
+  static getDerivedStateFromError(error) {
+    return {
+      caught: {
+        error
+      }
+    };
+  }
+  static getDerivedStateFromProps(props, state) {
+    return props.resetKey === state.resetKey ? null : {
+      caught: null,
+      resetKey: props.resetKey
+    };
+  }
+  componentDidCatch(error, info) {
+    this.props.onCatch?.(error, info);
+  }
+  render() {
+    return this.state.caught ? this.props.fallback : this.props.children;
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/** Headless React building blocks: theme, tree, page tree, timeline, sorted
+ *  lookups, status, error boundary, storage and small hooks. */
+export * from "./error-boundary.tsx";
+export * from "./page-tree.ts";
+export * from "./sorted.ts";
+export * from "./status.tsx";
+export * from "./storage.ts";
+export * from "./theme/index.ts";
+export * from "./timeline.ts";
+export * from "./tree/index.ts";
+export * from "./use-copy-feedback.ts";
+export * from "./use-frame.ts";
+export * from "./use-hover-focus.ts";
+export * from "./use-media-query.ts";
+export * from "./use-pausable-hover.ts";
+export * from "./use-pulse-style.ts";

package/dist/index.js

@@ -0,0 +1,16 @@
+/** Headless React building blocks: theme, tree, page tree, timeline, sorted
+ *  lookups, status, error boundary, storage and small hooks. */
+export * from "./error-boundary.js";
+export * from "./page-tree.js";
+export * from "./sorted.js";
+export * from "./status.js";
+export * from "./storage.js";
+export * from "./theme/index.js";
+export * from "./timeline.js";
+export * from "./tree/index.js";
+export * from "./use-copy-feedback.js";
+export * from "./use-frame.js";
+export * from "./use-hover-focus.js";
+export * from "./use-media-query.js";
+export * from "./use-pausable-hover.js";
+export * from "./use-pulse-style.js";

package/dist/l10n/repo-ui/en.json

@@ -0,0 +1,10 @@
+{
+  "@astralarium/repo-ui/slider/slider.messages#rangeEnd": {
+    "defaultMessage": "{value}, range end",
+    "description": "Spoken value of a range slider's last thumb. Shows: screen readers, sliders with several thumbs. Arguments: value (string) the thumb's formatted value."
+  },
+  "@astralarium/repo-ui/slider/slider.messages#rangeStart": {
+    "defaultMessage": "{value}, range start",
+    "description": "Spoken value of a range slider's first thumb. Shows: screen readers, sliders with several thumbs. Arguments: value (string) the thumb's formatted value."
+  }
+}

package/dist/page-tree.d.ts

@@ -0,0 +1,25 @@
+/** The router's static paths as a tree, and a breadcrumb trail through it. */
+/** A static path: a page, an ancestor of pages, or both. */
+export interface PageNode {
+    /** The path's last segment; empty at the root. */
+    segment: string;
+    /** The path from the root. */
+    path: string;
+    /** A page serves `path`. */
+    page: boolean;
+    /** Static paths one segment deeper, in first-given order. */
+    children: PageNode[];
+}
+/** One path segment of the trail. */
+export interface Crumb {
+    /** The path through this segment. */
+    path: string;
+    /** The static paths beside `path`, itself included; only itself for
+     *  the trail's first crumb; empty off the tree. */
+    siblings: PageNode[];
+}
+/** `paths` as a tree rooted at `/`. Paths with a param or splat segment
+ *  (`$`) are left out. */
+export declare function pageTree(paths: Iterable<string>): PageNode;
+/** `pathname`'s segments, located in `tree`. */
+export declare function crumbsOf(pathname: string, tree: PageNode): Crumb[];

package/dist/page-tree.js

@@ -0,0 +1,45 @@
+/** The router's static paths as a tree, and a breadcrumb trail through it. */
+/** `paths` as a tree rooted at `/`. Paths with a param or splat segment
+ *  (`$`) are left out. */
+export function pageTree(paths) {
+  const root = {
+    segment: "",
+    path: "/",
+    page: false,
+    children: []
+  };
+  for (const path of paths) {
+    const segments = path.split("/").filter(Boolean);
+    if (segments.some(segment => segment.includes("$"))) continue;
+    let node = root;
+    for (const segment of segments) {
+      let child = node.children.find(c => c.segment === segment);
+      if (!child) {
+        child = {
+          segment,
+          path: `${node === root ? "" : node.path}/${segment}`,
+          page: false,
+          children: []
+        };
+        node.children.push(child);
+      }
+      node = child;
+    }
+    node.page = true;
+  }
+  return root;
+}
+/** `pathname`'s segments, located in `tree`. */
+export function crumbsOf(pathname, tree) {
+  const segments = pathname.split("/").filter(Boolean);
+  let parent;
+  let node = tree;
+  return segments.map((segment, i) => {
+    parent = node;
+    node = parent?.children.find(c => c.segment === segment);
+    return {
+      path: `/${segments.slice(0, i + 1).join("/")}`,
+      siblings: !node ? [] : i > 0 && parent ? parent.children : [node]
+    };
+  });
+}

package/dist/slider/index.d.ts

@@ -0,0 +1,8 @@
+/** Sliders and scrubbers over Base UI: parts, state and timeline scrubbing. */
+export * from "./scrubber.tsx";
+export type { ScrubberStep, ScrubberTick } from "./scrubber-state.ts";
+export * from "./slider.tsx";
+export * from "./slider-parts.ts";
+export { type SliderContextValue, type SliderFill, type SliderSpan, type SliderTickLight, useSlider, useSliderTick, } from "./slider-state.ts";
+export * from "./timeline-scrubber.tsx";
+export { type TimelineMark, timelineNames } from "./timeline-scrubber-state.ts";

package/dist/slider/index.js

@@ -0,0 +1,7 @@
+/** Sliders and scrubbers over Base UI: parts, state and timeline scrubbing. */
+export * from "./scrubber.js";
+export * from "./slider.js";
+export * from "./slider-parts.js";
+export { useSlider, useSliderTick } from "./slider-state.js";
+export * from "./timeline-scrubber.js";
+export { timelineNames } from "./timeline-scrubber-state.js";

package/dist/slider/scrubber-state.d.ts

@@ -0,0 +1,118 @@
+/** Scrubber rules: tick groups, landing, stepping, lighting, reach,
+ *  and the split fill. */
+import type { Slider as SliderPrimitive } from "@base-ui/react/slider";
+import type { ReactNode } from "react";
+import type { SliderSpan } from "./slider-state.ts";
+/** A position along a scrubber's track: a snap and step target. Named
+ *  or glyphed, a mark, always drawn; bare, a stop, drawn faintly near
+ *  the pointer. */
+export interface ScrubberTick {
+    value: number;
+    /** Tooltip and spoken text; names sharing a value list together. */
+    name?: string;
+    /** Drawn at the tick; the lowest-ranked glyph at a value draws. Its
+     *  mark carries the thumb's reach along the fill as `data-reach`:
+     *  `ahead` short of the mark, `held` on it or within the hold window
+     *  past it, `past` beyond. */
+    glyph?: ReactNode;
+    /** Lower draws over higher at a shared value; ties keep order. */
+    rank?: number;
+}
+/** The ticks at one value. */
+export interface ScrubberTickGroup {
+    value: number;
+    /** The named or glyphed ticks, most prominent first; none for a
+     *  stop. */
+    marks: readonly ScrubberTick[];
+    /** The marks' names, most prominent first. */
+    names: readonly string[];
+}
+/** `ticks` grouped by value, ascending. */
+export declare function groupTicks(ticks: readonly ScrubberTick[]): ScrubberTickGroup[];
+/** The names of the `groups` at `value`, most prominent first. */
+export declare function tickNames(groups: readonly ScrubberTickGroup[], value: number): readonly string[];
+/** The names of the latest of `groups` at or before `value`, most
+ *  prominent first. */
+export declare function latestNames(groups: readonly ScrubberTickGroup[], value: number): readonly string[];
+/** A key step: `by` toward `max` (1) or `min` (-1), resolved for
+ *  orientation and direction; `large` with Shift or PageUp/PageDown. */
+export interface ScrubberStep {
+    by: -1 | 1;
+    large: boolean;
+}
+/** Where a step from `from` lands: the adjacent tick; a large step's
+ *  the adjacent mark, or tick where none is a mark. Undefined past the
+ *  outermost. */
+export declare function stepTick(groups: readonly ScrubberTickGroup[], from: number, { by, large }: ScrubberStep): number | undefined;
+/** The ticks and range landings snap within. */
+export interface ScrubberGrid {
+    groups: readonly ScrubberTickGroup[];
+    min: number;
+    max: number;
+    /** How near a tick a landing snaps to it. */
+    snapWindow: number;
+}
+/** Where `at` lands, within the range: snapping, the tick nearest it
+ *  within the snap window. */
+export declare function landAt({ groups, min, max, snapWindow }: ScrubberGrid, at: number, snaps: boolean): number;
+/** A value change, as the scrubber reads it. */
+export interface ScrubberChange {
+    /** Base UI's value; for a thumb key while playing, the end it heads
+     *  for. */
+    next: number;
+    reason: SliderPrimitive.Root.ChangeEventReason;
+    /** A step's way: `next`'s side of Base UI's value, or a thumb key's
+     *  (`keyWay`). */
+    by: -1 | 1;
+    /** The key pressed, on a keyboard change. */
+    key?: string;
+    /** Shift held, where the event carries modifiers. */
+    shiftKey?: boolean;
+}
+/** What a change does: lands at `land`, or steps by `step`, landing at
+ *  `land` unless a step handler takes the step. */
+export type ScrubberMove = {
+    land: number;
+} | {
+    step: ScrubberStep;
+    land: number | undefined;
+};
+/** Which way a thumb key heads, resolved for orientation and direction:
+ *  Home and End toward their ends; null for other keys. */
+export declare function keyWay(key: string, rtl: boolean): -1 | 1 | null;
+/** What `change` does to the scrubber at `current`: presses and drags
+ *  land snapped (`snapping`, unless the event says whether Shift is
+ *  held), arrows, Page keys, and input changes step their way, Home and
+ *  End land on the ends. */
+export declare function resolveChange(grid: ScrubberGrid, { next, reason, by, key, shiftKey }: ScrubberChange, { current, snapping }: {
+    current: number;
+    snapping: boolean;
+}): ScrubberMove;
+/** The tick an off-tick `target` shows: the latest at or before it;
+ *  null on a tick, before the first, or with no target. */
+export declare function hintedTick(groups: readonly ScrubberTickGroup[], target: number | null): number | null;
+/** A stop drawn near the pointer. */
+export interface NearStop {
+    value: number;
+    /** 1 for the nearest, falling with each stop farther. */
+    fade: number;
+}
+/** The `count` of `stops` nearest `pointer`, fading with distance. */
+export declare function nearStops(stops: readonly number[], pointer: number, count: number): NearStop[];
+/** How far `at` has come along `marks`: one per mark it stands on, two
+ *  per mark behind it. Changes exactly as `at` reaches or leaves a
+ *  mark. */
+export declare function crossings(marks: readonly number[], at: number): number;
+/** Where the thumb stands by a mark (`data-reach`). */
+export type ScrubberReach = "ahead" | "held" | "past";
+/** The thumb at `value` by the mark at `at`, along the way `fill`
+ *  grows: `held` on it or up to `hold` past it. */
+export declare function tickReach(value: number, at: number, hold: number, fill: "start" | "end"): ScrubberReach;
+/** A range segment: a run of the fill and how a press changes it. */
+export interface RangeSegment {
+    change: "kept" | "shrink" | "grow";
+    span: SliderSpan;
+}
+/** The fill over `shown`, split by what a press leaving `predicted`
+ *  keeps, shrinks, and grows. */
+export declare function rangeSegments(shown: SliderSpan, predicted: SliderSpan | null): RangeSegment[];

package/dist/slider/scrubber-state.js

@@ -0,0 +1,179 @@
+import { adjacent, nearest } from "../sorted.js";
+/** Whether `tick` draws as a mark. */
+function isMark(tick) {
+  return tick.name !== undefined || tick.glyph !== undefined;
+}
+/** `ticks` grouped by value, ascending. */
+export function groupTicks(ticks) {
+  const at = new Map();
+  for (const tick of ticks) {
+    at.set(tick.value, [...(at.get(tick.value) ?? []), tick]);
+  }
+  return [...at].sort(([a], [b]) => a - b).map(([value, here]) => {
+    const marks = here.filter(isMark).sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+    return {
+      value,
+      marks,
+      names: marks.flatMap(mark => mark.name === undefined ? [] : [mark.name])
+    };
+  });
+}
+/** The names of the `groups` at `value`, most prominent first. */
+export function tickNames(groups, value) {
+  return groups.find(group => group.value === value)?.names ?? [];
+}
+/** The latest of `groups` at or before `value`; undefined before the
+ *  first. */
+function latestTick(groups, value) {
+  return groups.findLast(group => group.value <= value);
+}
+/** The names of the latest of `groups` at or before `value`, most
+ *  prominent first. */
+export function latestNames(groups, value) {
+  return latestTick(groups, value)?.names ?? [];
+}
+/** Where a step from `from` lands: the adjacent tick; a large step's
+ *  the adjacent mark, or tick where none is a mark. Undefined past the
+ *  outermost. */
+export function stepTick(groups, from, {
+  by,
+  large
+}) {
+  const marks = groups.filter(group => group.marks.length > 0);
+  const over = (large && marks.length > 0 ? marks : groups).map(group => group.value);
+  return adjacent(over, from, by);
+}
+/** Where `at` lands, within the range: snapping, the tick nearest it
+ *  within the snap window. */
+export function landAt({
+  groups,
+  min,
+  max,
+  snapWindow
+}, at, snaps) {
+  const ticks = groups.map(group => group.value);
+  return Math.min(max, Math.max(min, snaps ? nearest(ticks, at, snapWindow) : at));
+}
+/** A step from `current` by `step`: to the adjacent tick; without
+ *  ticks, to `next`. */
+function stepMove({
+  groups
+}, current, next, step) {
+  return {
+    step,
+    land: groups.length === 0 ? next : stepTick(groups, current, step)
+  };
+}
+/** Which way a thumb key heads, resolved for orientation and direction:
+ *  Home and End toward their ends; null for other keys. */
+export function keyWay(key, rtl) {
+  switch (key) {
+    case "ArrowUp":
+    case "PageUp":
+    case "End":
+      return 1;
+    case "ArrowDown":
+    case "PageDown":
+    case "Home":
+      return -1;
+    case "ArrowRight":
+      return rtl ? -1 : 1;
+    case "ArrowLeft":
+      return rtl ? 1 : -1;
+    default:
+      return null;
+  }
+}
+/** What `change` does to the scrubber at `current`: presses and drags
+ *  land snapped (`snapping`, unless the event says whether Shift is
+ *  held), arrows, Page keys, and input changes step their way, Home and
+ *  End land on the ends. */
+export function resolveChange(grid, {
+  next,
+  reason,
+  by,
+  key,
+  shiftKey
+}, {
+  current,
+  snapping
+}) {
+  switch (reason) {
+    case "track-press":
+    case "drag":
+      return {
+        land: landAt(grid, next, shiftKey === undefined ? snapping : !shiftKey)
+      };
+    // Assistive tech adjusts the thumb a step at a time.
+    case "input-change":
+      return stepMove(grid, current, next, {
+        by,
+        large: false
+      });
+    case "keyboard":
+      if (key === "Home" || key === "End") return {
+        land: next
+      };
+      return stepMove(grid, current, next, {
+        by,
+        large: shiftKey === true || key === "PageUp" || key === "PageDown"
+      });
+    case "none":
+      return {
+        land: next
+      };
+    default:
+      return reason;
+  }
+}
+/** The tick an off-tick `target` shows: the latest at or before it;
+ *  null on a tick, before the first, or with no target. */
+export function hintedTick(groups, target) {
+  if (target === null) return null;
+  const tick = latestTick(groups, target);
+  return tick === undefined || tick.value === target ? null : tick.value;
+}
+/** The `count` of `stops` nearest `pointer`, fading with distance. */
+export function nearStops(stops, pointer, count) {
+  return [...stops].sort((a, b) => Math.abs(a - pointer) - Math.abs(b - pointer)).slice(0, count).map((value, rank) => ({
+    value,
+    fade: 1 - rank / count
+  }));
+}
+/** How far `at` has come along `marks`: one per mark it stands on, two
+ *  per mark behind it. Changes exactly as `at` reaches or leaves a
+ *  mark. */
+export function crossings(marks, at) {
+  let count = 0;
+  for (const mark of marks) count += mark < at ? 2 : mark === at ? 1 : 0;
+  return count;
+}
+/** The thumb at `value` by the mark at `at`, along the way `fill`
+ *  grows: `held` on it or up to `hold` past it. */
+export function tickReach(value, at, hold, fill) {
+  const past = fill === "start" ? value - at : at - value;
+  return past < 0 ? "ahead" : past <= hold ? "held" : "past";
+}
+/** `a`'s runs outside `b`. */
+function spanMinus([a0, a1], [b0, b1]) {
+  return [[a0, Math.min(a1, b0)], [Math.max(a0, b1), a1]].filter(([lo, hi]) => hi > lo);
+}
+/** The fill over `shown`, split by what a press leaving `predicted`
+ *  keeps, shrinks, and grows. */
+export function rangeSegments(shown, predicted) {
+  if (predicted === null) return [{
+    change: "kept",
+    span: shown
+  }];
+  const kept = [Math.max(shown[0], predicted[0]), Math.min(shown[1], predicted[1])];
+  return [...(kept[1] > kept[0] ? [{
+    change: "kept",
+    span: kept
+  }] : []), ...spanMinus(shown, predicted).map(span => ({
+    change: "shrink",
+    span
+  })), ...spanMinus(predicted, shown).map(span => ({
+    change: "grow",
+    span
+  }))];
+}

package/dist/slider/scrubber.d.ts

@@ -0,0 +1,77 @@
+import type { Slider as SliderPrimitive } from "@base-ui/react/slider";
+import { type ScrubberStep, type ScrubberTick } from "./scrubber-state.ts";
+import type { SliderRootProps, SliderThumbProps } from "./slider.tsx";
+import { type SliderParts } from "./slider-parts.ts";
+/** What moved the value: Base UI's reasons, `track-press` as the
+ *  scrubber lands a press, `keyboard` as it lands a thumb key while
+ *  playing, or `modifier` as Shift toggles snapping mid-drag. */
+export type ScrubberChangeDetails = Exclude<SliderPrimitive.Root.ChangeEventDetails, {
+    reason: "track-press";
+}> | {
+    reason: "track-press";
+    event: PointerEvent;
+} | {
+    reason: "keyboard";
+    event: KeyboardEvent;
+} | {
+    reason: "modifier";
+    event: KeyboardEvent;
+};
+/** Where a thumb key steps from the playhead: between the ticks, or
+ *  through the step handler. */
+type ScrubberStepping = {
+    playhead?: null;
+    /** Landings snap to these; arrows step between them. */
+    ticks?: readonly ScrubberTick[];
+    /** Arrows, Page keys, and input changes (assistive tech adjusting
+     *  the thumb) step through this in place of the ticks: it lands
+     *  the step itself. Home and End land on the ends regardless. */
+    onStep?: (step: ScrubberStep) => void;
+} | {
+    /** The shown value, read every frame while set (playback): the
+     *  thumb and fill glide with it (`SliderRoot` `glide`); `value`
+     *  stays the spoken one. Thumb keys, input changes, and presses
+     *  move from it. */
+    playhead: (() => number) | null;
+    ticks: readonly ScrubberTick[];
+    onStep?: (step: ScrubberStep) => void;
+} | {
+    playhead: (() => number) | null;
+    ticks?: readonly ScrubberTick[];
+    onStep: (step: ScrubberStep) => void;
+};
+/** `Scrubber` props: a single-thumb slider's, over ticks. */
+export type ScrubberProps = Omit<SliderRootProps<number>, "value" | "defaultValue" | "onValueChange" | "onValueCommitted" | "children" | "fill" | "minStepsBetweenValues" | "thumbCollisionBehavior"> & {
+    value: number;
+    /** Lands at `value`: presses, drags, input changes, and steps. */
+    onValueChange: (value: number, details: ScrubberChangeDetails) => void;
+    /** How near a tick a landing snaps to it, as a share of the range; 0
+     *  lands on ticks alone. A mark holds the thumb as far past it
+     *  (`data-reach`); playing, the thumb passes marks. */
+    snapShare?: number;
+    /** A value shown ahead of a pick elsewhere: the thumb there,
+     *  tentative (`data-tentative`), its tick lit. */
+    tentative?: number | null;
+    /** The pointer previews its press: the fill it keeps, shrinks, and
+     *  grows, and the tick it lands on. */
+    pointerPreview?: boolean;
+    /** The run the range fills. */
+    fill?: "start" | "end";
+    /** The spoken value at `value`, given the names of the latest tick at
+     *  or before it; by default the names of the ticks at `value` as a
+     *  conjunction in the messages locale, else the formatted value. */
+    valueText?: (value: number, names: readonly string[]) => string;
+    /** The thumb's props (accessible name); its ref, style, and focus
+     *  handlers merge with the scrubber's own. */
+    thumb?: Omit<SliderThumbProps, "index" | "getAriaValueText">;
+    /** The parts drawn; the unstyled ones by default. */
+    parts?: SliderParts;
+} & ScrubberStepping;
+/** A single-thumb slider over ticks: landings snap to them, arrows
+ *  step between them, marks draw always, stops near the pointer. The
+ *  pointer previews its press; Shift lands at the pointer. State shows
+ *  as `data-tentative` on the root, `data-change` on the fill's
+ *  segments (`kept`, `shrink`, `grow`), `data-light` and `data-reach`
+ *  on ticks, and `data-hover` on the thumb. */
+export declare function Scrubber({ value, onValueChange, ticks, snapShare, tentative, playhead, pointerPreview, fill, onStep, valueText, thumb, parts, onDraggingChange, min, max, disabled, onKeyDownCapture, ...props }: ScrubberProps): import("react/jsx-runtime").JSX.Element;
+export {};