@vireo-ai/trellis-ui 0.1.61 → 0.1.62

package/packages/client/types/motion/config.d.ts

@@ -0,0 +1,118 @@
+import { type AnimationOptions, type ValueAnimationTransition } from 'motion';
+/** Global animation policy. Recipe options override these defaults. */
+export interface MotionConfiguration {
+    tempo: number;
+    elasticity: number;
+    displacement: number;
+}
+declare const motionRoles: {
+    readonly feedback: {
+        readonly duration: "fast";
+        readonly easing: "out";
+        readonly reduced: "feedback";
+        readonly spring: false;
+        readonly elasticity: 0.12;
+    };
+    readonly presence: {
+        readonly duration: "moderate";
+        readonly easing: "out";
+        readonly reduced: "feedback";
+        readonly spring: false;
+        readonly elasticity: 0.2;
+    };
+    readonly presenceEmphasized: {
+        readonly duration: "slow";
+        readonly easing: "out";
+        readonly reduced: "feedback";
+        readonly spring: false;
+        readonly elasticity: 0.24;
+    };
+    readonly presenceEmphasizedExit: {
+        readonly duration: "slow-exit";
+        readonly easing: "out";
+        readonly reduced: "feedbackExit";
+        readonly spring: false;
+        readonly elasticity: 0;
+    };
+    readonly feedbackExit: {
+        readonly duration: "fast-exit";
+        readonly easing: "out";
+        readonly reduced: "feedbackExit";
+        readonly spring: false;
+        readonly elasticity: 0;
+    };
+    readonly presenceExit: {
+        readonly duration: "moderate-exit";
+        readonly easing: "out";
+        readonly reduced: "feedbackExit";
+        readonly spring: false;
+        readonly elasticity: 0;
+    };
+    readonly layout: {
+        readonly duration: "moderate";
+        readonly easing: "inOut";
+        readonly reduced: "feedback";
+        readonly spring: false;
+        readonly elasticity: 0.14;
+    };
+    readonly layoutQuick: {
+        readonly duration: "fast";
+        readonly easing: "inOut";
+        readonly reduced: "feedback";
+        readonly spring: false;
+        readonly elasticity: 0.08;
+    };
+    readonly layoutSpring: {
+        readonly duration: "moderate";
+        readonly easing: "inOut";
+        readonly reduced: "feedback";
+        readonly spring: true;
+        readonly elasticity: 0.22;
+    };
+    readonly resize: {
+        readonly duration: "moderate";
+        readonly easing: "inOut";
+        readonly reduced: "feedback";
+        readonly spring: true;
+        readonly elasticity: 0.18;
+    };
+    readonly gestureExit: {
+        readonly duration: "moderate";
+        readonly easing: "out";
+        readonly reduced: "feedbackExit";
+        readonly spring: false;
+        readonly elasticity: 0;
+    };
+    readonly gestureSettle: {
+        readonly duration: "slow";
+        readonly easing: "out";
+        readonly reduced: "feedback";
+        readonly spring: true;
+        readonly elasticity: 0.3;
+    };
+    readonly continuous: {
+        readonly duration: "continuous";
+        readonly easing: "linear";
+        readonly reduced: "feedback";
+        readonly spring: false;
+        readonly elasticity: 0;
+    };
+};
+export type MotionTransition = Readonly<AnimationOptions>;
+export type MotionRoleName = keyof typeof motionRoles;
+export type MotionSpeedName = 'fast' | 'moderate' | 'slow';
+export type DurationSpeed = Readonly<{
+    duration: number;
+}>;
+export type PhysicsSpeed = Readonly<{
+    stiffness: number;
+    damping: number;
+    mass?: number;
+}>;
+export type MotionSpeed = MotionSpeedName | DurationSpeed | PhysicsSpeed;
+export declare const configureMotion: (options: Partial<MotionConfiguration>) => void;
+export declare const subscribeMotionConfiguration: (listener: () => void) => (() => void);
+export declare const motionDisplacement: () => number;
+export declare const resolveMotionRole: (role: MotionRoleName, channel?: "spatial" | "opacity", speed?: MotionSpeed) => ValueAnimationTransition;
+export declare const reducedMotionRole: (role: MotionRoleName) => MotionRoleName;
+export {};

