@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.1

package/slider/state.js

@@ -0,0 +1,377 @@
+// Ported from react-stately `useSliderState` (packages/react-stately/src/slider/useSliderState.ts), Apache-2.0, © Adobe.
+// Rivet:
+// - State = plain signals + JSON (serializable, resumable); every `SliderState` method is an exported
+//   function taking the state first (`state.setThumbValue(0, 5)` → `setThumbValue(state, 0, 5)`),
+//   `state.values` → `sliderValues(state)`, `state.focusedThumb` → `state.focusedThumb()`.
+// - `value` (controlled) accepts a two-way `Signal<T>` (the state writes it) or a plain value (fixed:
+//   only `onChange` fires, like a React controlled prop). Controlled values are snapped
+//   (`restrictValues`) on read. `SliderState.value` may also be an accessor in transient views built
+//   per call (the color slider's `sliderView`); stored states hold signals only.
+// - Deviation: `numberFormatter` (an `Intl.NumberFormat`, not serializable) → `locale` + `formatOptions`
+//   (formatter created on use, `@internationalized/number` `NumberFormatter` cache).
+// - React refs (`valuesRef`, `isDraggingsRef`, `isEditablesRef`) → plain `refs` object on the state.
+// - Deviation (user decision 2026-10-08): `snap` option, default `"release"`: during a pointer drag the thumb
+//   position follows the pointer freely (`dragPercents`, `getThumbPositionPercent`) while the value stays on
+//   steps; on release the thumb animates to the stepped position on `@rivetjs/cdk/motion` `Motion1D` (embla's
+//   ease-out; `dragPercents` carries the animated position, `snappings` / `isThumbSnapping` flag it; no CSS transition).
+//   `snap: "drag"` = upstream behaviour (no free position).
+import { signal, untrack, _regionState } from "@rivetjs/reactivity";
+import { clamp, snapValueToStep } from "@rivetjs/cdk/utils";
+import { Motion1D } from "../motion/Motion1D.js";
+import { NumberFormatter } from "../number/NumberFormatter.js";
+import { cachedIntl } from "../i18n/intl-cache.js";
+const DEFAULT_MIN_VALUE = 0;
+const DEFAULT_MAX_VALUE = 100;
+const DEFAULT_STEP_VALUE = 1;
+const isSignal = (v) => typeof v === "function" && typeof v.set === "function";
+/**
+ * Provides state management for a slider component. Stores values for all thumbs,
+ * formats values for localization, and provides methods to update the position
+ * of any thumbs.
+ */
+export function createSliderState(props) {
+    const { isDisabled: disabledInput = false } = props;
+    // Rivet (live props): a range / orientation / format prop may be an accessor (the component's live boundary);
+    // the state keeps its creation value and the accessor (`live`), readers resolve the current one.
+    const given = props;
+    let live;
+    const now = (key) => {
+        const v = given[key];
+        if (typeof v !== "function")
+            return v;
+        (live ??= {})[key] = v;
+        return untrack(v);
+    };
+    const minValue = now("minValue") ?? DEFAULT_MIN_VALUE;
+    const maxValue = now("maxValue") ?? DEFAULT_MAX_VALUE;
+    const step = now("step") ?? DEFAULT_STEP_VALUE;
+    const orientation = now("orientation") ?? "horizontal";
+    const formatOptions = now("formatOptions");
+    const pageSize = pageSizeOf(minValue, maxValue, step);
+    const restrict = (values) => restrictValues(values, minValue, maxValue, step);
+    const defaultValue = restrict(convertValue(props.defaultValue) ?? [minValue]);
+    let value;
+    let writable = true;
+    const input = props.value;
+    if (input === undefined)
+        value = _regionState(() => signal(defaultValue));
+    else if (isSignal(input))
+        value = input;
+    else if (typeof input === "function") {
+        // Rivet (live props): a controlled accessor — read live, changes reported through onChange only.
+        value = input;
+        writable = false;
+    }
+    else {
+        value = _regionState(() => signal(input));
+        writable = false;
+    }
+    const initialValues = restrict(convertValue(untrack(value)));
+    const count = initialValues.length;
+    return {
+        value,
+        writable,
+        scalar: typeof (typeof input === "function" ? untrack(input) : input) === "number" || typeof props.defaultValue === "number",
+        defaultValues: props.defaultValue !== undefined ? defaultValue : initialValues,
+        minValue,
+        maxValue,
+        step,
+        pageSize,
+        orientation,
+        isDisabled: typeof disabledInput === "function" ? !!untrack(disabledInput) : disabledInput,
+        ...(typeof disabledInput === "function" ? { disabled: disabledInput } : {}),
+        draggings: _regionState(() => signal(new Array(count).fill(false))),
+        focusedThumb: _regionState(() => signal(undefined)),
+        snap: props.snap ?? "release",
+        dragPercents: _regionState(() => signal(new Array(count).fill(null))),
+        snappings: _regionState(() => signal(new Array(count).fill(false))),
+        onChange: props.onChange,
+        onChangeEnd: props.onChangeEnd,
+        locale: props.locale ?? "en-US",
+        formatOptions,
+        ...(live ? { live: live } : {}),
+        refs: { values: initialValues, draggings: new Array(count).fill(false), editables: new Array(count).fill(true) },
+    };
+}
+/** Page step: at least the step and always a multiple of it. */
+function pageSizeOf(minValue, maxValue, step) {
+    let calcPageSize = (maxValue - minValue) / 10;
+    calcPageSize = snapValueToStep(calcPageSize, 0, calcPageSize + step, step);
+    return Math.max(calcPageSize, step);
+}
+/** The slider's current minimum (its live `minValue`, else the creation value). */
+export function sliderMin(state) {
+    const live = state.live?.minValue;
+    return live ? (live() ?? DEFAULT_MIN_VALUE) : state.minValue;
+}
+/** The slider's current maximum. */
+export function sliderMax(state) {
+    const live = state.live?.maxValue;
+    return live ? (live() ?? DEFAULT_MAX_VALUE) : state.maxValue;
+}
+/** The slider's current step. */
+export function sliderStep(state) {
+    const live = state.live?.step;
+    return live ? (live() ?? DEFAULT_STEP_VALUE) : state.step;
+}
+/** The slider's current page size (derived from the current range and step when one of them is live). */
+export function sliderPageSize(state) {
+    const live = state.live;
+    return live && (live.minValue || live.maxValue || live.step) ? pageSizeOf(sliderMin(state), sliderMax(state), sliderStep(state)) : state.pageSize;
+}
+/** The slider's current orientation. */
+export function sliderOrientation(state) {
+    const live = state.live?.orientation;
+    return live ? (live() ?? "horizontal") : state.orientation;
+}
+/** The slider's current number format options. */
+export function sliderFormatOptions(state) {
+    const live = state.live?.formatOptions;
+    return live ? live() : state.formatOptions;
+}
+function restrictValues(values, minValue, maxValue, step) {
+    return values.map((val, idx) => {
+        const min = idx === 0 ? minValue : values[idx - 1];
+        const max = idx === values.length - 1 ? maxValue : values[idx + 1];
+        return snapValueToStep(val, min, max, step);
+    });
+}
+/** Values managed by the slider by thumb index (upstream `state.values`). */
+export function sliderValues(state) {
+    return restrictValues(convertValue(state.value()), sliderMin(state), sliderMax(state), sliderStep(state));
+}
+/** Get the value for the specified thumb. */
+export const getThumbValue = (state, index) => sliderValues(state)[index];
+/** Returns the value as a percent between the min and max of the slider. */
+export function getValuePercent(state, value) {
+    const min = sliderMin(state);
+    return (value - min) / (sliderMax(state) - min);
+}
+/** Returns the specified thumb's value as a percentage from 0 to 1. */
+export const getThumbPercent = (state, index) => getValuePercent(state, getThumbValue(state, index));
+/** Returns the min allowed value for the specified thumb. */
+export function getThumbMinValue(state, index) {
+    return index === 0 ? sliderMin(state) : sliderValues(state)[index - 1];
+}
+/** Returns the max allowed value for the specified thumb. */
+export function getThumbMaxValue(state, index) {
+    const values = sliderValues(state);
+    return index === values.length - 1 ? sliderMax(state) : values[index + 1];
+}
+/** Returns if the specified thumb is editable. */
+export function isThumbEditable(state, index) {
+    return state.refs.editables[index];
+}
+/** Set the specified thumb's editable state. */
+export function setThumbEditable(state, index, editable) {
+    state.refs.editables[index] = editable;
+}
+function setValues(state, values) {
+    // useControlledState: no change → no write, no onChange.
+    const current = untrack(() => sliderValues(state));
+    if (values.length === current.length && values.every((v, i) => Object.is(v, current[i])))
+        return;
+    state.refs.values = values;
+    const next = state.scalar ? values[0] : values;
+    if (state.writable)
+        state.value.set(next);
+    state.onChange?.(next);
+}
+/**
+ * Sets the value for the specified thumb.
+ * The actual value set will be clamped and rounded according to min/max/step.
+ */
+export function setThumbValue(state, index, value) {
+    if (isSliderDisabled(state) || !isThumbEditable(state, index)) {
+        return;
+    }
+    // Rivet: a keyboard / programmatic change during the release animation puts the thumb on its new step at once.
+    if (!state.refs.draggings[index])
+        endThumbSnap(state, index);
+    const thisMin = untrack(() => getThumbMinValue(state, index));
+    const thisMax = untrack(() => getThumbMaxValue(state, index));
+    // Round value to multiple of step, clamp value between min and max
+    value = snapValueToStep(value, thisMin, thisMax, untrack(() => sliderStep(state)));
+    const newValues = replaceIndex(untrack(() => sliderValues(state)), index, value);
+    setValues(state, newValues);
+}
+/** Whether the slider is disabled now (its live `isDisabled` accessor, else the creation value). */
+export const isSliderDisabled = (state) => (state.disabled ? !!state.disabled() : state.isDisabled);
+/** Whether the specific thumb is being dragged. */
+export const isThumbDragging = (state, index) => state.draggings()[index] ?? false;
+/** Set is dragging on the specified thumb. */
+export function setThumbDragging(state, index, dragging) {
+    if (isSliderDisabled(state) || !isThumbEditable(state, index)) {
+        return;
+    }
+    if (dragging) {
+        state.refs.values = untrack(() => sliderValues(state));
+    }
+    const wasDragging = state.refs.draggings[index];
+    state.refs.draggings = replaceIndex(state.refs.draggings, index, dragging);
+    state.draggings.set(state.refs.draggings);
+    if (!dragging)
+        releaseThumbPosition(state, index);
+    // Call onChangeEnd if no handles are dragging.
+    if (state.onChangeEnd && wasDragging && !state.refs.draggings.some(Boolean)) {
+        state.onChangeEnd(state.scalar ? state.refs.values[0] : state.refs.values);
+    }
+}
+/**
+ * Rivet: the thumb's visual position, 0–1: the free pointer position during a pointer drag (`snap: "release"`),
+ * else the stepped value's percent (`getThumbPercent`). Position thumbs / fills with it.
+ */
+export function getThumbPositionPercent(state, index) {
+    return state.dragPercents()[index] ?? getThumbPercent(state, index);
+}
+/**
+ * Rivet: sets the free position (0–1) of a thumb being dragged by a pointer, clamped to the track and to the
+ * neighbouring thumbs' values. No-op with `snap: "drag"`, disabled or not editable. Cancels a running snap.
+ */
+export function setThumbDragPercent(state, index, percent) {
+    if (state.snap !== "release" || isSliderDisabled(state) || !isThumbEditable(state, index))
+        return;
+    const min = untrack(() => getValuePercent(state, getThumbMinValue(state, index)));
+    const max = untrack(() => getValuePercent(state, getThumbMaxValue(state, index)));
+    const next = clamp(percent, min, max);
+    endThumbSnap(state, index);
+    const current = untrack(state.dragPercents);
+    if (current[index] !== next)
+        state.dragPercents.set(replaceIndex(current, index, next));
+}
+/** Rivet: whether the thumb is animating to its stepped position after a free drag (`data-snapping`). */
+export const isThumbSnapping = (state, index) => state.snappings()[index] ?? false;
+/** Rivet: ends the snap animation of a thumb: stops it and puts the thumb on its stepped position. */
+export function endThumbSnap(state, index) {
+    const motions = snapMotions.get(state.refs);
+    const motion = motions?.[index];
+    if (motion) {
+        motion.stop();
+        delete motions[index];
+        const percents = untrack(state.dragPercents);
+        if (percents[index] != null)
+            state.dragPercents.set(replaceIndex(percents, index, null));
+    }
+    const current = untrack(state.snappings);
+    if (current[index])
+        state.snappings.set(replaceIndex(current, index, false));
+}
+// Browser-only: running snap animations by thumb index, keyed by the state's refs (kept out of the JSON state).
+const snapMotions = new WeakMap();
+function prefersReducedMotion() {
+    return typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
+}
+/**
+ * Drag end: animate the free position to the stepped one on `@rivetjs/cdk/motion` (`Motion1D`: embla's
+ * ease-out, the same motion as the carousel / sheet), then drop it. Jumps when already there, with reduced
+ * motion, or without `requestAnimationFrame`.
+ */
+function releaseThumbPosition(state, index) {
+    const current = untrack(state.dragPercents);
+    const free = current[index];
+    if (free == null)
+        return;
+    const stepped = untrack(() => getThumbPercent(state, index));
+    // A second release (thumb move end + the global pointerup) retargets the running snap instead of restarting it.
+    const running = snapMotions.get(state.refs)?.[index];
+    if (running) {
+        running.to(stepped);
+        return;
+    }
+    if (Math.abs(free - stepped) <= 1e-9 || prefersReducedMotion() || typeof requestAnimationFrame !== "function") {
+        state.dragPercents.set(replaceIndex(current, index, null));
+        return;
+    }
+    endThumbSnap(state, index);
+    state.snappings.set(replaceIndex(untrack(state.snappings), index, true));
+    let motions = snapMotions.get(state.refs);
+    if (!motions)
+        snapMotions.set(state.refs, (motions = {}));
+    const motion = Motion1D({
+        value: free,
+        render: (percent) => {
+            const percents = untrack(state.dragPercents);
+            if (percents[index] !== percent)
+                state.dragPercents.set(replaceIndex(percents, index, percent));
+        },
+        onSettle: () => endThumbSnap(state, index),
+    });
+    motions[index] = motion;
+    motion.to(stepped);
+}
+/** Set focused true on specified thumb. This will remove focus from any thumb that had it before. */
+export function setFocusedThumb(state, index) {
+    state.focusedThumb.set(index);
+}
+function formatterOf(state) {
+    return new NumberFormatter(state.locale, sliderFormatOptions(state));
+}
+/** Returns the string label for the value, per props.formatOptions. */
+export function getFormattedValue(state, valueParam) {
+    if (valueParam === undefined) {
+        if (state.format)
+            return state.format.formattedValue();
+        valueParam = sliderValues(state);
+    }
+    if (typeof valueParam === "number") {
+        valueParam = [valueParam];
+    }
+    const formatter = formatterOf(state);
+    switch (valueParam.length) {
+        case 0:
+            return "";
+        case 1:
+            return formatter.format(valueParam[0]);
+        case 2:
+            return formatter.formatRange(valueParam[0], valueParam[1]);
+        default: {
+            const formatted = valueParam.map((value) => formatter.format(value));
+            const listFormat = cachedIntl(Intl.ListFormat, formatter.resolvedOptions().locale, { type: "unit" });
+            return listFormat.format(formatted);
+        }
+    }
+}
+/** Returns the string label for the specified thumb's value, per props.formatOptions. */
+export const getThumbValueLabel = (state, index) => state.format ? state.format.thumbValueLabel(index) : getFormattedValue(state, getThumbValue(state, index));
+function getRoundedValue(state, value) {
+    const min = sliderMin(state), step = sliderStep(state);
+    return Math.round((value - min) / step) * step + min;
+}
+/** Converts a percent along track (between 0 and 1) to the corresponding value. */
+export function getPercentValue(state, percent) {
+    const min = sliderMin(state), max = sliderMax(state);
+    const val = percent * (max - min) + min;
+    return clamp(getRoundedValue(state, val), min, max);
+}
+/** Sets value for the specified thumb by percent offset (between 0 and 1). */
+export function setThumbPercent(state, index, percent) {
+    setThumbValue(state, index, getPercentValue(state, percent));
+}
+/** Increments the value of the thumb by the step or page amount. */
+export function incrementThumb(state, index, stepSize = 1) {
+    untrack(() => {
+        const step = sliderStep(state);
+        const s = Math.max(stepSize, step);
+        setThumbValue(state, index, snapValueToStep(getThumbValue(state, index) + s, sliderMin(state), sliderMax(state), step));
+    });
+}
+/** Decrements the value of the thumb by the step or page amount. */
+export function decrementThumb(state, index, stepSize = 1) {
+    untrack(() => {
+        const step = sliderStep(state);
+        const s = Math.max(stepSize, step);
+        setThumbValue(state, index, snapValueToStep(getThumbValue(state, index) - s, sliderMin(state), sliderMax(state), step));
+    });
+}
+function replaceIndex(array, index, value) {
+    if (array[index] === value) {
+        return array;
+    }
+    return [...array.slice(0, index), value, ...array.slice(index + 1)];
+}
+function convertValue(value) {
+    if (value == null) {
+        return undefined;
+    }
+    return Array.isArray(value) ? value : [value];
+}

