Namespace Velvet

Namespaces

Velvet.Experimental

Classes

AnchoredSettings: The 3D Transform an Anchored element's screen position tracks, plus the camera whose projection drives it (null resolves to UnityEngine.Camera.main on every tick, so a scene's active camera can change without a settings update), a pixel offset applied after projection, an opt-in physics occlusion test, and an opt-in camera-distance scale factor. The constructor fail-fasts on a non-positive or NaN DistanceFactor so every construction path (the factory, wrapper hosts, direct construction) shares one guard; a with expression bypasses it like any record init.

AnimateControls: A running animation or sequence from Animator: Framer Motion's animation controls.

AnimatePresenceNode: Container node that manages mount / unmount animations of its children. When keyed children become null, it does not delete them immediately and retains them until the exit animation completes. A keyed child is kept while the exits of the Motions under it play, however deep they sit; the Exits section of Documentation~/motion.md owns which Motions play one. A keyed FragmentNode is accepted as a child: its first Motion is the child's anchor and every element it places stays until the exits of its Motions finish. Children without a key receive a position-based automatic key, so reordering can cause unintended exit / enter animations. Set explicit keys on children that participate in animation.

Animator: What UseAnimate() returns for animating elements inside its scope, Framer Motion's animate of useAnimate. Animations are cancelled when the scope's component unmounts.

BaseElementNode: Base class shared by ElementNode and MotionNode. ClassNames / Children / Events default to empty arrays so derived nodes can omit them when unused.

BlockerFunctionArgs: What a navigation Blocker's predicate is asked about: React Router's BlockerFunction argument.

BlurBinding

ChangeEventBinding<T>: Binding for BaseField<T>.RegisterValueChangedCallback events.

ChoicesSettings: List of choices for DropdownField / RadioButtonGroup.

ClickedBinding: Binding for the Button.clicked event.

ClickedEvent: The click a ClickedEventBinding handler receives, carrying React's preventDefault(): V.Link and V.NavLink skip their navigation for a click a handler bound ahead of it prevented, as React Router's Link does.

ClickedEventBinding: Binding for a click on a Button whose handler receives the click, React's onClick with its event. The bindings of this kind on one button share one ClickedEvent per click and run in the order they were bound, so a handler sees what an earlier one did to it.

ComponentAttribute: Registers a static method returning VNode as a Velvet function component.

ComponentContext<T>: Typed context definition that lets a value be supplied by an ancestor Provider and read by any descendant via UseContext. Holds the default value returned when no Provider is configured.

ComponentFiber: Identity that persists across re-renders for one component instance. Forms a parent/child linked-list tree via Parent / Child / Sibling pointers, and holds hook slots / context dependencies / refs / error boundary / suspense boundary.

ComponentMethodRegistry: Process-global registry of methods annotated with [Component(IsErrorBoundary = true)] and [Component(DisplayName = "...")]. Populated at startup by registration calls MetadataRegistrationWeaver injects into the assembly's module initializer at build time; consumed by V.Component on every render and by hook-rule violation paths.

ComponentNode: Node that embeds a child component into a VNode tree. Holds the function-style component ([Component] static VNode) as a Body delegate and its function identity (MethodInfo) in Identity.

ContextProviderNode: Non-generic base for a Context Provider.

ContextProviderNode<T>: Node that provides a context value to a subtree, read by descendants via UseContext.

Deferred<T>: A value a loader hands back before it has it: React Router's unawaited promise in loader data. A loader returns it inside its data so the navigation commits without waiting for it, and the route reads it through V.Await beneath a V.Suspense, which shows its fallback until the value arrives. Any number of V.Await may read one.

DndAccessibility: A scope's screen-reader settings, dnd-kit's accessibility prop. Announcements null means Default. Announce receives each announcement; null sends it to UnityEngine.Accessibility.AssistiveSupport.notificationDispatcher while a screen reader is enabled, where dnd-kit writes it into an ARIA live region.

DndAnnouncements: The text DndAccessibility hands the screen reader for each drag event, dnd-kit's announcements. A null function, or one returning null, announces nothing for that event. Default carries dnd-kit's default English sentences.

DndAutoScroll: Scrolling the ScrollViews around the drag while the pointer nears their edges, dnd-kit's autoScroll. Within ThresholdX or ThresholdY (a fraction of the view's size per axis) of an edge the view scrolls toward it, faster the closer the pointer is, at up to Acceleration px per IntervalMs, and only in a direction the pointer has moved in since the drag started. A drag DndKeyboardSensor drives never auto-scrolls.

DndCollisions: The built-in collision strategies: RectIntersection, ClosestCenter, ClosestCorners and PointerWithin. Each is a pure function over a DndCollisionQuery (no panel access) returning every colliding droppable ranked best first, with the same ranking value, rounding and tie order as the algorithm of the same name in @dnd-kit/core (packages/core/src/utilities/algorithms), computed in double precision from the rects' float edges as it computes in JavaScript numbers. The context takes the first entry as the over target. None of them consider occlusion; all are rect-based only.

DndContextSettings: Drag-and-drop scope configuration. All callbacks are optional; CollisionDetection null means RectIntersection; Activation is the scope-wide default a per-draggable override wins over.

DndContextState: What Hooks.UseDndContext returns: the drag the nearest V.DndContext holds, dnd-kit's public context. Active is null while no drag is active; ActiveNodeRect is the source's rect at activation, panel space.

DndDropAnimation: How a V.DragOverlay returns to its source when the drag ends or is cancelled, dnd-kit's dropAnimation: the overlay moves from where it was to the source's settled position over DurationMs with CSS ease timing while the source is held at opacity 0, then hides. A zero duration, or an overlay already over the source, hides at once.

DndKeyboardCodes: The keys DndKeyboardSensor starts, cancels and ends a drag with.

DndKeyboardSensor: dnd-kit's KeyboardSensor: a start key on a draggable that holds keyboard focus, or contains the element that does, starts a drag; until an end or cancel key, each other key the CoordinateGetter answers moves it. The default getter moves 25 px per arrow key.