package/packages/client/types/motion/feedback.d.ts

@@ -0,0 +1,3 @@
+/** Project feedback once per change, leaving decorative contents and initial CSS intact. */
+declare const createOpacityFeedback: (signal: AbortSignal) => ((element: Element, visible: boolean) => void);
+export { createOpacityFeedback };

package/packages/client/types/motion/index.d.ts

@@ -1,108 +1,9 @@
-declare const motion: ((subject: import("./subject").MotionSubject) => import("./plan").MotionPlan) & {
-    readonly presets: Readonly<{
-        opacity: Readonly<{
-            in: import("./recipe").MotionKeyframePreset;
-            out: import("./recipe").MotionKeyframePreset;
-        }>;
-        popover: Readonly<{
-            in: import("./recipe").MotionKeyframePreset;
-            out: import("./recipe").MotionKeyframePreset;
-        }>;
-        modal: Readonly<{
-            in: import("./recipe").MotionKeyframePreset;
-            out: import("./recipe").MotionKeyframePreset;
-        }>;
-        toast: Readonly<{
-            in: import("./recipe").MotionKeyframePreset;
-            out: import("./recipe").MotionKeyframePreset;
-        }>;
-        sheet: Readonly<{
-            left: Readonly<{
-                in: import("./recipe").MotionKeyframePreset;
-                out: import("./recipe").MotionKeyframePreset;
-            }>;
-            right: Readonly<{
-                in: import("./recipe").MotionKeyframePreset;
-                out: import("./recipe").MotionKeyframePreset;
-            }>;
-            top: Readonly<{
-                in: import("./recipe").MotionKeyframePreset;
-                out: import("./recipe").MotionKeyframePreset;
-            }>;
-            bottom: Readonly<{
-                in: import("./recipe").MotionKeyframePreset;
-                out: import("./recipe").MotionKeyframePreset;
-            }>;
-        }>;
-    }>;
-    readonly roles: Readonly<{
-        feedback: Readonly<{
-            duration: 0.08;
-            ease: readonly [0.23, 1, 0.32, 1];
-        }>;
-        presence: Readonly<{
-            duration: 0.16;
-            ease: readonly [0.23, 1, 0.32, 1];
-        }>;
-        presenceEmphasized: Readonly<{
-            duration: 0.24;
-            ease: readonly [0.23, 1, 0.32, 1];
-        }>;
-        layout: Readonly<{
-            duration: 0.16;
-            ease: readonly [0.77, 0, 0.175, 1];
-        }>;
-        layoutQuick: Readonly<{
-            duration: 0.08;
-            ease: readonly [0.77, 0, 0.175, 1];
-        }>;
-        layoutSpring: Readonly<{
-            visualDuration: 0.16;
-            bounce: 0;
-        }>;
-        resize: Readonly<{
-            visualDuration: 0.16;
-            bounce: 0;
-        }>;
-        gestureExit: Readonly<{
-            duration: 0.16;
-            ease: readonly [0.23, 1, 0.32, 1];
-        }>;
-        gestureSettle: Readonly<{
-            visualDuration: 0.24;
-            bounce: 0;
-        }>;
-    }>;
-    readonly speeds: Readonly<{
-        fast: Readonly<{
-            duration: 0.08;
-        }>;
-        moderate: Readonly<{
-            duration: 0.16;
-        }>;
-        slow: Readonly<{
-            duration: 0.24;
-        }>;
-    }>;
-    readonly easings: {
-        readonly out: readonly [0.23, 1, 0.32, 1];
-        readonly inOut: readonly [0.77, 0, 0.175, 1];
-    };
-    readonly createController: <T extends import("./controller").ControllerDefinitions>(options: import("./controller").ControllerOptions<T>) => import("./controller").Controller<import("./controller").ControllerState<T>>;
-    readonly stop: (element: Element) => void;
-    readonly withReducedMotion: <T extends import("motion").AnimationOptions>(options: T, reducedOptions?: Partial<T>, preference?: import("./reduced-motion").MotionPreference) => T;
-    readonly view: (update: () => void | Promise<void>, options?: import("./view").ViewOptions) => import("./animate").MotionHandle;
+import { animateMutation } from './lifecycle';
+declare const animate: ((root: Element, update: () => void | Promise<void>) => Promise<void>) & {
+    configure: (options: Partial<import("./config").MotionConfiguration>) => void;
+    register: (definitions: Readonly<Record<string, import("./registry").AnimationRecipe>>) => void;
 };
-export { motion };
-export { type MotionHandle } from './animate';
-export { flip, type FlipOptions } from './flip';
-export { createBoundsMotion, type BoundsMotion, type BoundsMotionOptions, type BoundsProperty, type BoundsUpdateOptions, } from './bounds';
-export { createController, type Controller, type ControllerDefinitions, type ControllerOptions, type ControllerScalar, type ControllerState, type ControllerValueDefinition, type ControllerValues, type StyleProjection, } from './controller';
-export { prefersReducedMotion, reducedMotionQuery, shouldReduceMotion, withReducedMotion, type MotionPreference, } from './reduced-motion';
-export { createMotionPlan, MotionPlan, type MotionDefaults, type MotionPlanOptions, type MotionSegment, type MotionStage, } from './plan';
-export { presets, isSpringRole, resolveMiniMotionRole, resolveMotionRole, roles, easings, speeds, type DurationSpeed, type MotionKeyframePreset, type MotionKeyframes, type MotionRoleName, type MotionSpeed, type MotionSpeedName, type MotionTransition, type PhysicsSpeed, } from './recipe';
-export { resize, type ResizeDestination, type ResizeOptions } from './resize';
-export { animateSize, type SizeKeyframes, type SizeMotionOptions, type SizeProperty, type SizeScalar, type SizeValue, } from './size';
-export { type MotionSubject, type MotionTransitionSubject } from './subject';
-export type { MotionTarget, ViewScope } from './targets';
-export { view, type ViewOptions, type ViewPreset } from './view';
+export { animate, animateMutation };
+export { retainExit } from './lifecycle';
+export type { AnimationRecipe, AnimationPhase, AnimationContext } from './registry';
+export type { MotionConfiguration } from './config';

package/packages/client/types/motion/layout.d.ts

@@ -0,0 +1,25 @@
+import { type MotionHandle } from './animate';
+import { type MotionRoleName, type MotionTransition } from './config';
+import { type MotionSubject } from './subject';
+type LayoutTarget = {
+    subject: Element;
+    destination: () => Element | undefined;
+};
+type LayoutOptions = Readonly<{
+    target?: Element | string | readonly (Element | string)[];
+    update(): void | Promise<void>;
+    role?: MotionRoleName;
+    transition?: MotionTransition;
+    signal?: AbortSignal | null;
+}>;
+/** Motion owns projection, nesting, replacement geometry and interruption. */
+declare const animateLayoutTargets: (update: () => void | Promise<void>, targets: readonly LayoutTarget[], options?: Pick<LayoutOptions, "role" | "transition" | "signal"> & {
+    scope?: Element;
+}) => MotionHandle;
+/**
+ * Register persistent native layout participants, then batch DOM mutations and
+ * project their geometry with shared policy. Later scoped layouts reuse them.
+ */
+declare const layout: (subject: MotionSubject, options: LayoutOptions) => MotionHandle;
+export { animateLayoutTargets, layout };
+export type { LayoutOptions };

package/packages/client/types/motion/lifecycle.d.ts

@@ -0,0 +1,10 @@
+declare const setAnimationPaused: (element: Element, value: boolean) => void;
+/** One root lifecycle for static effects; it never tries to infer pre-mutation layout. */
+declare const registerAnimationLifecycle: (nextTick?: () => Promise<void>) => void;
+/** Retire logical ownership immediately; keep only inert outgoing presentation. */
+declare const retainExit: (node: Element, retire: () => void) => boolean;
+/** Whether a managed mutation affects declared layout, including containing panels. */
+declare const hasAnimationParticipants: (root: Element, html?: string | null) => boolean;
+/** Resolves after mutation/readiness, never after finite or continuous playback. */
+declare const animateMutation: (root: Element, update: () => void | Promise<void>) => Promise<void>;
+export { animateMutation, retainExit, registerAnimationLifecycle, hasAnimationParticipants, setAnimationPaused };

package/packages/client/types/motion/owned.d.ts

@@ -1,7 +1,18 @@
-import type { AnimationPlaybackControls } from 'motion';
+import { type AnimationPlaybackControls } from 'motion';
 import { type MotionHandle } from './animate';
 type MotionProperty = string;
+type MotionSettlement = 'finished' | 'cancelled' | 'stopped';
+declare const trackTransformMotion: (element: Element) => (() => void);
+type MotionPresentation = ReadonlyMap<MotionProperty, string | number | undefined>;
+declare const hasOwnedMotion: (element: Element) => boolean;
 /** Stop and release motion ownership before direct measurement or presentation changes. */
-declare const stopOwnedMotion: (element: Element) => ReadonlySet<MotionProperty> | undefined;
-declare const ownMotion: (element: Element, start: (previousProperties?: ReadonlySet<MotionProperty>) => Pick<AnimationPlaybackControls, "finished" | "cancel" | "stop" | "complete">, properties: ReadonlySet<MotionProperty>, signal?: AbortSignal | null, cleanup?: () => void) => MotionHandle;
-export { ownMotion, stopOwnedMotion };
+declare const stopOwnedMotion: (element: Element, properties?: ReadonlySet<string>) => MotionPresentation | undefined;
+/** Retire a DOM/gesture owner, including upstream values and queued presentation. */
+declare const releaseOwnedMotion: (element: Element) => void;
+/** Detach renderer values after their drivers have stopped or settled. */
+declare const releaseMotionEffect: (element: Element, properties?: ReadonlySet<string>) => void;
+/** Return temporary animation styles to CSS, including layout projection's base opacity. */
+declare const restoreMotionStyles: (element: HTMLElement, styles: Readonly<Record<string, string>>) => void;
+declare const ownMotion: (element: Element, start: (previousProperties?: MotionPresentation) => Pick<AnimationPlaybackControls, "finished" | "cancel" | "stop" | "complete">, properties: ReadonlySet<MotionProperty>, signal?: AbortSignal | null, cleanup?: (settlement: MotionSettlement) => void) => MotionHandle;
+export { hasOwnedMotion, trackTransformMotion, ownMotion, releaseOwnedMotion, releaseMotionEffect, restoreMotionStyles, stopOwnedMotion };
+export type { MotionPresentation, MotionSettlement };

package/packages/client/types/motion/properties.d.ts

@@ -0,0 +1,17 @@
+import { type DOMKeyframesDefinition } from 'motion';
+import { type MotionHandle } from './animate';
+import { type MotionRoleName, type MotionSpeed, type MotionTransition } from './config';
+import { type MotionSubject } from './subject';
+type PropertyAnimationOptions = Readonly<{
+    target?: Element | string;
+    role?: MotionRoleName;
+    speed?: MotionSpeed;
+    transition?: MotionTransition;
+    signal?: AbortSignal | null;
+}>;
+export declare const withMotionDefaults: (defaults: MotionTransition, options: MotionTransition) => MotionTransition;
+/** Literal transforms take over aliases while unrelated properties retain their renderer. */
+declare const releaseTransformEffect: (target: Element) => void;
+declare const animateProperties: (subject: MotionSubject, keyframesInput: Readonly<DOMKeyframesDefinition>, options?: PropertyAnimationOptions) => MotionHandle;
+export { animateProperties, releaseTransformEffect };
+export type { PropertyAnimationOptions };

package/packages/client/types/motion/recipe.d.ts

@@ -1,75 +1,9 @@
-import type { AnimationOptions, DOMKeyframesDefinition, ValueAnimationTransition } from 'motion';
-type MotionSpeedName = 'fast' | 'moderate' | 'slow';
-type MotionRoleName = 'feedback' | 'presence' | 'presenceEmphasized' | 'layout' | 'layoutQuick' | 'layoutSpring' | 'resize' | 'gestureExit' | 'gestureSettle';
-type DurationSpeed = Readonly<{
-    duration: number;
-}>;
-type PhysicsSpeed = Readonly<{
-    stiffness: number;
-    damping: number;
-    mass?: number;
-}>;
-type MotionSpeed = MotionSpeedName | DurationSpeed | PhysicsSpeed;
+import type { DOMKeyframesDefinition } from 'motion';
 type MotionKeyframes<T> = T | readonly T[];
 type MotionKeyframePreset = Readonly<DOMKeyframesDefinition>;
-type MotionTransition = Readonly<AnimationOptions>;
-declare const speeds: Readonly<{
-    fast: Readonly<{
-        duration: 0.08;
-    }>;
-    moderate: Readonly<{
-        duration: 0.16;
-    }>;
-    slow: Readonly<{
-        duration: 0.24;
-    }>;
-}>;
-declare const easings: {
-    readonly out: readonly [0.23, 1, 0.32, 1];
-    readonly inOut: readonly [0.77, 0, 0.175, 1];
-};
-declare const roles: Readonly<{
-    feedback: Readonly<{
-        duration: 0.08;
-        ease: readonly [0.23, 1, 0.32, 1];
-    }>;
-    presence: Readonly<{
-        duration: 0.16;
-        ease: readonly [0.23, 1, 0.32, 1];
-    }>;
-    presenceEmphasized: Readonly<{
-        duration: 0.24;
-        ease: readonly [0.23, 1, 0.32, 1];
-    }>;
-    layout: Readonly<{
-        duration: 0.16;
-        ease: readonly [0.77, 0, 0.175, 1];
-    }>;
-    layoutQuick: Readonly<{
-        duration: 0.08;
-        ease: readonly [0.77, 0, 0.175, 1];
-    }>;
-    layoutSpring: Readonly<{
-        visualDuration: 0.16;
-        bounce: 0;
-    }>;
-    resize: Readonly<{
-        visualDuration: 0.16;
-        bounce: 0;
-    }>;
-    gestureExit: Readonly<{
-        duration: 0.16;
-        ease: readonly [0.23, 1, 0.32, 1];
-    }>;
-    gestureSettle: Readonly<{
-        visualDuration: 0.24;
-        bounce: 0;
-    }>;
-}>;
-declare const resolveMotionRole: (target: Element, role: MotionRoleName) => ValueAnimationTransition;
-declare const isSpringRole: (role: MotionRoleName, target?: Element) => boolean;
-/** Resolve semantic timing for Motion's WAAPI-backed mini animator. */
-declare const resolveMiniMotionRole: (target: Element, role: MotionRoleName) => MotionTransition;
+/** Positioned surfaces share spatial presentation; controllers own readiness and reversal. */
+declare const anchoredEntrance: (element: Element) => MotionKeyframePreset;
+declare const anchoredExit: MotionKeyframePreset;
 declare const presets: Readonly<{
     opacity: Readonly<{
         in: MotionKeyframePreset;
@@ -79,10 +13,10 @@ declare const presets: Readonly<{
         in: MotionKeyframePreset;
         out: MotionKeyframePreset;
     }>;
-    modal: Readonly<{
+    readonly modal: {
         in: MotionKeyframePreset;
         out: MotionKeyframePreset;
-    }>;
+    };
     toast: Readonly<{
         in: MotionKeyframePreset;
         out: MotionKeyframePreset;
@@ -106,8 +40,7 @@ declare const presets: Readonly<{
         }>;
     }>;
 }>;
-declare const speedOptions: (speed?: MotionSpeed, target?: Element) => DurationSpeed | PhysicsSpeed;
 declare const finalKeyframe: <T>(keyframes: MotionKeyframes<T>) => T;
 declare const mutableKeyframes: <T>(keyframes: MotionKeyframes<T>) => T | T[];
-export { easings, finalKeyframe, isSpringRole, mutableKeyframes, presets, resolveMiniMotionRole, resolveMotionRole, roles, speedOptions, speeds, };
-export type { DurationSpeed, MotionKeyframePreset, MotionKeyframes, MotionRoleName, MotionSpeed, MotionSpeedName, MotionTransition, PhysicsSpeed, };
+export { anchoredEntrance, anchoredExit, finalKeyframe, mutableKeyframes, presets, };
+export type { MotionKeyframes, };

package/packages/client/types/motion/reduced-motion.d.ts

@@ -1,9 +1,8 @@
-import type { AnimationOptions, DOMKeyframesDefinition } from 'motion';
-type MotionPreference = 'user' | 'always' | 'never';
+import { type AnimationPlaybackControls } from 'motion';
 declare const reducedMotionQuery = "(prefers-reduced-motion: reduce)";
-declare const prefersReducedMotion: () => boolean;
-declare const shouldReduceMotion: (preference?: MotionPreference) => boolean;
-declare const withReducedMotion: <T extends AnimationOptions>(options: T, reducedOptions?: Partial<T>, preference?: MotionPreference) => T;
-declare const reduceKeyframes: (keyframes: DOMKeyframesDefinition) => DOMKeyframesDefinition;
-export { prefersReducedMotion, reducedMotionQuery, reduceKeyframes, shouldReduceMotion, withReducedMotion, };
-export type { MotionPreference };
+declare const shouldReduceMotion: () => boolean;
+export { reducedMotionQuery, shouldReduceMotion, };
+declare const spatialProperties: Set<string>;
+type SpatialMotion = Pick<AnimationPlaybackControls, 'complete' | 'finished'>;
+declare const trackSpatialMotion: (handle: SpatialMotion) => (() => void);
+export { spatialProperties, trackSpatialMotion };

package/packages/client/types/motion/registry.d.ts

@@ -0,0 +1,37 @@
+import { createScopedAnimate, type AnimationPlaybackControls, type AnimationScope, type DOMKeyframesDefinition, type AnimationOptions, type ElementOrSelector } from 'motion';
+import { type MotionRoleName } from './config';
+type AnimationContext = Readonly<{
+    element: Element;
+    signal: AbortSignal;
+    animate: ReturnType<typeof createScopedAnimate>;
+    cleanup(disposer: () => void): void;
+}>;
+type AnimationPhase = Readonly<DOMKeyframesDefinition> | ((context: AnimationContext) => AnimationPlaybackControls | (() => void) | void);
+interface AnimationRecipe {
+    enter?: AnimationPhase;
+    exit?: AnimationPhase;
+    active?: AnimationPhase;
+    options?: AnimationOptions;
+}
+declare const registerAnimations: (definitions: Readonly<Record<string, AnimationRecipe>>) => void;
+declare const recipeName: (element: Element, phase: "enter" | "exit" | "active") => string;
+declare const hasAnimation: (element: Element, phase: "enter" | "exit" | "active") => boolean;
+/** One scoped connection to Motion for recipes and reactive bindings. */
+declare const createAnimationScope: (element: Element, options?: AnimationOptions, signal?: AbortSignal, role?: MotionRoleName) => {
+    animate: {
+        (sequence: import("motion").AnimationSequence, options?: import("motion").SequenceOptions): import("motion").AnimationPlaybackControlsWithThen;
+        (value: string | import("motion").MotionValue<string>, keyframes: string | import("motion").UnresolvedValueKeyframe<string>[], options?: import("motion").ValueAnimationTransition<string>): import("motion").AnimationPlaybackControlsWithThen;
+        (value: number | import("motion").MotionValue<number>, keyframes: number | import("motion").UnresolvedValueKeyframe<number>[], options?: import("motion").ValueAnimationTransition<number>): import("motion").AnimationPlaybackControlsWithThen;
+        <V extends string | number>(value: V | import("motion").MotionValue<V>, keyframes: V | import("motion").UnresolvedValueKeyframe<V>[], options?: import("motion").ValueAnimationTransition<V>): import("motion").AnimationPlaybackControlsWithThen;
+        (element: ElementOrSelector, keyframes: DOMKeyframesDefinition, options?: AnimationOptions): import("motion").AnimationPlaybackControlsWithThen;
+        <O extends {}>(object: O | O[], keyframes: import("motion").ObjectTarget<O>, options?: AnimationOptions): import("motion").AnimationPlaybackControlsWithThen;
+    };
+    cleanup: (disposer: () => void) => void;
+    dispose: () => void;
+    ownPlayback: (controls: AnimationPlaybackControls) => void;
+    scope: AnimationScope<Element>;
+};
+declare const getAnimationOptions: (element: Element) => AnimationOptions | undefined;
+declare const runAnimation: (element: Element, phase: "enter" | "exit" | "active", signal: AbortSignal) => AnimationPlaybackControls | (() => void) | undefined;
+export { registerAnimations, recipeName, hasAnimation, runAnimation, createAnimationScope, getAnimationOptions };
+export type { AnimationRecipe, AnimationPhase, AnimationContext };

package/packages/client/types/motion/resize-preview.d.ts

@@ -0,0 +1,26 @@
+import { type MotionHandle } from './animate';
+import { type SizeProperty } from './size';
+type ResizePreviewOptions = {
+    region: HTMLElement;
+    content: HTMLElement;
+    axis: 'x' | 'y';
+    direction: 'positive' | 'negative';
+    track: {
+        element: HTMLElement;
+        property: Extract<SizeProperty, 'flexBasis' | 'gridTemplateColumns'> | `--${string}`;
+        value(size: number): string;
+    };
+    collapsedSize: number;
+    render(): void;
+};
+/** Threshold motion owns presentation; the resize owner keeps its committed layout. */
+declare const createResizePreview: ({ region, content, axis, direction, track, collapsedSize, render }: ResizePreviewOptions) => {
+    readonly moving: boolean;
+    readonly collapsed: boolean;
+    begin(size: number): void;
+    update: (size: number, nextCollapsed: boolean) => void;
+    commit(): MotionHandle;
+    cancel(): void;
+};
+export { createResizePreview };
+export type { ResizePreviewOptions };

package/packages/client/types/motion/resize.d.ts

@@ -1,11 +1,13 @@
 import { type MotionHandle } from './animate';
-import { type MotionRoleName, type MotionKeyframes, type MotionSpeed, type MotionTransition } from './recipe';
+import { type MotionKeyframes } from './recipe';
+import { type MotionRoleName, type MotionSpeed, type MotionTransition } from './config';
 import { type MotionSubject } from './subject';
 type ResizeDestination = 'content' | 'collapsed';
 type ResizeOptions = Readonly<{
     from: ResizeDestination;
     measure?: Element | string;
     opacity?: MotionKeyframes<number>;
+    opacityRole?: MotionRoleName;
     role?: MotionRoleName;
     speed?: MotionSpeed;
     target?: Element | string;

package/packages/client/types/motion/size.d.ts

@@ -1,7 +1,8 @@
 import { type MotionHandle } from './animate';
-import { type MotionRoleName, type MotionTransition } from './recipe';
+import { type MotionSettlement } from './owned';
+import { type MotionRoleName, type MotionSpeed, type MotionTransition } from './config';
 import { type MotionSubject } from './subject';
-type SizeProperty = 'flexBasis' | 'height' | 'width';
+type SizeProperty = 'flexBasis' | 'gridTemplateColumns' | 'height' | 'width';
 type SizeScalar = number | string;
 type SizeValue = SizeScalar | readonly SizeScalar[];
 type SizeKeyframes = Partial<Record<SizeProperty, SizeValue>> & {
@@ -11,13 +12,15 @@ type SizeMotionOptions = Readonly<{
     target?: Element | string;
     keyframes: SizeKeyframes;
     role?: MotionRoleName;
+    speed?: MotionSpeed;
+    opacityRole?: MotionRoleName;
     transition?: MotionTransition;
     signal?: AbortSignal | null;
-    cleanup?: () => void;
+    cleanup?: (settlement: MotionSettlement) => void;
 }>;
 /**
  * Owns the narrow layout-size animation exception used by disclosures and measured shells.
- * Callers provide rendered endpoints; this capability owns replacement, abort, reduced motion,
+ * Callers provide CSS layout endpoints; this capability owns replacement, abort, reduced motion,
  * cleanup, and deterministic settlement without per-frame JavaScript style projection.
  */
 declare const animateSize: (subject: MotionSubject, options: SizeMotionOptions) => MotionHandle;

package/packages/client/types/runtime/anchored-popover.d.ts

@@ -8,6 +8,7 @@ type AnchoredPopoverOptions = {
     align: () => PopoverAlign;
     gap: () => number;
     offset: () => number;
+    shiftAxes?: 'alignment' | 'both';
     matchReferenceWidth?: boolean;
     strategy?: Strategy;
 };
@@ -16,15 +17,23 @@ type AnchoredPopover = {
     mount(): void;
     unmount(): void;
     sync(): void;
+    positioned(): Promise<void> | null;
 };
 type AnchoredPopoverSurface = {
     opened(): boolean;
     open(): void;
     close(): void;
     sync(): void;
+    positioned(): Promise<void> | null;
     destroy(): void;
 };
-declare const createAnchoredPopover: ({ reference, floating, position: getPosition, align: getAlign, gap, offset, matchReferenceWidth, strategy, }: AnchoredPopoverOptions) => AnchoredPopover;
+/** Keep an unpositioned surface hidden without taking over its transition lifecycle. */
+declare const createPopoverVisibility: (floating: () => HTMLElement) => {
+    pending: () => boolean;
+    defer(): void;
+    reveal(): boolean;
+};
+declare const createAnchoredPopover: ({ reference, floating, position: getPosition, align: getAlign, gap, offset, shiftAxes, matchReferenceWidth, strategy, }: AnchoredPopoverOptions) => AnchoredPopover;
 declare const createAnchoredPopoverSurface: (options: AnchoredPopoverOptions) => AnchoredPopoverSurface;
-export { createAnchoredPopover, createAnchoredPopoverSurface };
+export { createAnchoredPopover, createAnchoredPopoverSurface, createPopoverVisibility };
 export type { AnchoredPopover, AnchoredPopoverOptions, AnchoredPopoverSurface, PopoverAlign, PopoverSide };

package/packages/client/types/runtime/collection-navigation.d.ts

@@ -1,8 +1,8 @@
 type CollectionRoot = HTMLElement | null;
 type CollectionNavigationOptions = {
     root: () => CollectionRoot;
-    itemSelector: string;
-    ownsItem?: (el: HTMLElement) => boolean;
+    input?: () => HTMLInputElement | null;
+    onActiveChange?: (item: HTMLElement | null, key: string | null) => void;
     activeAttribute?: string;
     isDisabled?: (el: HTMLElement) => boolean;
     loop?: boolean | (() => boolean);
@@ -17,6 +17,13 @@ type CollectionKeydownOptions = {
     event: KeyboardEvent;
 };
 type CollectionNavigation = {
+    readonly active: string | null;
+    readonly activeItem: HTMLElement | null;
+    resolveItem(element: Element): HTMLElement | null;
+    refresh(): void;
+    destroy(): void;
+    registerItem(el: HTMLElement, key?: string): () => void;
+    reconcileItems(items: HTMLElement[]): void;
     allItems(): HTMLElement[];
     items(): HTMLElement[];
     currentActiveIndex(options?: CollectionItemsOptions): number;
@@ -29,6 +36,7 @@ type CollectionNavigation = {
     focusLast(): void;
     handleKeydown(options: CollectionKeydownOptions): boolean;
 };
-declare const createCollectionNavigation: ({ root: getRoot, itemSelector, ownsItem, activeAttribute, isDisabled, loop, }: CollectionNavigationOptions) => CollectionNavigation;
-export { createCollectionNavigation };
+declare const collectionIndex: (current: number, count: number, direction: 1 | -1, loop: boolean) => number;
+declare const createCollectionNavigation: ({ root: getRoot, input, onActiveChange, activeAttribute, isDisabled, loop, }: CollectionNavigationOptions) => CollectionNavigation;
+export { collectionIndex, createCollectionNavigation };
 export type { CollectionElementOptions, CollectionItemsOptions, CollectionKeydownOptions, CollectionNavigation, CollectionNavigationOptions, };

package/packages/client/types/runtime/control-size.d.ts

@@ -0,0 +1,4 @@
+declare const CONTROL_SIZES: readonly ["xs", "sm", "md", "lg", "xlg"];
+type ControlSize = typeof CONTROL_SIZES[number];
+export { CONTROL_SIZES };
+export type { ControlSize };