@vireo-ai/trellis-ui 0.1.8 → 0.1.10

package/packages/client/types/runtime/engine/stream.d.ts

@@ -5,6 +5,7 @@ type StreamPatchPayload = {
     target?: string | null;
     selector?: string | null;
     mode?: PatchMode | null;
+    viewTransition?: boolean;
 };
 type StreamEventPayload = {
     event: string;
@@ -25,10 +26,15 @@ type SseFrame = {
     event: string;
     data: string;
 };
-type SseFrameHandler = (frame: SseFrame) => void;
 type StreamController = {
     abort(reason?: string): void;
 };
+type StreamLifecycle = {
+    open?(): void;
+    disconnected?(): void;
+    reset?(data: string): void;
+    error?(data: string): void;
+};
 type StreamAlpine = Pick<Alpine.Alpine, 'initTree'> & {
     morph?: (target: HTMLElement, html: string, options?: {
         key?: (el: HTMLElement) => string | null;
@@ -40,9 +46,9 @@ declare const applyStreamPatch: (AlpineInstance: StreamAlpine, payload: StreamPa
 declare const dispatchStreamEvent: (payload: StreamEventPayload) => void;
 declare const applyUiEffect: (AlpineInstance: StreamAlpine, effect: UiEffectPayload) => void;
 declare const applyUiEffects: (AlpineInstance: StreamAlpine, effects: UiEffectPayload | UiEffectPayload[]) => void;
-declare const streamSseFrames: (response: Response, onFrame: SseFrameHandler) => Promise<void>;
 declare const applySseFrame: (AlpineInstance: StreamAlpine, frame: SseFrame) => void;
-declare const connectStream: (AlpineInstance: StreamAlpine, url: string) => StreamController;
+declare const streamUrl: (url: string, scopes?: string, client?: string) => string;
+declare const connectStream: (AlpineInstance: StreamAlpine, url: string, scopes?: string, client?: string, lifecycle?: StreamLifecycle) => StreamController;
 declare const registerStream: (AlpineInstance: Alpine.Alpine) => void;
-export { applyUiEffect, applyUiEffects, applyStreamPatch, applyStreamPatchNow, applyStreamPatches, applySseFrame, connectStream, dispatchStreamEvent, registerStream, streamSseFrames, };
-export type { LocationPayload, PatchMode, SseFrame, SseFrameHandler, StreamAlpine, StreamEventPayload, StreamPatchPayload, UiEffectPayload };
+export { applyUiEffect, applyUiEffects, applyStreamPatch, applyStreamPatchNow, applyStreamPatches, applySseFrame, connectStream, dispatchStreamEvent, registerStream, streamUrl, };
+export type { LocationPayload, PatchMode, SseFrame, StreamAlpine, StreamEventPayload, StreamPatchPayload, UiEffectPayload };

package/packages/client/types/runtime/focus-scope.d.ts

@@ -0,0 +1,7 @@
+declare const FOCUSABLE_SELECTOR: string;
+declare const isFocusable: (el: HTMLElement) => boolean;
+declare const closestFocusable: (el: HTMLElement) => HTMLElement;
+declare const focusableElements: (scope: HTMLElement) => HTMLElement[];
+declare const focusFirst: (scope: HTMLElement) => void;
+declare const trapFocus: (event: KeyboardEvent, scope: HTMLElement) => void;
+export { FOCUSABLE_SELECTOR, closestFocusable, focusFirst, focusableElements, isFocusable, trapFocus };

package/packages/client/types/runtime/identity.d.ts

@@ -0,0 +1,3 @@
+declare const STABLE_KEY_ATTR = "data-ui-key";
+declare const stableIdentity: (element: Element, explicit?: unknown) => string | null;
+export { STABLE_KEY_ATTR, stableIdentity };

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

@@ -1,94 +1,28 @@
 import type Alpine from 'alpinejs';
-export { createAnchoredPopover, type AnchoredPopover, type AnchoredPopoverOptions, type PopoverAlign, type PopoverSide, } from './anchored-popover';
-export { className, cx, type ClassArray, type ClassDictionary, type ClassNameOptions, type ClassValue } from './class-name';
+export { createAlpineMachine, findAlpineMachineOwner, type AlpineMachine, type AlpineMachineOwner, type AlpinePropsChangedEvent, type CreateAlpineMachineOptions, type MachineFactoryScope, } from './alpine-machine';
+export { createAnchoredPopover, createAnchoredPopoverSurface, type AnchoredPopover, type AnchoredPopoverOptions, type AnchoredPopoverSurface, type PopoverAlign, type PopoverSide, } from './anchored-popover';
 export { createCollectionNavigation, type CollectionElementOptions, type CollectionItemsOptions, type CollectionKeydownOptions, type CollectionNavigation, type CollectionNavigationOptions, } from './collection-navigation';
 export { registerConfirm, unregisterConfirm, type ConfirmEventDetail, type ConfirmRuntimeOptions } from './confirm';
-export { create, type CreateOptions, type StyleTree } from './create';
 export { mergeBindings, type BindingInput, type BindingObject, type MergeBindingsOptions } from './merge-bindings';
-export { defineProps, string, number, bool, json, oneOf, type CodecFn, type PropState, type SchemaToProps } from './codecs';
-export { createMachine, createVisibilityMachine, type Machine, type MachineAction, type MachineActionList, type MachineActionRef, type MachineConfig, type MachineEffect, type MachineEvent, type MachineEventObject, type MachineGuard, type MachineOptions, type MachineScope, type MachineStateConfig, type MachineTransition, type VisibilityMachineConfig, } from './machine';
+export { attribute, boundNumber, clampNumber, dataAttributeForProp, dataAttributeForSchemaProp, decodeProps, defineProps, snapNumber, string, number, bool, json, oneOf, type CodecFn, type DecodePropsOptions, type PropState, type SchemaToProps, } from './codecs';
+export { createMachine, type Machine, type MachineConfig, type MachineEffect, type MachineEffectList, type MachineEffectRef, type MachineEntry, type MachineEvent, type MachineEventObject, type MachineGuard, type MachineOptions, type MachineReducer, type MachineReducerList, type MachineReducerRef, type MachineScope, type MachineSnapshot, type MachineStateConfig, type MachineStateValue, type MachineTransition, type MachineTransitionDefinition, type MachineUpdate, } from './state-machine';
 export { addListener, asBool, dispatch, isRtl, removeAttribute, setAttribute, setPresence, type AddListenerOptions, type AttributeOptions, type BoolOptions, type CleanupStack, type DispatchOptions, type ElementOptions, type PresenceOptions, } from '../utils/dom';
 export { addDismissableLayer, type DismissableLayerOptions } from './dismissable-layer';
 export { dispatchNativeControlChange, syncControlPresence, syncNativeControl, syncRepeatedHiddenInputs, type ControlState, type DispatchNativeControlChangeOptions, type HiddenInputState, type NativeControlState, type SyncControlPresenceOptions, type SyncNativeControlOptions, type SyncRepeatedHiddenInputsOptions, } from './form-control';
+export { FOCUSABLE_SELECTOR, closestFocusable, focusFirst, focusableElements, isFocusable, trapFocus } from './focus-scope';
 export { getPathValue, normalizeOptionText, parseItemData, splitControlValues } from './option-data';
-export { createResizable, registerResizable, type ResizableOptions, type ResizeAxis, type ResizeEvent, type ResizeMode, type ResizePhase, } from './resizable';
+export { observeSemanticChanges, type SemanticObserverOptions } from './semantic-observer';
+export { createResizable, registerResizable, type ResizableOptions, type ResizeAxis, type ResizeDirection, type ResizeEvent, type ResizeMode, type ResizePhase, } from './drag-and-drop';
 export { defineManifest, propsFromSchema, type ComponentManifest, type DefineManifestOptions, type ManifestPart, type ManifestProp, type ManifestPropDetails, type ManifestToken, type PropsFromSchemaOptions, type SchemaPropDetails, } from './manifest';
 export { defineStyles, resolveStyle, type DefineStylesOptions, type ResolveStyleOptions, type StyleDefinition, type StylePart, type StyleProps, } from './styles';
 export { del as deleteRequest, get, post, put, registerRequestRuntime, type RequestLifecycleDetail, type RequestMethod, type RequestOptions, type RequestResult, } from './engine/request';
 export { applyStreamPatch, applyStreamPatches, applyUiEffect, applyUiEffects, connectStream, dispatchStreamEvent, registerStream, type PatchMode, type StreamEventPayload, type StreamPatchPayload, type UiEffectPayload, } from './engine/stream';
 export { applyThemeMode, createThemeStore, registerThemeStore, type ResolvedThemeMode, type ThemeChangeDetail, type ThemeStore, type ThemeMode, } from './theme';
 export { lockDocumentScroll, unlockDocumentScroll } from './scroll-lock';
+export { registerUiMagic, ui, type UiRuntime } from './ui';
+export { createTransitionCoordinator, defineHook, type AnyTransitionHook, type TransitionCallback, type TransitionContext, type TransitionCoordinator, type TransitionCoordinatorOptions, type TransitionEventCreator, type TransitionElementResolver, type TransitionHookDefinition, } from './transition-coordinator';
 type TrellisAlpineComponent<T> = Alpine.AlpineComponent<T> & {
     init(): void;
     destroy(): void;
 };
 export type { TrellisAlpineComponent };
-declare const ui: {
-    readonly createAnchoredPopover: ({ reference, floating, position: getPosition, align: getAlign, gap, offset, matchReferenceWidth, }: import("./anchored-popover").AnchoredPopoverOptions) => import("./anchored-popover").AnchoredPopover;
-    readonly createCollectionNavigation: ({ root: getRoot, itemSelector, activeAttribute, isDisabled, loop, }: import("./collection-navigation").CollectionNavigationOptions) => import("./collection-navigation").CollectionNavigation;
-    readonly create: <const T extends Record<string, import("./create").StyleTree>>({ definition }: import("./create").CreateOptions<T>) => Readonly<T>;
-    readonly addDismissableLayer: ({ isEnabled, roots, onDismiss, }: import("./dismissable-layer").DismissableLayerOptions) => (() => void);
-    readonly addListener: ({ target, event, handler, cleanup, options, }: import(".").AddListenerOptions) => (() => void);
-    readonly asBool: ({ value }: import(".").BoolOptions) => boolean;
-    readonly dispatch: <T = unknown>({ el, name, detail }: import(".").DispatchOptions<T>) => void;
-    readonly dispatchNativeControlChange: ({ container, fallback, marker, }: import("./form-control").DispatchNativeControlChangeOptions) => void;
-    readonly isRtl: ({ el }: import(".").ElementOptions) => boolean;
-    readonly removeAttribute: ({ el, attr }: Omit<import(".").AttributeOptions, "value">) => void;
-    readonly setAttribute: ({ el, attr, value }: import(".").AttributeOptions) => void;
-    readonly setPresence: ({ el, attr, present, value }: import(".").PresenceOptions) => void;
-    readonly syncControlPresence: ({ el, state, value, }: import("./form-control").SyncControlPresenceOptions) => void;
-    readonly syncNativeControl: ({ input, state, }: import("./form-control").SyncNativeControlOptions) => void;
-    readonly syncRepeatedHiddenInputs: ({ container, state, currentKey, }: import("./form-control").SyncRepeatedHiddenInputsOptions) => string;
-    readonly getPathValue: (item: unknown, path: string) => unknown;
-    readonly normalizeOptionText: (value: string) => string;
-    readonly parseItemData: (raw: string | undefined) => unknown;
-    readonly splitControlValues: (value: string) => string[];
-    readonly createResizable: ({ element, handle, axis, min, max, step, mode, hitArea, coarseHitArea, disabled, onStart, onResize, onEnd, }: import("./resizable").ResizableOptions) => (() => void);
-    readonly mergeBindings: ({ inputs }: import("./merge-bindings").MergeBindingsOptions) => import("./merge-bindings").BindingObject;
-    readonly createMachine: <TContext>(config: import("./machine").MachineConfig<TContext>, options: import("./machine").MachineOptions<TContext>) => import("./machine").Machine<TContext>;
-    readonly createVisibilityMachine: <TContext>({ enter, exit, }?: import("./machine").VisibilityMachineConfig) => import("./machine").MachineConfig<TContext>;
-    readonly propsFromSchema: <const T extends Record<string, import("./codecs").CodecFn<unknown>>>({ schema, details, }: import("./manifest").PropsFromSchemaOptions<T>) => Record<string, import("./manifest").ManifestProp>;
-    readonly resolveStyle: ({ part, props, className: override, }: import("./styles").ResolveStyleOptions) => string;
-    readonly className: ({ values }: import("./class-name").ClassNameOptions) => string;
-    readonly cx: ({ values }: import("./class-name").ClassNameOptions) => string;
-    readonly motion: {
-        readonly createAnimator: <T extends string | number>(value: import("../motion").MotionValue<T> | T, defaultOptions?: import("../motion").ValueAnimationTransition<T>) => import("..").Animator<T>;
-        readonly parallel: (...handles: import("..").MotionHandle[]) => import("..").MotionHandle;
-        readonly sequential: (...steps: Array<() => import("..").MotionHandle>) => import("..").MotionHandle;
-        readonly bindTransform: <T extends import("..").TransformContext>(element: HTMLElement, values: T, compose: import("..").TransformComposer<T>) => (() => void);
-        readonly bindStyle: <T extends string | number>(element: HTMLElement, property: keyof CSSStyleDeclaration, value: import("../motion").MotionValue<T>, map?: (value: T) => string) => (() => void);
-        readonly withReducedMotion: <T extends import("../motion").AnimationOptions>(options: T, reducedOptions?: Partial<T>, preference?: import("..").MotionPreference) => T;
-        readonly resolveTargets: (scope?: import("..").ViewScope, targets?: import("..").MotionTarget | import("..").MotionTarget[] | null) => Element[];
-        readonly applyViewKeys: (scope?: import("..").ViewScope, options?: {
-            key?: string;
-            layout?: boolean;
-        }) => (() => void);
-        readonly animateView: (update: () => void | Promise<void>, targets?: import("..").MotionTarget | import("..").MotionTarget[] | null, options?: import("..").AnimateViewOptions) => import("..").MotionHandle;
-        readonly animatePresence: (element: Element, phase: import("..").PresencePhase, preset?: import("..").PresenceDefinition, options?: import("..").PresenceOptions) => import("..").MotionHandle;
-        readonly createPresenceLifecycle: ({ element, preset, enter, exit, options, enterOptions, exitOptions, owner, }: import("..").PresenceLifecycleOptions) => import("..").PresenceLifecycle;
-        readonly animateStreamPatch: <AlpineInstance>(_Alpine: AlpineInstance, patchOrPatches: import("../motion/stream").StreamPatchLike | import("../motion/stream").StreamPatchLike[], options?: import("..").AnimateStreamPatchOptions) => import("..").MotionHandle;
-    };
-    readonly get: (url: string | URL, options?: import(".").RequestOptions) => Promise<import(".").RequestResult>;
-    readonly post: (url: string | URL, options?: import(".").RequestOptions) => Promise<import(".").RequestResult>;
-    readonly put: (url: string | URL, options?: import(".").RequestOptions) => Promise<import(".").RequestResult>;
-    readonly delete: (url: string | URL, options?: import(".").RequestOptions) => Promise<import(".").RequestResult>;
-    readonly registerRequestRuntime: (AlpineInstance: Alpine.Alpine | import("./engine").StreamAlpine) => void;
-    readonly applyStreamPatch: (AlpineInstance: import("./engine").StreamAlpine, payload: import(".").StreamPatchPayload) => void;
-    readonly applyStreamPatches: (AlpineInstance: import("./engine").StreamAlpine, payload: import(".").StreamPatchPayload | import(".").StreamPatchPayload[]) => void;
-    readonly applyUiEffect: (AlpineInstance: import("./engine").StreamAlpine, effect: import(".").UiEffectPayload) => void;
-    readonly applyUiEffects: (AlpineInstance: import("./engine").StreamAlpine, effects: import(".").UiEffectPayload | import(".").UiEffectPayload[]) => void;
-    readonly connectStream: (AlpineInstance: import("./engine").StreamAlpine, url: string) => {
-        abort(reason?: string): void;
-    };
-    readonly dispatchStreamEvent: (payload: import(".").StreamEventPayload) => void;
-    readonly applyThemeMode: (mode: import("./theme").ThemeMode) => import("./theme").ThemeChangeDetail;
-    readonly createThemeStore: () => import("./theme").ThemeStore;
-    readonly lockDocumentScroll: () => void;
-    readonly registerConfirm: ({ root }?: import("./confirm").ConfirmRuntimeOptions) => void;
-    readonly registerResizable: (AlpineInstance: Alpine.Alpine) => void;
-    readonly registerStream: (AlpineInstance: Alpine.Alpine) => void;
-    readonly registerThemeStore: (AlpineInstance: Alpine.Alpine) => void;
-    readonly unregisterConfirm: () => void;
-    readonly unlockDocumentScroll: () => void;
-};
-export { ui };

package/packages/client/types/runtime/merge-bindings.d.ts

@@ -1,4 +1,4 @@
-import { type ClassValue } from './class-name';
+import { type ClassValue } from 'clsx';
 type AttributeValue = unknown;
 export type BindingObject = Record<string, AttributeValue>;
 export type BindingInput = ClassValue | BindingObject;

package/packages/client/types/runtime/semantic-observer.d.ts

@@ -0,0 +1,10 @@
+type SemanticObserverOptions<T> = {
+    targets: Element | readonly Element[];
+    read(): T;
+    onChange(value: T, previous: T): void;
+    observer: MutationObserverInit;
+    equals?(left: T, right: T): boolean;
+};
+declare const observeSemanticChanges: <T>({ targets, read, onChange, observer: observerOptions, equals, }: SemanticObserverOptions<T>) => (() => void);
+export { observeSemanticChanges };
+export type { SemanticObserverOptions };

package/packages/client/types/runtime/state-machine/index.d.ts

@@ -0,0 +1,4 @@
+export { createMachine } from './machine';
+export { propsChanged, propsChangedEvent } from './props-change';
+export type { PropsChangedEvent } from './props-change';
+export type { Machine, MachineConfig, MachineEffect, MachineEffectList, MachineEffectRef, MachineEntry, MachineEvent, MachineEventObject, MachineGuard, MachineOptions, MachineReducer, MachineReducerList, MachineReducerRef, MachineScope, MachineSnapshot, MachineStateConfig, MachineStateValue, MachineTransition, MachineTransitionDefinition, MachineUpdate, } from './machine';

package/packages/client/types/runtime/state-machine/machine.d.ts

@@ -0,0 +1,83 @@
+type MachineEventObject = {
+    type: string;
+    [key: string]: unknown;
+};
+type MachineEvent = string | MachineEventObject;
+type MachineStateValue = string | readonly string[];
+type MachineSnapshot<TContext, TProps> = Readonly<{
+    value: MachineStateValue;
+    tags: readonly string[];
+    context: Readonly<TContext>;
+    props: Readonly<TProps>;
+    generations: Readonly<Record<string, number>>;
+}>;
+type MachineEntry<TContext, TProps> = Readonly<{
+    path: string;
+    generation: number;
+    from: MachineStateValue;
+    to: MachineStateValue;
+    event: MachineEventObject;
+    snapshot: MachineSnapshot<TContext, TProps>;
+}>;
+type MachineScope<TContext, TProps> = {
+    snapshot: MachineSnapshot<TContext, TProps>;
+    context: Readonly<TContext>;
+    props: Readonly<TProps>;
+    event: MachineEventObject;
+    state: MachineStateValue;
+};
+type MachineGuard<TContext = unknown, TProps = Record<string, never>> = (scope: MachineScope<TContext, TProps>) => boolean;
+type MachineUpdate<TContext, TProps> = {
+    context?: Partial<TContext>;
+    props?: Partial<TProps>;
+};
+type MachineReducer<TContext = unknown, TProps = Record<string, never>> = (scope: MachineScope<TContext, TProps>) => MachineUpdate<TContext, TProps> | void;
+type MachineEffect<TContext = unknown, TProps = Record<string, never>> = (scope: MachineScope<TContext, TProps>) => void | (() => void);
+type MachineReducerRef<TContext, TProps> = string | MachineReducer<TContext, TProps>;
+type MachineEffectRef<TContext, TProps> = string | MachineEffect<TContext, TProps>;
+type MachineReducerList<TContext, TProps> = MachineReducerRef<TContext, TProps> | MachineReducerRef<TContext, TProps>[];
+type MachineEffectList<TContext, TProps> = MachineEffectRef<TContext, TProps> | MachineEffectRef<TContext, TProps>[];
+type MachineTransitionDefinition<TContext, TProps> = {
+    target?: string;
+    guard?: string | MachineGuard<TContext, TProps>;
+    reduce?: MachineReducerList<TContext, TProps>;
+    effects?: MachineEffectList<TContext, TProps>;
+};
+type MachineTransition<TContext, TProps = Record<string, never>> = string | MachineTransitionDefinition<TContext, TProps>;
+type MachineStateConfig<TContext, TProps = Record<string, never>> = {
+    id?: string;
+    type?: 'compound' | 'parallel' | 'final';
+    initial?: string;
+    tags?: string[];
+    reduce?: MachineReducerList<TContext, TProps>;
+    entry?: MachineEffectList<TContext, TProps>;
+    exit?: MachineEffectList<TContext, TProps>;
+    on?: Record<string, MachineTransition<TContext, TProps> | Array<MachineTransition<TContext, TProps>>>;
+    states?: Record<string, MachineStateConfig<TContext, TProps>>;
+};
+type MachineConfig<TContext, TProps = Record<string, never>> = MachineStateConfig<TContext, TProps> & {
+    initial?: string;
+    states: Record<string, MachineStateConfig<TContext, TProps>>;
+};
+type MachineOptions<TContext, TProps = Record<string, never>> = {
+    context: TContext;
+    props?: TProps;
+    reducers?: Record<string, MachineReducer<TContext, TProps>>;
+    guards?: Record<string, MachineGuard<TContext, TProps>>;
+    effects?: Record<string, MachineEffect<TContext, TProps>>;
+};
+type Machine<TContext, TProps = Record<string, never>> = {
+    readonly state: MachineStateValue;
+    readonly context: Readonly<TContext>;
+    readonly props: Readonly<TProps>;
+    getSnapshot(): MachineSnapshot<TContext, TProps>;
+    send(event: MachineEvent): void;
+    subscribe(listener: (snapshot: MachineSnapshot<TContext, TProps>) => void): () => void;
+    subscribeEntries(listener: (entry: MachineEntry<TContext, TProps>) => void): () => void;
+    matches(state: string): boolean;
+    hasTag(tag: string): boolean;
+    stop(): void;
+};
+declare const createMachine: <TContext, TProps = Record<string, never>>(config: MachineConfig<TContext, TProps>, options: MachineOptions<TContext, TProps>) => Machine<TContext, TProps>;
+export { createMachine };
+export type { Machine, MachineConfig, MachineEffect, MachineEffectList, MachineEffectRef, MachineEntry, MachineEvent, MachineEventObject, MachineGuard, MachineOptions, MachineReducer, MachineReducerList, MachineReducerRef, MachineScope, MachineSnapshot, MachineStateConfig, MachineStateValue, MachineTransition, MachineTransitionDefinition, MachineUpdate, };

package/packages/client/types/runtime/state-machine/props-change.d.ts

@@ -0,0 +1,12 @@
+import type { MachineEventObject } from './machine';
+type PropsChangedEvent<TProps> = MachineEventObject & {
+    type: 'PROPS_CHANGED';
+    props: TProps;
+    changes: ReadonlyArray<{
+        key: keyof TProps;
+    }>;
+};
+declare const propsChangedEvent: <TProps>(event: MachineEventObject) => PropsChangedEvent<TProps> | null;
+declare const propsChanged: <TProps>(event: MachineEventObject, ...keys: Array<keyof TProps>) => boolean;
+export { propsChanged, propsChangedEvent };
+export type { PropsChangedEvent };

package/packages/client/types/runtime/transition-coordinator.d.ts

@@ -0,0 +1,52 @@
+import type { Machine, MachineEvent, MachineEventObject, MachineSnapshot } from './state-machine';
+type TransitionEventCreator = (...args: never[]) => MachineEvent;
+type TransitionSend = ((event: MachineEvent) => void) & {
+    [name: string]: ((...args: unknown[]) => void) | undefined;
+};
+type TransitionHookDefinition<TContext, TProps, TData, TName extends string = string, TSends extends Record<string, TransitionEventCreator> = Record<string, TransitionEventCreator>> = Readonly<{
+    name: TName;
+    state: string;
+    onDone: string;
+    onError: string;
+    required?: boolean;
+    sends?: TSends;
+    project?: (snapshot: MachineSnapshot<TContext, TProps>) => TData;
+    projectEach?: (snapshot: MachineSnapshot<TContext, TProps>) => readonly TData[];
+}>;
+type AnyTransitionHook<TContext, TProps> = TransitionHookDefinition<TContext, TProps, unknown>;
+type TransitionContext<TProps, TData, TElement = unknown> = Readonly<{
+    el: TElement;
+    root: TElement;
+    from: string;
+    to: string;
+    event: MachineEventObject;
+    props: TProps;
+    data: TData;
+    send: TransitionSend;
+    signal: AbortSignal;
+}>;
+type TransitionCallback<TProps, TData, TElement = unknown> = (transition: TransitionContext<TProps, TData, TElement>) => unknown | Promise<unknown>;
+type TransitionCoordinatorOptions<TContext, TProps, TElement> = {
+    machine: Machine<TContext, TProps>;
+    hooks: readonly AnyTransitionHook<TContext, TProps>[];
+    root?: TElement;
+    resolveElement?: TransitionElementResolver<TElement>;
+};
+type TransitionElementResolver<TElement> = (scope: Readonly<{
+    name: string;
+    data: unknown;
+    root: TElement;
+    registrationEl: TElement;
+}>) => TElement | null | undefined;
+type TransitionCoordinator<TProps, TElement = unknown> = {
+    register<TData>(registration: {
+        name: string;
+        el: TElement;
+        callback: TransitionCallback<TProps, TData, TElement>;
+    }): () => void;
+    destroy(): void;
+};
+declare const defineHook: <TContext, TProps, TData, const TName extends string, const TSends extends Record<string, TransitionEventCreator> = Record<string, TransitionEventCreator>>(definition: TransitionHookDefinition<TContext, TProps, TData, TName, TSends>) => typeof definition;
+declare const createTransitionCoordinator: <TContext, TProps, TElement = unknown>({ machine, hooks, root: ownerRoot, resolveElement, }: TransitionCoordinatorOptions<TContext, TProps, TElement>) => TransitionCoordinator<TProps, TElement>;
+export { createTransitionCoordinator, defineHook };
+export type { AnyTransitionHook, TransitionCallback, TransitionContext, TransitionCoordinator, TransitionCoordinatorOptions, TransitionEventCreator, TransitionSend, TransitionElementResolver, TransitionHookDefinition, };

package/packages/client/types/runtime/ui.d.ts

@@ -0,0 +1,15 @@
+import type Alpine from 'alpinejs';
+import { motion } from '../motion';
+import { del, get, post, put } from './engine/request';
+type UiRuntime = {
+    readonly delete: typeof del;
+    readonly get: typeof get;
+    readonly post: typeof post;
+    readonly put: typeof put;
+    readonly isFetching: boolean;
+    readonly motion: typeof motion;
+};
+declare const ui: UiRuntime;
+declare const registerUiMagic: (AlpineInstance: Alpine.Alpine) => void;
+export { registerUiMagic, ui };
+export type { UiRuntime };

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

@@ -1,3 +1,4 @@
 export { addListener, asBool, dispatch, isRtl, removeAttribute, setAttribute, setPresence, type AddListenerOptions, type AttributeOptions, type BoolOptions, type CleanupStack, type DispatchOptions, type ElementOptions, type PresenceOptions, } from './dom';
-export { isRecord } from './object';
+export { cloneSerializable, isPromiseLike, isRecord, isSerializableEqual } from './object';
+export { clamp } from './number';
 export { warn } from './warn';

package/packages/client/types/utils/number.d.ts

@@ -0,0 +1,2 @@
+declare const clamp: (value: number, min: number, max: number) => number;
+export { clamp };

package/packages/client/types/utils/object.d.ts

@@ -1,2 +1,5 @@
 declare const isRecord: (value: unknown) => value is Record<string, unknown>;
-export { isRecord };
+declare const cloneSerializable: <T>(value: T) => T;
+declare const isSerializableEqual: (left: unknown, right: unknown) => boolean;
+declare const isPromiseLike: (value: unknown) => value is PromiseLike<unknown>;
+export { cloneSerializable, isPromiseLike, isRecord, isSerializableEqual };