DndModifiers: The modifiers dnd-kit's @dnd-kit/modifiers ships.

DndMonitorListener: The callbacks Hooks.UseDndMonitor registers with the nearest V.DndContext, each called after the context's own callback of the same name, as dnd-kit's useDndMonitor is.

DndPointerSensor: dnd-kit's PointerSensor: a primary-button press starts the drag under Activation, or under the scope's activation: when this is null. A draggable's own activation: wins over both.

DndSensor: An input source that can start a drag, dnd-kit's sensor. A scope offers each pointer-down and key-down that reaches one of its enabled draggables to its sensors in order (Sensors), and the first whose TryActivate(EventBase, DndSensorActivation) returns true takes the event. A press or key that lands inside a nested draggable, or inside a NoDrag element, is offered to the innermost draggable only.

DndSensorActivation: What a sensor is handed with the event it may claim.

DndSensorSession: The drag a sensor started, which the sensor drives until it ends.

DndSensors: The sensors a scope uses when it names none.

DndSortable: Helpers of dnd-kit's @dnd-kit/sortable.

DndSortingStrategies: The sorting strategies dnd-kit's @dnd-kit/sortable ships.

DragActivation: Constraint before a press becomes a drag. Distance is panel px of travel before activation; zero (the default, and None) makes the press itself the drag, as dnd-kit's PointerSensor does with no constraint — so a press on a draggable control is a drag and not a click. A DelaySec > 0 switches from distance-based to hold-to-drag activation: activation happens after the hold, aborted if the observed travel exceeds Tolerance first.

DragCancelArgs: Fired when a drag aborts without a drop: Escape, a pointer cancel, a lost pointer capture, or the source/scope unmounting mid-drag.

DragEndArgs: Fired on release. Over is null when dropped on nothing; state written here flushes synchronously, like any discrete input handler. Collisions is the strategy's full ranking at the last pointer move, empty when the drag ended before one.

DragMoveArgs: Fired on every move of an active drag, before an onDragOver the same move causes, as dnd-kit's onDragMove is. Over is the target the drag was over before this move and Collisions the strategy's ranking at this move.

DragOverArgs: Fired when the winning drop target CHANGES (including to null — leaving all targets). Delta is the total panel-space translation since the press. Collisions is the strategy's full ranking at that move, as dnd-kit's event carries collisions.

DragOverlaySettings: Marker settings for the V.DragOverlay positioner element (framework-positioned, picking-ignored, hidden while no drag is active). Carried on props so the overlay rides the same binding lifecycle as every other element binding.

DragStartArgs: Fired once when a press crosses its activation constraint and becomes a drag. Origin is the pointer's panel-space position at the press.

DraggableInfo: The active drag source, as seen by every context callback.

DraggableSettings: Drag-source configuration. The element carrying the setting is the drag node itself.

DroppableInfo: A drop target, as seen by the over/end callbacks.

DroppableSettings: Drop-target configuration. WhileOverClass applies while this target is the winning collision; WhileDragActiveClass applies to every enabled candidate while any drag is live in scope.

ElementNode: Node corresponding to a VisualElement (the host primitive, e.g. div, button).

ErrorBoundaryReset: An error boundary's reset — react-error-boundary's resetErrorBoundary. One instance per boundary, reference-stable for the boundary's lifetime; it converts to an System.Action that invokes it with no arguments, so it can be passed as an onClick.

ErrorBoundaryResetDetails: Handed to the onReset of UseErrorBoundaryReset(object?[]?, Action<ErrorBoundaryResetDetails>?) before the boundary resets, as react-error-boundary hands its onReset the reset's details.

ErrorInfo: Diagnostic data passed to Hooks.UseFallback's 2-arg overload and to OnCaughtError when an Error Boundary catches a descendant's exception, and to OnUncaughtError when none does.

ErrorResponse: An error a route renders with a status, as React Router's ErrorResponse: the 404 a navigation to a path no route matches commits. Hooks.UseRouteError returns it to the errorElement that renders it.

FiberDispatchedEventBinding: Base for the bindings that take React's on…Capture form: pointer down, up and move, wheel, key, focus in and out, focus and blur. The enter and leave bindings derive from FiberEventBinding instead, as React's onPointerEnter and onPointerLeave have no capture form, and so does the geometry binding, which has no React counterpart at all.

FiberElementProps: Type-safe property bag for a VNode (text, tooltip, enabled/visible, field value, and element-specific settings), passed as the props: argument of the V.* factories.

FiberEventBinding: Abstract base for event bindings. Uses an "unbind all → bind all" diff strategy (event count is typically 1-3, so this is lightweight).

FiberPortalRegistry: Registry that registers and retrieves the destination VisualElement for a Portal. A Portal renders its children into the container looked up here by id, rather than into its own position in the tree. Not thread-safe (main thread only).

FocusBinding

FocusInBinding

FocusManager: Moves focus among the focusable descendants of the focus scope around the component that called Hooks.UseFocusManager, in hierarchy order — React Aria's FocusManager. A field such as a TextField or a Toggle is one element. The scope is the nearest V.FocusScope or FocusScope element prop above the component, a portal's content reaching the scope its portal is declared in. Each method focuses the element it finds and returns it; it returns null, leaving focus where it is, when it finds none or the component is in no scope.

FocusManagerOptions: Options for a FocusManager move, React Aria's FocusManagerOptions.

FocusOutBinding

FocusScopeSettings: Focus-management behavior for a container subtree: Contain, RestoreFocus, and AutoFocus are straightforward toggles; SingleTabStop is the WAI-ARIA composite-widget (roving) contract adapted to UI Toolkit, where arrow/dpad movement inside the group is engine-native 2D navigation. Record structural equality simplifies DiffProps.

FragmentNode: Node that returns multiple nodes without a wrapper element (a Fragment).

GeometryChangedBinding

HookServiceContext: Provides the host IHookServiceResolver to descendant components through the Velvet Provider tree. UseService<T>() reads Ref and throws when no Provider has supplied a resolver.