package/slots/index.d.ts

@@ -0,0 +1,248 @@
+import { createContext, useContext, type Context, type Signal } from "@rivetjs/reactivity";
+import type { Content, JSX, Ref } from "@rivetjs/runtime/jsx-runtime";
+import type { StyleObject } from "../utils/types.js";
+export { createContext, useContext, type Context };
+export type { DOMRenderProps, DOMRenderFunction } from "../utils/render.js";
+export type { StyleObject };
+/** Key of the default (unnamed) slot in a `{ slots }` context value. */
+export declare const DEFAULT_SLOT = "__rv_default_slot";
+/** A Rivet ref value: a `ref()` signal object, a callback receiving the element, or a `{ current }` object. */
+export type RefValue<E extends Element = Element> = Ref<E> | ((element: E) => void) | {
+    current: E | null;
+};
+interface SlottedValue<T> {
+    slots?: Record<string, T>;
+}
+export type SlottedContextValue<T> = SlottedValue<T> | T | null | undefined;
+export type WithRef<T, E extends Element = Element> = T & {
+    ref?: RefValue<E>;
+};
+/** Value of a part context: the part's props (+ `ref`), optionally keyed by slot name (`{ slots: { close: {…} } }`). */
+/** Context `id` may also be a `SlotId` (`createSlotId`): the part takes its id and reports itself rendered. */
+export type ContextValue<T, E extends Element = Element> = SlottedContextValue<WithRef<T extends {
+    id?: unknown;
+} ? Omit<T, "id"> & {
+    id?: T["id"] | SlotId;
+} : T, E>>;
+/**
+ * Props whose values may also be accessors (ACCESSOR RULE: state-dependent values such as `aria-invalid`,
+ * `disabled` travel as accessors and are read in bindings / resolved by the element spread). Event handlers
+ * (`on*`) and the keys in `Except` (read once by the part) stay plain.
+ */
+export type AccessorProps<T, Except extends keyof T = never> = {
+    [P in keyof T]: P extends Except ? T[P] : P extends `on${string}` ? T[P] : T[P] | (() => T[P]);
+};
+/** One `[context, value]` pair of `<Provider values>`. */
+export type ProviderValue<T> = [Context<T>, T];
+export interface ProviderProps {
+    /** `[context, value]` pairs, outermost first. */
+    values: ProviderValue<any>[];
+    children?: Content;
+}
+/** Provides several contexts at once (RAC `Provider`); later pairs are nested inside earlier ones. */
+export declare function Provider(props: ProviderProps): import("@rivetjs/runtime/jsx-runtime").CompiledElement;
+export interface StyleProps {
+    /** The CSS class of the element. */
+    class?: string;
+    /** The inline style of the element. */
+    style?: StyleObject;
+}
+export interface DOMProps extends StyleProps {
+    /** The element's unique identifier. */
+    id?: string;
+    /** The children of the component. */
+    children?: Content;
+}
+/** `class` prop of a component with render props: a string, or a function of the render props (called in a binding). */
+export type ClassNameOrFunction<T> = string | ((values: T & {
+    defaultClassName: string | undefined;
+}) => string | undefined);
+/** `style` prop of a component with render props: an object, or a function of the render props (called in a binding). */
+export type StyleOrFunction<T> = StyleObject | ((values: T & {
+    defaultStyle: StyleObject;
+}) => StyleObject | undefined);
+export interface StyleRenderProps<T> {
+    /**
+     * The CSS class of the element. A function may be provided to compute the class based on component state
+     * (render props are accessors: `class={({ isSelected }) => (isSelected() ? "on" : "off")}`).
+     */
+    class?: ClassNameOrFunction<T> | undefined;
+    /** The inline style of the element. A function may be provided to compute the style based on component state. */
+    style?: StyleOrFunction<T> | undefined;
+}
+/** `children` of a component with render props: content, or a function of the render props. */
+export type ChildrenOrFunction<T> = Content | ((values: T & {
+    defaultChildren: Content | undefined;
+}) => Content);
+export interface RenderProps<T> extends StyleRenderProps<T> {
+    /** The children of the component. A function may be provided to alter the children based on component state. */
+    children?: ChildrenOrFunction<T> | undefined;
+}
+export interface RenderPropsHookOptions<T> extends RenderProps<T> {
+    /** The render props (accessors). */
+    values: T;
+    defaultChildren?: Content;
+    defaultClassName?: string;
+    defaultStyle?: StyleObject;
+}
+/** Live views of a part's props for `renderProps`, one key each: `class`, `style`, `children` (`renderPropsOf`). */
+export type LiveRenderProps<T> = readonly [Pick<RenderProps<T>, "class">, Pick<RenderProps<T>, "style">, Pick<RenderProps<T>, "children">];
+export interface RenderPropsHookRetVal {
+    /** The resolved class (read it inside a binding: `class={rp.class()}`). */
+    class: () => string | undefined;
+    /** The resolved style (read it inside a binding: `style={rp.style()}`). */
+    style: () => StyleObject | undefined;
+    /** The resolved children (render where the content goes: `{rp.children()}`). */
+    children: () => Content;
+}
+/**
+ * Resolves `class` / `style` / `children` render props (RAC `useRenderProps`). The returned accessors call
+ * the user's functions with `{ ...values, defaultClassName | defaultStyle | defaultChildren }`.
+ */
+export declare function renderProps<T>(props: RenderPropsHookOptions<T>, from?: RenderProps<T> | LiveRenderProps<T>): RenderPropsHookRetVal;
+/**
+ * `renderProps` for a part's own props (`renderProps({ ...props, values, defaultClassName })`): live props (an own
+ * getter) → `class` / `style` / `children` read through one live view per key inside the accessors (`liveRenderProps`);
+ * static → the values. `keys`: the keys taken from the props (default all three; TabList leaves its collection
+ * children out). Call it directly in the `const rp = …` initializer, no `untrack(() => …)` wrapper and no inline arrow
+ * in `options` (hoist `values`): a function in the initializer makes the compiler capture `rp` whole in spread sites,
+ * so the class / style binding would encode the children accessor too (per-key views wasted).
+ */
+export declare function renderPropsOf<T>(props: RenderProps<T>, options: Omit<RenderPropsHookOptions<T>, "class" | "style" | "children">, keys?: readonly RenderKey[]): RenderPropsHookRetVal;
+type RenderKey = "class" | "style" | "children";
+/**
+ * The live `from` of `renderProps` for live props (`hasLive(props)`): one forwarding `splitProps` view per key
+ * (`[class, style, children]`), so each resolved accessor captures only its own key on a resumed page. A shared
+ * `liveView(props, ["class", "style", "children"])` made the `class` / `style` bindings capture the children too: a
+ * children function capturing a class instance (a calendar cell's `date`) failed the resumable render. `keys` = the
+ * keys taken from the props (default all three); a left-out key gets an empty view (`renderProps` falls back to its
+ * default, as a `liveView` without that key did).
+ */
+export declare function liveRenderProps<T>(props: object, keys?: readonly RenderKey[]): LiveRenderProps<T>;
+/**
+ * Combines a user-provided render prop value (a static value or a function) with another value
+ * (RAC `composeRenderProps`).
+ */
+export declare function composeRenderProps<T, U, V extends T>(value: T extends any ? T | ((renderProps: U) => V) : never, wrap: (prevValue: T, renderProps: U) => V): (renderProps: U) => V;
+export interface SlotProps {
+    /**
+     * A slot name for the component. Slots allow the component to receive props from a parent component.
+     * An explicit `null` value indicates that the local props completely override all props received from a parent.
+     * Read once at mount (it picks the context props).
+     */
+    slot?: string | null;
+}
+/** The context value for `slot` (RAC `useSlottedContext`); throws for an unknown slot of a slotted value. */
+export declare function slottedContext<T>(context: Context<SlottedContextValue<T>>, slot?: string | null): T | null | undefined;
+/**
+ * Merges the props a parent provided through `context` (for `props.slot`) with the component's own
+ * props (RAC `useContextProps`): own props win, handlers chain, classes join, `style` objects merge
+ * (functions compose). Returns the merged props (without `ref`) and the ref to put on the element.
+ */
+export declare function contextProps<T extends object, U extends SlotProps, E extends Element>(props: T & SlotProps, ref: RefValue<E> | undefined, context: Context<ContextValue<U, E>>): [T, RefValue<E> | undefined];
+/**
+ * One ref for an element from two refs (RA `mergeRefs` / `useSyncRef` for Rivet refs): either alone is
+ * returned as is; both → a fresh `ref()` whose element a `clientEffect` copies to both (see the header).
+ */
+export declare function mergeRefValues<E extends Element>(own: RefValue<E> | undefined, fromContext: RefValue<E> | undefined): RefValue<E> | undefined;
+/**
+ * Whether a slotted element (e.g. a `<Heading slot="title">` inside a Dialog) rendered (RAC `useSlot`).
+ * Put the returned ref on the slot element's context value; `hasSlot()` is `initialState` until that
+ * element exists in the browser (server render: `initialState`; resumed page: whether the server
+ * rendered it), then whether it is attached.
+ */
+export declare function createSlot(initialState?: boolean | (() => boolean)): [Ref<Element>, () => boolean];
+/**
+ * @internal Server: the part holding a `createSlot` ref rendered (Label calls it with its context ref), so an owner whose
+ * attributes render after it sees `hasSlot()` true even with a `false` initial state. Browser: unused (the ref is set).
+ */
+export declare function markSlotRendered(ref: unknown): void;
+/**
+ * An id for a slotted part that may not render (RA `useSlotId`). Client render: `rendered()` starts `true` (RA's
+ * first render keeps the id), then a `clientEffect` after mount checks `document.getElementById(id)` and drops the
+ * id when no element has it; the check re-runs when the signals read by `deps` change (RA `depArray`). Fast path
+ * (same semantics): a part consuming the id through `contextProps` sets `rendered` true while mounted and false when
+ * it unmounts.
+ * Server render (UI-COLD 2026-10-08): no check effect, so a resumed page does not boot the runtime for it.
+ * `rendered()` starts `false` and the consuming part marks it (no server cleanup), so the serialized flag says
+ * whether the part is in the HTML; only a server-rendered part of an id with `deps` (it may unmount later) records
+ * its unmount cleanup as a client effect. `slotIdRef` keeps an id whose part may still render later in the tree
+ * (RA's server HTML) and reads the flag, so the owner's binding resumes and follows the part.
+ * Deviation from RA (which drops an id without element after mount): a server id whose part never rendered (no
+ * `deps`) stays in the owner's attribute until that binding re-runs for another reason (a validity change, the part
+ * mounting); assistive technology ignores IDREFs without an element. A check effect at the first interaction was
+ * tried and dropped: it loaded the owners' chunks mid-interaction (lost DateField keys).
+ * Plain data + a signal, so it serializes in context values.
+ * Usage: provide `{ id: slotId }` in the part's context and read `slotIdRef(slotId)` inside the owner's
+ * `aria-labelledby` / `-describedby` binding.
+ */
+export interface SlotId {
+    /** The element id the part gets. */
+    readonly id: string;
+    /**
+     * Whether the id is in use (an element with it exists, or it has not been checked yet); a string when the part
+     * rendered with its own `id` prop (RA mergeIds): the id the owner must reference instead of `id`.
+     */
+    readonly rendered: Signal<boolean | string>;
+}
+/**
+ * Creates a slot id (RA `useSlotId(depArray)`); `id` defaults to a generated one; the signals `deps` reads re-run
+ * the check. `deps` is captured by a resumable effect: pass a signal / computed or a local const function, not an
+ * inline arrow argument (arguments are not resumable).
+ */
+export declare function createSlotId(id?: string, deps?: () => unknown): SlotId;
+/**
+ * The slot id's id while it is in use, else `undefined` (read it inside a binding). `expected`: server only, whether
+ * the part may still render later in the tree (an owner reads before its later parts): the id is kept then (RA's
+ * server HTML); a FieldError's id passes the validity (RAC FieldError renders only while invalid).
+ */
+export declare function slotIdRef(slotId: SlotId | undefined, expected?: boolean): string | undefined;
+/**
+ * Server slot probe (`probeSlots`): a hideable part that renders nothing in the probe marks the slot id its context
+ * gives it (the id it would consume through `contextProps`), so the owner can write `slotIdRef(id, false)`.
+ */
+export declare function probeSlot(props: {
+    slot?: string | null;
+    id?: unknown;
+}, context: Context<ContextValue<any, any>>): void;
+/** Whether `value` is a `SlotId`. */
+export declare function isSlotId(value: unknown): value is SlotId;
+/**
+ * A parent's generated id that a part may replace with its own (RA `useId` + `mergeIds`): an Autocomplete's
+ * collection id / a ComboBox's listbox id passed in a context value (`{ id: mergedId }`). When the consuming part
+ * (`contextProps`) has its own `id`, `current` switches to it (RA re-renders the `useId` holder with the merged id),
+ * so the parent's `aria-controls` / `aria-activedescendant` bindings follow. Runs during the part's render: on the
+ * server that precedes the parent's attribute writes (spread accessors are written after the synchronous tree is
+ * built), so SSR markup already points at the part's id. Plain data + a signal: serializes in context values.
+ */
+export interface MergedId {
+    /** The parent's generated id (the part's id when it has none). */
+    readonly id: string;
+    /** The id in use: `id`, or the consuming part's own id. */
+    readonly current: Signal<string>;
+}
+/** Creates a merged id (`id` defaults to a generated one). Read `mergedId.current()` inside bindings. */
+export declare function createMergedId(id?: string): MergedId;
+/** Whether `value` is a `MergedId`. */
+export declare function isMergedId(value: unknown): value is MergedId;
+/** The plain id of an id prop that may be a `MergedId` (its generated `id`). */
+export declare function mergedIdOf(id: unknown): string | undefined;
+/** Filters out `data-*` attributes to keep them from being passed down and duplicated (RAC `removeDataAttributes`). */
+export declare function removeDataAttributes<T extends object>(props: T): T;
+/** Override of the shared `Validation` base that changes the default (RAC `RACValidation`). */
+export interface RACValidation {
+    /**
+     * Whether to use native HTML form validation to prevent form submission when the value is missing or
+     * invalid, or mark the field as required or invalid via ARIA.
+     *
+     * @default 'native'
+     */
+    validationBehavior?: "native" | "aria";
+}
+/**
+ * Native attributes of element `K` as component props (RAC `HTMLAttributes<…>`), without the props the
+ * part handles itself (`children`, `ref`, `slot`, `class`, `style`).
+ */
+export type HTMLProps<K extends keyof JSX.IntrinsicElements> = Omit<JSX.IntrinsicElements[K], "children" | "ref" | "slot" | "class" | "className" | "style">;
+/** Registers a part context for resume (`resumableContext(createContext(v, { id: "rv-<name>" }))`). */
+export { resumableContext } from "@rivetjs/runtime/resume-format";