Hooks: Single entry point for all hooks invoked from a [Component] static VNode body. Hooks may only be called during Render(), unconditionally and in a stable order (the Rules of Hooks). For example, UseState<T>(T) returns the 2-tuple (value, setValue) where setValue is a StateUpdater<T> accepting either a replacement value (setValue.Invoke(next)) or a functional updater (setValue.Invoke(prev => next)).

KeyDownBinding

KeyUpBinding

MemoNode: Node that skips rebuilding its child tree when the dependency array is unchanged. When omitting key, do not change the order of MemoNodes within the same component, since the node is identified by its position in the element it is written into.

MemoizationReportAttribute: Written onto a [Component] method by the build-time compiler transform to record what it made of the body, so that a component cached in part can be inspected as readily as one cached whole. Do not apply by hand.

MemoizeMethodAttribute: Marks a method as a per-method auto-memoization target recognized by the Source Generator. The annotated partial method is expanded into a V.Memoized(...) wrapper.

MotionClock: The time source a mounted tree's motion advances on, chosen per mount through MotionClock: every StyleTransitionConfig play whatever its Type, its DelaySec included, a layoutId move, a filter- transition, the animate- loops, and the delta UseFrame(Action<float>, int) hands its callback. Documentation~/motion.md owns the full scope.

MotionNode: Element node that participates in animations. A variant Initial/Animate pair plays its mount enter on ANY Motion, standalone or under AnimatePresence; Exit requires AnimatePresence (something must defer the unmount for the removal to animate against) and switches CSS classes on unmount based on the transition definition. Inline styles (StyleOverrides) are intentionally not supported. Apply styles via USS classes.

MountOptions: Options passed to Mount(VisualElement, VNode, MountOptions), as React's createRoot takes an options object.

MountedTree: Handle to a tree created by V.Mount. Unmounts on Dispose.

MutableRef<T>: Mutable slot holder with no type constraint, for non-element values held across renders.

MutateOptions<TVariables, TData>: The cancellation token and callbacks passed to one Mutate(TVariables, MutateOptions<TVariables, TData>?) or MutateAsync(TVariables, MutateOptions<TVariables, TData>?) call: TanStack Query's mutate(variables, { onSuccess, onError, onSettled }). The callbacks run after the hook options' own callbacks, once the call's outcome is on the handle, and only while the component is mounted and the call is still the one the handle follows: the component unmounting, a newer call starting and Reset() each drop them. Every context parameter is the call's OnMutate result boxed, and null for the context-free option records.

MutationOptions: Options for a void mutation that takes no input and returns no data. Common for "save current state" / "logout" / "reset" actions where everything is captured in closure.

MutationOptions<TVariables>: Options for a void mutation that takes TVariables input but returns no data. Use this overload when the mutation is fire-and-forget (typical for Store actions that update state internally).

MutationOptions<TVariables, TData>: Options passed to UseMutation<TVariables, TData>(MutationOptions<TVariables, TData>). The MutationFn is the async function invoked by Mutate(TVariables) / MutateAsync(TVariables). For a value carried from before the call to its callbacks, use MutationOptions<TVariables, TData, TContext>. Each callback returns a task the call waits for before the next stage, as TanStack Query awaits the promise its callbacks return; a callback with nothing to wait for returns CompletedTask.

MutationOptions<TVariables, TData, TContext>: Options passed to UseMutation<TVariables, TData, TContext>(MutationOptions<TVariables, TData, TContext>): TanStack Query's onMutate / onSuccess / onError / onSettled quartet. OnMutate runs before MutationFn, and what it returns is the context each later callback of that call receives — the place to snapshot and write an optimistic value, roll it back in OnError, and finish in OnSettled. Where OnMutate throws or its task faults, or the options declare none, the callbacks receive a default context. Every callback returns a task the call waits for before the next stage, OnMutate included, so a context built from a request is the task's result.

MutationResultExtensions: Convenience extensions for mutations that take Unit as input. Allows callers to omit the explicit Unit.Default argument: mutation.Mutate() instead of mutation.Mutate(Unit.Default).

MutationResult<TVariables, TData>: Mutation handle returned by UseMutation<TVariables, TData>(MutationOptions<TVariables, TData>). Exposes Status flags + Data / Error / Variables snapshots + Mutate(TVariables) / MutateAsync(TVariables) / Reset() imperative API.

NavigateOptions: The per-call options of a NavigateFunction: React Router's second argument to navigate, less flushSync and viewTransition, which routing.md lists among its deviations.

NetworkSignals: The application-wide readings of whether the device is online and whether the application is visible, TanStack's online manager and focus manager. A QueryClient refetches its queries when either turns true (RefetchOnReconnect, RefetchOnWindowFocus), and a refetch interval waits while the application is not visible (RefetchIntervalInBackground). A RetryPolicy pauses on the same readings when it supplies none of its own (IsOnline, IsFocused).

NullStoreLogger

ParticlesElement: The element behind Particles(ParticleSystem?, string?, string?, string?, PlayTrigger, float, StyleOverrides?, Func<VisualElement, Action>?, string?, string?, string?, IReadOnlyDictionary<string, string>?, IReadOnlyDictionary<string, string>?, FiberEventBinding[]?): draws a hidden ParticleSystem simulation's baked geometry in its own visual content and in the blend layers over it, or the texture a camera renders of a hidden VisualEffect. A dedicated subclass so a type change to or from any other element remounts instead of patching, and so the element is never recycled through the shared primitive pools while it owns a live simulation host.

ParticlesSettings: The particle effect a Particles element simulates and draws: the source effect (a prefab's ParticleSystem, or a VFX Graph VisualEffect when no ParticleSystem is given — the framework instantiates a hidden host from it and owns that instance), the play trigger, and the world-unit → element-pixel mapping. The constructor fail-fasts on a non-positive or NaN mapping so every construction path shares one guard; a with expression bypasses it like any record init.

PointerDownBinding

PointerEnterBinding

PointerLeaveBinding

PointerMoveBinding

PointerUpBinding

PortalNode: Node that renders children into a different VisualElement registered in FiberPortalRegistry, rather than at their position in the VNode tree. Used when a component's children are logically scoped to it but should be placed near the DOM root, such as modals or overlays.

QueryClient: TanStack Query's QueryClient: a cache of query results keyed by QueryKey, shared by every UseQuery<TQueryFnData, TData>(QueryOptions<TQueryFnData, TData>, QueryClient?) that reaches it. One entry holds one result and at most one request in flight, whichever component started it, and keeps the result after the components reading it unmount, until it is collected. A request in flight is kept too when its query function takes no token; one that does is cancelled when the last component reading the entry leaves, as QueryFn describes.

QueryClientContext: Provides a QueryClient to the UseQuery<TQueryFnData, TData>(QueryOptions<TQueryFnData, TData>, QueryClient?) calls below it: V.Provider(QueryClientContext.Ref, value: client, children: ...), TanStack Query's QueryClientProvider. Read it with Hooks.UseContext(QueryClientContext.Ref) to reach the client from a component, as useQueryClient() does.

QueryClientOptions: Defaults a QueryClient applies to every query that does not set its own, plus the clock it measures staleness and garbage collection against.

QueryFilters: Selects the entries a QueryClient method works on, TanStack Query's query filters. Every property that is set must match: an entry is selected when its key matches, it is of the type asked for, its staleness and fetch status are those asked for, and the predicate accepts it.

QueryKey: Identifies an entry in a QueryClient's cache: TanStack Query's queryKey array. Two keys are equal when they hold the same number of parts and each pair of parts is equal under object.Equals(object, object), so a key rebuilt every render with equal parts names the same entry, and a string, a boxed number or a record or tuple of such values compares by content. A part that is itself a QueryKey compares the same way. A part that is a collection whose type keeps object's own Equals compares by what it holds: an array or a list element by element, in order, as v5's structural hash compares an array; a dictionary by key and value whatever order the entries were added in, as v5 sorts an object's keys before hashing it; a set by element, in any order. A collection type that defines its own equality keeps it.

QueryOptions<T>: QueryOptions<TQueryFnData, TData> for a query whose result holds the data its query function returns.

QueryOptions<TQueryFnData, TData>: Options passed to UseQuery<TQueryFnData, TData>(QueryOptions<TQueryFnData, TData>, QueryClient?): TanStack Query's { queryKey, queryFn } with its enabled, select, placeholderData, staleTime, gcTime, refetchInterval, refetchIntervalInBackground, refetchOnWindowFocus, refetchOnReconnect, retry, retryDelay, structuralSharing and notifyOnChangeProps. QueryOptions<T> is the form without a Select that changes the data's type.

QueryPlaceholder: Ready-made PlaceholderData functions.

QueryResult<T>: What UseQuery<TQueryFnData, TData>(QueryOptions<TQueryFnData, TData>, QueryClient?) returns: the entry's state as this render reads it, TanStack Query's UseQueryResult. Reading a property marks it as one the component depends on, which is what NotifyOnChangeProps leaves to decide when the component re-renders.

QueryState<T>: An entry's state as GetQueryState<T>(QueryKey) reads it, a snapshot that does not follow the entry: TanStack Query's QueryState.

Ref<T>: Reference holder for an element or imperative handle. Receives a VisualElement-derived type via refCallback:, and can also hold any handle interface exposed by UseImperativeHandle.

RefetchOptions: What RefetchQueries(QueryFilters?, RefetchOptions?), ResetQueries(QueryFilters?, RefetchOptions?) and the filter form of InvalidateQueries(QueryFilters?, RefetchOptions?) do with the requests they start: TanStack Query's refetchQueries options.

ResolvedPath: The pathname, search and hash a target resolves to: React Router's Path, as Hooks.UseResolvedPath returns it.

RetryPolicy: Retries a failed async operation: TanStack Query's retry / retryDelay pair as a value an operation opts into. Retry hands one to a mutation; RunAsync<T>(Func<CancellationToken, VelvetTask<T>>, CancellationToken) wraps another operation, such as a Use<T>(Func<CancellationToken, VelvetTask<T>>, object?) loader.

RouteActionContext: What a route's action is called with: React Router's ActionFunctionArgs.

RouteBlockerManager: Coordinates the navigation Blockers registered with a Router.

RouteBlockerState: Observable state for an individual navigation Blocker: React Router's Blocker.

RouteDefinition: A directly constructed route that combines RedirectTo and Guard throws System.InvalidOperationException when its redirect configuration is evaluated during navigation.

RouteLoaderContext: Describes the route matched for a Guard or Loader.

RouteMatch: One level in a parent-first route matching result.

RouteTree: Ranks route branches by specificity before matching; declaration order breaks score ties only. Supports literal, dynamic (:param), optional (:param? / segment?), and splat (*) segments.

Router: Navigation controller: consults its blocker, matches paths against a route tree, runs guards and loaders, and maintains a history stack with Back/Forward. V.RouterProvider publishes one to the routing hooks beneath it.

RouterContext

RouterLocation

SceneViewElement: The element behind SceneView(Camera?, string?, string?, string?, float, StyleOverrides?, Func<VisualElement, Action>?, string?, string?, string?, IReadOnlyDictionary<string, string>?, IReadOnlyDictionary<string, string>?, FiberEventBinding[]?): displays a Camera's output over its content box, from a framework-owned RenderTexture sized to that box, above the element's own background. A dedicated subclass (rather than reusing another element type) so a type change to or from any other element remounts instead of patching, and so the element is never recycled through the shared primitive pools while it owns a live RenderTexture.

SceneViewSettings: The camera a SceneView element displays, plus its render-resolution policy. The framework owns the RenderTexture: it is created at the element's laid-out pixel size (times ResolutionScale), follows geometry changes, and is released on unmount. The constructor fail-fasts on a non-positive or NaN scale so every construction path (the factory, wrapper hosts, direct construction) shares one guard; a with expression bypasses it like any record init.

ScrollViewSettings: Controls ScrollView scroller visibility and touch-scroll behavior.

SearchParams: Mutable ISearchParams implementation that retains key insertion order.

SearchParamsSetter: Updates the current location's query. Navigation defaults to Push.

SliderIntSettings: SliderInt.lowValue / highValue / direction / inverted, and the keyboard step: SliderSettings over whole numbers, with the same undeclared and default rules.

SliderSettings: Slider.lowValue / highValue / direction / inverted, and the keyboard step. Record structural equality simplifies DiffProps. A null Direction or Inverted is undeclared: one no render has declared is not written, and one a render declared and a later render dropped is restored to what the slider carried when a render first declared it. A null bound is written as 0 or 10 whenever either bound's declaration changes. Step is Radix's step, and null is its default of 1.

SortableInfo: A sortable item's place in its V.SortableContext, dnd-kit's data.sortable.

StoreLogger

StoreShallowEqualityComparer

Store<TState>: State container for immutable state, collocated actions, and synchronous change notifications.

StyleBackgroundImageResolver: Parses utility-style arbitrary-value background-image className syntax and applies the result as an inline UnityEngine.UIElements.IStyle.backgroundImage.

StyleClassNames: Central null/empty-safe join point for utility-first class composition, so call sites can pass raw conditional expressions (ternaries, When(bool, string)) as arguments without each one guarding against null or empty branches itself.

StyleFontClass: Parses Velvet's font utility classes — font-<name> (family), font-thin … font-black (weight), italic / not-italic / bold-italic (style), plus the arbitrary font-[…] forms — into a single FontIntent. Mirrors Velvet.StyleGapClass's whole-array, last-wins extraction so it slots into the reconciler the same way. Resolution to actual assets/styles is done by StyleFontResolver.

StyleFontResolver

Applies an element's font utility classes as inline style, resolving family + weight + italic together against the VelvetFonts registry. Setting unityFontDefinition and unityFontStyleAndWeight in one pass is what lets Velvet:

compose font-bold italic into bold-and-italic (impossible from two separate USS classes that share the single -unity-font-style property);
render the full font-thin…font-black scale when weight-specific Font Assets are registered, and gracefully fold to the binary bold/normal threshold when they are not.

Inline styles win over the USS fallback classes in _typography.uss, so this resolver is the authoritative font layer for every Velvet element.

StyleOverrides: Limited set of inline styles applied directly to an element. Intentionally inconvenient to encourage class-based styling.

StyleRecipe: Class-name builder utility with named variant axes. Specify a value for each variant axis (visual, size, etc.) and expand to the corresponding classes.

StyleRecipe.CompoundVariant: Compound variant that applies an extra class when multiple axis conditions all match.

StyleSlotRecipe: Companion to StyleRecipe for components whose variants must drive class names across several independently-styled parts (e.g. a trigger and its listbox) at once, keeping every slot's classes in sync under the same variant selection instead of duplicating a StyleRecipe per part.

StyleSlotRecipe.SlotCompoundVariant: Adds classes to slots when a compound condition matches.

StyleTransition: Predefined transition presets for V.Motion. All presets animate only translate / scale / opacity, so they never trigger a layout recomputation. Override duration / easing per use via With(float?, EasingMode?, EasingMode?, float?), e.g. StyleTransition.Fade.With(durationSec: 0.5f).

StyleTransitionConfig: CSS-transition-based animation configuration for V.Motion. Drives a USS class swap (enter-from → enter-to / exit-from → exit-to); DurationSec / Easing are applied as inline styles. Use the presets on StyleTransition, optionally tuned via With(float?, EasingMode?, EasingMode?, float?).

StyleVariantClass

Parses a state-variant utility token of the form <variant>:<payload> (e.g. hover:bg-blue-500, focus:border-accent, active:w-[200px]).

USS class selectors cannot contain :, so these tokens are never added to the class list; the reconciler routes them to a Velvet.StyleVariantManipulator that toggles the payload when the matching pointer/focus state is active. The payload itself is an ordinary utility — a USS class (bg-blue-500) or an arbitrary value (w-[200px]).

SubmitOptions: How SubmitFunction and SubmitAsync(object?, SubmitOptions?, CancellationToken) submit: React Router's SubmitOptions.

SuspenseNode: Boundary node that displays a fallback when a descendant Use<T> declares pending. Error handling is delegated to an Error Boundary.

TextFieldSettings: TextField.isPasswordField, textEdition.placeholder, maxLength, isReadOnly, isDelayed, multiline, keyboardType and autoCorrection. A null member is undeclared: ApplyTextField(VisualElement, TextFieldSettings) leaves a member no render has declared untouched, and restores what the element was constructed with once a render that did declare one drops it. An empty Placeholder is a declared empty placeholder.

TextNode: Text-only node. Converted to a Label.

UiMatch: One entry of Hooks.UseMatches: a matched route with the data it carries, as React Router's UIMatch.

V: VNode builder DSL. Declarative UI construction API for composing element trees in C#.

VNode: Abstract base for virtual DOM nodes. The smallest unit of a declarative element tree.

VelvetFilters

Registry for user-defined UI Toolkit custom filters consumed by the filter-[name:args] utility. Register a UnityEngine.UIElements.FilterFunctionDefinition under a name, then reference it from any class string:

VelvetFilters.Register("dissolve", dissolveDefinition);
V.Div(className: "filter-[dissolve:0.4]");

Arguments after the name are colon-separated and fill the definition's declared parameters in order, parsed by each slot's declared type — floats (filter-[dissolve:0.4], sign allowed) for float slots and colors (filter-[glow:#ff0000:2]) for color slots; a missing tail is padded from the declaration's defaults, so a bare name (filter-[dissolve]) applies the declared defaults outright. Custom functions compose into the same inline filter list as the built-in blur-/contrast-/… utilities: built-ins first (canonical CSS order), then customs in class order. Registration reaches mounted elements: registering, re-registering or unregistering a name re-resolves every element carrying it, and an element carrying a name nothing is registered under draws no filter, as CSS ignores a filter chain whose url() names no filter. Not thread-safe (main thread only).

VelvetFontFamily

A named font family — the Velvet counterpart of a font-family entry. A family owns one or more VelvetFontWeightEntry slots keyed by VelvetFontWeight, and is selected through the font-<name> utility class (e.g. font-sans → the family named "sans").

Multilingual (CJK / fallback) coverage is a property of the Font Assets themselves: configure the local fallback table on the Font Asset, or the global fallback list on the panel's UITK Text Settings, or name several families in a font-family list (font-[Inter,Noto_Sans_JP]), which appends the later families' assets to the first one's table. TextCore performs the per-glyph fallback at render time.

VelvetFontWeightEntry: One weight slot of a VelvetFontFamily: the upright and italic Font Assets for a single VelvetFontWeight. Each asset can be supplied either as a direct reference (upright / italic) or as an Addressables key (uprightAddress / italicAddress) that VelvetFonts loads and caches on first use. A direct reference always wins over an address.

VelvetFonts

Application-wide font registry backing the font-<name> / font-<weight> utilities. Mirrors VelvetTheme's "global state + change event" shape: register families once at startup and swap the active set at runtime (e.g. on a locale change) — FontsChanged lets the app trigger a re-render so mounted elements re-resolve.

The registry is independent of how the master data is stored. It only consumes VelvetFontFamily values via Register(VelvetFontFamily?) / Register(IEnumerable<VelvetFontFamily>?, string?); producing those from CSV, MasterMemory, a ScriptableObject, or plain code is an adapter concern that lives outside this class.

Font Assets may be supplied directly or by Addressables key; keyed assets are loaded synchronously and cached on first use, the same mechanism StyleBackgroundImageResolver uses for bg-[addr:…].

VelvetKeyframes: The registry behind animate-<name> and animate-[<name><time><timing>_infinite]: keyframe animations, as CSS @keyframes declares them, which an element loops through the same driver as animate-pulse and its siblings. Register before the first render that uses the name.

VelvetResponsive: Public entry points for Velvet's responsive system, for consumers that need to reference its conventions from code rather than only as utility-class strings.

VelvetRuntimeAssets: Holds the package assets a player needs and cannot look up by name.

VelvetStyleUtilities

Resolves and attaches Velvet's bundled utility stylesheet from runtime code, in the editor and in a player alike. Every utility the sheet declares resolves to nothing on a panel that does not carry it, while arbitrary values and the many families Velvet resolves itself rather than declaring are unaffected — so Mount(VisualElement, VNode) and a portal into an element the app owns warn, once per run, when the sheet is missing at their target panel's next update, or at the next update after the target is added to a panel.

Documentation~/setup.md owns when to call this, which utilities sit on which side of that split (with the command that answers it for any one class), and the alternative of referencing the asset from a scene instead.

VelvetTaskCompletionSource

VelvetTaskCompletionSource<T>

VelvetTaskExtensions

VelvetTaskStatusExtensions

VelvetTheme

Global theme state backing the dark: utility variant and the bundled stylesheet's dark token set. This models a class-based dark-mode strategy as a single application-wide flag rather than scanning for an ancestor .dark class (UI Toolkit has no class-change event to react to cheaply); BindThemeTo(VisualElement) projects the flag back onto that class for the roots the sheet is attached to, which is what selects the token set.

Set IsDark from your app (e.g. on a settings toggle); every mounted element with a dark: variant re-evaluates its payload when the value changes.

VirtualListHandle: The imperative API of a mounted VirtualList<T>(IReadOnlyList<T>, Func<T, string>, float, Func<T, VNode>, bool, int, string?, string?, string?, Ref<VirtualListHandle>?, FiberEventBinding[]?), set on the list's listRef — the counterpart of react-window's listRef.

VirtualListNode: List virtualization node for large item collections. Renders a ScrollView of items and keeps only the items in view present in the DOM to ensure performance.

WheelBinding

WorldSpaceNode: A portal into a framework-owned world-space panel positioned by a scene transform — UI that lives among 3D content (depth-tested), unlike the always-on-top screen-space layers. Children stay part of the logical tree (context crosses; events do not — the panel boundary is physical).

Structs

AnimateAt: Where a segment of a sequence starts, as Framer Motion's at: after the previous segment ends (the default), at a time on the sequence's timeline, with the previous segment ("<"), or an offset from the previous segment's end ("+0.5", "-0.2").

AnimateSegment: One entry of a sequence given to Animate(IReadOnlyList<AnimateSegment>).

AnimateValues: The values Animate(VisualElement, AnimateValues, StyleTransitionConfig?) animates, each an array of keyframes as Framer Motion's animate takes them: two or more run through in turn over the transition, and one is a value to animate to from the element's current one. A property left null is left alone.

AnimationSequenceControls: Imperative controls for a sequence started by UseAnimationSequence(IReadOnlyList<AnimationSequenceStep>, object?[]?, bool, bool), Framer Motion's sequence playback controls. They drive the sequence's own timeline — its step cursor and clock — and the Spring and Bezier plays its steps' labels start on a V.Motion handed CurrentTransition: see the motion guide's Timelines section for what each reaches.

AnimationSequenceState: Per-render snapshot of a sequence, returned by UseAnimationSequence(IReadOnlyList<AnimationSequenceStep>, object?[]?, bool, bool).

AnimationSequenceStep: One step in an animation sequence played by UseAnimationSequence(IReadOnlyList<AnimationSequenceStep>, object?[]?, bool, bool). A step is exactly one of: a variant-label change (To(string, StyleTransitionConfig?, float?)), a pure timing gap (Wait(float)), a synchronous C# callback (Call(Action)), or a wait on a task (Await(Func<CancellationToken, VelvetTask>)).

BezierCurve: A CSS cubic-bezier(x1, y1, x2, y2) control-point pair; see BezierX1.

DndCollision: One colliding droppable: its id, its Data, and the value the strategy ranked it by (DndCollisions says which per strategy).

DndCollisionQuery: Everything a collision strategy may consider. Candidates are pre-filtered: in-scope, enabled, attached, on the source's panel or on another runtime panel of the tree (their rects mapped into the source's panel space), and the active draggable's own id excluded unless it is a V.Sortable item (any other element that is both draggable and droppable under one id never collides with itself).

DndDroppableRect: One drop candidate's live rect, as handed to a collision strategy.

DndKeyboardMove: What a DndKeyboardCoordinateGetter reads.

DndModifierArgs: What a DndModifier reads. Every rect is panel space, the source's panel.

DndSortingArgs: What a DndSortingStrategy reads, dnd-kit's sorting strategy arguments.

DndSortingTransform: The translate and scale a sorting strategy gives one item.

DraggableState: What Hooks.UseDraggable returns: dnd-kit's useDraggable state. Transform is the translate the drag applies to this draggable, null unless it is the one being dragged.

DroppableState: What Hooks.UseDroppable returns: dnd-kit's useDroppable state.

ErrorBoundaryApi: What UseErrorBoundary() returns — react-error-boundary's useErrorBoundary() result.

FocusRing: Focus state of the element carrying Ref, returned by Hooks.UseFocusRing. Rides the same focus-visible heuristic as the focus-visible: styling variant, so the two surfaces cannot drift.

FontIntent: The combined font request extracted from an element's class list: a family, a weight, and an italic flag, each tracked with a "was it specified?" companion. Because all three facets are gathered together (rather than applied class-by-class), font-bold italic composes into a single bold-and-italic result — something the raw -unity-font-style property cannot express from two independent classes.

KeyframeStop: One stop of a keyframe animation registered with VelvetKeyframes: the values the animation holds at Offset (0 to 1 through the loop). A property a stop leaves null takes no value there; a property no stop names is not animated, and one that is named between stops starts and ends on the element's own value where no stop at 0 or 1 names it.

MotionVariant: One entry of a V.Motion(variants:) map: the utility-class string naming a pose, plus an optional transition the swap into that pose plays on. A string converts implicitly, so a pose that takes the Motion's own transition: is still written as the class string alone.

NavigateTarget: The target of a NavigateFunction call: a path, or a number of history entries to move by (negative for back). A string or an int converts implicitly, so navigate("/a") and navigate(-1) both read as React Router's.

NavigationState: The navigation in flight, as Navigation holds it and Hooks.UseNavigation returns it: React Router's navigation.

QueryInfo: What a function form of RefetchIntervalFn, RefetchOnWindowFocusFn or RefetchOnReconnectFn is handed: the entry its query reads, as it stands when the function is called. TanStack Query hands these functions its Query; this holds the part of its state they read.

QueryPlaceholder<T>: Data a query shows while it has none of its own, or nothing: what PlaceholderData returns, where TanStack Query's function returns the data or undefined. A value converts to it implicitly, and a null value is no data.

ResolvedFont: Outcome of resolving a (family, weight, italic) request against the VelvetFonts registry. HasAsset tells the caller whether a Font Asset was found; ResidualBold / ResidualItalic are the parts of the request that the chosen asset does NOT already satisfy and therefore must be emulated through -unity-font-style (faux bold / faux italic).

RetryDelayRule: TanStack's retryDelay option as a value: a constant wait, or a function of the failure. A System.TimeSpan converts implicitly, and By(Func<int, Exception, TimeSpan>) takes the function. The default value is the default schedule: one second doubled at each retry, capped at thirty seconds.

RetryRule: TanStack's retry option as a value: a number of retries, every failure, no failure, or a function of the failure. A number or a bool converts implicitly, and When(Func<int, Exception, bool>) takes the function.

SortableState: What Hooks.UseSortable returns, dnd-kit's useSortable state. An index is -1 where there is none: ActiveIndex and OverIndex while no item of this context is dragged or under the drag.

SpringPhysics: A spring's stiffness, damping and mass; see Stiffness.

StateUpdater<T>: The single state setter returned by UseState<T>(T). Accepts either a replacement value (setValue(next)) or a functional updater (setValue(prev => next)). The functional form receives the state the updates written before it produce, so it is safe to invoke from a closure captured by an earlier render (no stale-closure pitfall).

StylePropertyTransition: A single property's transition override inside PropertyOverrides. Any null field falls back to the enclosing config's corresponding top-level value — Easing falls back to the config's EFFECTIVE easing for the direction being played (Easing for an enter, ExitEasing ?? Easing for an exit), matching how the top-level fields already resolve per direction.

StyleSlotClasses: Read-only wrapper from slot name → class name.

TransitionStarter: The startTransition function returned by UseTransition(). Accepts either a synchronous callback (startTransition(() => ...)) or an async one (startTransition(async () => ...)). The state updates the callback schedules before it first suspends are put on the Transition lane, whichever component owns the state they write; for the async form, isPending stays true across awaits until the task completes, while the updates the action makes after an await that suspended it fall outside the scope this call opened — wrap them in a further startTransition to put them back in it. An await of a VelvetTask suspends even where the task had already completed, as JavaScript's does; an await of a completed System.Threading.Tasks.Task does not, so what follows it is still inside the scope — the migration guide's useTransition row owns that rule. Nested calls join the outer transition. An error the callback throws, or the action faults with, is not rethrown to the caller: it is thrown from the declaring component's next Transition-lane render, or dropped once that component has unmounted.

Unit: A type with a single value. Used in generic positions that stand in for "no value" (e.g. MutationResult<TVariables, TData> with no variables or no return value).

VelvetTask

VelvetTask.Awaiter

VelvetTask.SuppressThrowingAwaitable

VelvetTask.SuppressThrowingAwaitable.Awaiter

VelvetTask.SwitchToMainThreadAwaitable

VelvetTask.SwitchToMainThreadAwaitable.Awaiter

VelvetTaskMethodBuilder

VelvetTaskMethodBuilder<T>

VelvetTask<T>

VelvetTask<T>.Awaiter

Interfaces

IHookServiceResolver: Resolver abstraction that fetches services from the host DI container. Decouples DI-framework-specific implementations from the framework core.

IRouteScope: DI container abstraction for a route scope. Resolves services on a per-route basis; the scope is destroyed by Dispose when navigation leaves the route.

IRouteScopeFactory: Factory abstraction that builds route scopes. Decouples DI-framework-specific implementations (such as VContainer) from the framework core.

ISearchParams: Read-only view over URL query parameters that preserves every value of a repeated key. Enumeration yields distinct keys in insertion order.

IStoreWriter<TState>: Minimal write-side interface exposing a store's state-update API to collaborators. Store<TState> implements it explicitly.

Enums

AnimatePresenceMode: How an AnimatePresenceNode sequences exit and enter when its keyed children change.

DragMovement: How an active drag moves its source element. Translate (the default) writes the pointer delta as an inline translate on the source every move; None leaves the source in place — the V.DragOverlay ghost pattern, where only the portal-rendered preview follows the pointer.

ErrorBoundaryResetReason: What reset an error boundary, as react-error-boundary's onReset details name it.

FiberUpdatePriority: Lane priority for a scheduled re-render. The lane is chosen from the scheduling context, not passed as an argument. A UseDeferredValue derivation asks for the Transition lane directly, and a StartTransition call asks for the Urgent lane directly for the render that shows its isPending. A hook-driven state update is classified from its context, tested in this order: the Transition lane while a StartTransition callback is running and has not yet suspended; failing that, the Urgent lane while a discrete event handler runs; failing that, the Normal lane. A starved Transition lane is promoted to Normal. Lower numeric values indicate higher priority; a fiber's lane queue drains lowest-value-first.

FocusScopeOrientation: The axes an arrow/d-pad move may travel inside a singleTabStop group.

LoaderMode: Execution mode for a route loader.

MutationStatus: Lifecycle status of a mutation.

NavigationLifecycle: The phase of the navigation in flight: React Router's navigation.state.

NavigationMode: Controls how a successful navigation changes history.

NavigationResult

NavigationType: How a location was reached: React Router's NavigationType.

NetworkMode: TanStack's networkMode option: whether a lost connection pauses an operation.

PanelFocusOrder: Where the elements of a host panel (V.Portal(layer:) / V.WorldSpace) sit in sequential (Tab/Shift-Tab) focus order. Arrow/2D navigation stays within each panel in every mode.

PlayTrigger: When a Particles element starts its effect.

QueryFetchStatus: Whether an entry has a request in flight: TanStack Query's filter fetchStatus.

QueryProperties: The properties of a QueryResult<T>, for NotifyOnChangeProps: TanStack Query's list of result property names.

QueryRefetchMode: Whether a query fetches again when the application becomes visible or the device comes back online: TanStack Query's refetchOnWindowFocus and refetchOnReconnect given as false, true or 'always'.

QueryStatus: Whether a query has data, TanStack Query's status. Whether a request is in flight is the separate IsFetching, so a query refetching over data it already holds stays Success.

QueryTypeFilter: Which entries a QueryFilters selects by whether a mounted, enabled query reads them: TanStack Query's filter type.

RelativeRoutingType: How a relative to is resolved: React Router's relative option.

RouteBlockerStatus

StyleVariantKind: State-variant kinds for utility classes — the hover: / focus: / active: / disabled: prefixes.

TransitionRepeatType: How each pass after the first of a repeating play runs — Framer Motion's repeatType. See Repeat.

TransitionType: Selects the animation model a StyleTransitionConfig plays with — see Type.

TransitionWhen: Sequences a Motion's own class swap against its inheriting descendants' swaps — see When and StaggerChildrenSec.

UILayer: Framework-managed screen-space layer panels a Portal(UILayer, VNode?[]?, string?, PanelFocusOrder) can target, sorted around the app's main panel. Screen-space panels always composite over the 3D scene (the engine's compositor draws overlay panels after cameras) — UI that must sit among or behind scene geometry is WorldSpace(Vector3, Quaternion?, Vector2?, VNode?[]?, string?, PanelFocusOrder)'s depth-tested territory instead.

VelvetFontWeight

The numeric font-weight scale (font-thin … font-black). The underlying integer value is the CSS weight, so a class such as font-semibold resolves to (int)VelvetFontWeight.SemiBold == 600.

UI Toolkit's -unity-font-style can only express the binary normal/bold axis, so a weight only renders faithfully when a weight-specific Font Asset is registered for it in a VelvetFontFamily. When no such asset exists Velvet folds the weight to the nearest binary value (>= 600 → bold, otherwise normal); see VelvetFonts.

VelvetTaskStatus

VirtualListAlign: Where ScrollToItem(int, VirtualListAlign) places an item in the viewport: react-window's scrollToRow align.

VirtualListScrollBehavior: How ScrollToItem(int, VirtualListAlign) moves the list to its target: react-window's scrollToRow behavior, which it hands to the DOM's scrollTo.

Delegates

DndCollisionDetection: Returns the colliding droppables ranked best first, as dnd-kit's CollisionDetection does; the first entry becomes the over target and an empty array means no collision. Must be pure over the query — it runs on every pointer move of an active drag.

DndKeyboardCoordinateGetter: Where a key moves a keyboard drag to, as a new CurrentCoordinates; null leaves it where it is.

DndModifier: Returns the translate a drag applies, given the one before it, dnd-kit's Modifier.

DndSortingStrategy: Where an item of a V.SortableContext moves while a drag sorts it, dnd-kit's SortingStrategy; null leaves it in place.

NavigateFunction: What Hooks.UseNavigate returns: React Router's navigate. The options apply to a path target and are ignored for a delta, as React Router ignores them.

SubmitFunction: The function Hooks.UseSubmit returns: React Router's SubmitFunction.

Table of Contents