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.

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. Children should preferably be MotionNode. Non-MotionNode children (e.g. ElementNode) also work as transition-less (immediate deletion), but a Debug.LogWarning is emitted because they are not animation targets. TextNode is skipped without a warning. Note: FragmentNode cannot be included directly as a child (it is not expanded). Use MotionNode or a direct VNode. 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.

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

BlurBinding

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

ChoicesSettings: List of choices for DropdownField / RadioButtonGroup.

ClickedBinding: Binding for the Button.clicked event.

ComponentAttribute: Registers a functional component (static VNode XxxComp()) as a Velvet 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. Note: a single wrapper VisualElement is added to the DOM for the Provider (each VNode maps to one DOM element), so consider the impact on USS selectors and layout.

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

DndCollisions: The built-in collision strategies: RectIntersection, ClosestCenter, and PointerWithin. All are pure functions over a DndCollisionQuery (no panel access), returning a single winning id or null rather than a ranked collision list — the context only ever consumes the first collision anyway, and the delegate's return can be extended compatibly later. 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.

DragActivation: Constraint before a press becomes a drag, so clicks keep working on draggable elements. Distance is panel px of travel before activation. 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. The default is Distance = 4, not 0, because a zero threshold would race UI Toolkit's own Clickable capture-at-down and kill clicks on draggable buttons; None restores unconstrained (zero-threshold) activation.

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.

DragOverArgs: Fired when the winning drop target CHANGES (including to null — leaving all targets). Delta is the total panel-space translation since activation.

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 activation.

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).

ErrorInfo: Diagnostic data passed to Hooks.UseFallback's 2-arg overload when an Error Boundary catches a descendant render exception. Carries the caught error together with the component stack of the throwing subtree.

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

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 already 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 identity is resolved by call order.

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.

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.

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.

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).

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.

NavigationAttempt: Describes the transition presented to a navigation Blocker.

NullStoreLogger

OutletNode: Placeholder node that renders the matched child route component of a nested route at this position. Dynamically renders the next child route in the matched route hierarchy based on RouterContext depth.

ParticlesElement: The element behind Particles(ParticleSystem?, string?, string?, string?, PlayTrigger, float, StyleOverrides?, Func<VisualElement, Action>?, string?, string?, string?, IReadOnlyDictionary<string, string>?, IReadOnlyDictionary<string, string>?): draws a hidden ParticleSystem simulation as textured quads in its own visual content. 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 — the framework instantiates a hidden simulation 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.

PureAttribute: Marker attribute used by the Source Generator / Analyzer to treat a method as pure. Velvet can declare purity standalone, without depending on System.Diagnostics.Contracts.PureAttribute or JetBrains Annotations. The declaration is trusted and not verified.

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.

RouteBlockerManager: Coordinates the navigation Blockers registered with a Router.

RouteBlockerState: Observable state for an individual navigation 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: matches paths against a route tree, runs guards / blockers / loaders, and maintains a history stack with Back/Forward. The active instance is exposed as Current.

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>?): displays a Camera's output as its background image, from a framework-owned RenderTexture sized to the element's laid-out rect. 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. While the camera texture is live it owns the element's backgroundImage: every other writer routes through Velvet.SceneViewElement.WriteBackground(UnityEngine.UIElements.VisualElement, UnityEngine.UIElements.StyleBackground), which defers the value instead of clobbering the feed and restores it when the camera releases.

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.

SliderSettings: Slider.lowValue / highValue. Record structural equality simplifies DiffProps.

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]).

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 and isDelayed. 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.

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 at startup (before the consuming tree mounts), 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 is not reactive: a class resolved before its name was registered stays inert until the element's class list changes again. 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. Velvet only selects which family/weight asset to assign — 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:…].

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 — which is why a missing sheet reads as a partial styling bug.

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.

VirtualListNode: List virtualization node for large item collections. Renders a ScrollView of fixed-height 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

AnimationSequenceControls: Imperative controls for a sequence started by UseAnimationSequence(IReadOnlyList<AnimationSequenceStep>, bool, bool, object?[]?).

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

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

DndCollisionQuery: Everything a collision strategy may consider. Candidates are pre-filtered: in-scope, enabled, attached, same panel as the source, and the active draggable's own id excluded (an 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.

FocusRing: Focus state of the element carrying Ref, returned by Hooks.UseFocusRing. Rides the same element-local focus-visible heuristic as the focus-visible: styling variant (a pointer press on the element suppresses the visible state for the focus it causes), 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.

NavigationState: Snapshot of the active navigation exposed by Hooks.UseNavigation, restricted to Idle / Loading.

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).

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 always reads the latest committed value, 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 task that had already completed does not suspend, so what follows it is still inside the scope; the migration guide's useTransition row owns that rule. Nested calls join the outer transition.

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

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.

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; 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.

LoaderMode: Execution mode for a route loader.

MutationStatus: Lifecycle status of a mutation.

NavigationLifecycle: Hooks.UseNavigation reports these phases.

NavigationMode: Controls how a successful navigation changes history.

NavigationResult

PanelFocusOrder: How a host panel (V.Portal(layer:) / V.WorldSpace) participates in sequential (Tab/Shift-Tab) focus order relative to the panel declaring it. Isolated (the default) is the pre-existing behavior: the host panel's focus ring wraps internally and never crosses the panel boundary — the explicit-opt-in stance of the cross-panel navigation decision. Chained joins the declaring panel's Tab order at the portal's call site (iframe semantics): Tab past the host ring's last element exits to the element after the portal's placeholder; Tab reaching the placeholder's position enters the host at its ring-first (Shift-Tab symmetric). Arrow/2D navigation never crosses panels.

PlayTrigger: When a Particles element starts its effect.

RouteBlockerStatus

RouterStatus

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

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

Delegates

DndCollisionDetection: Returns the winning droppable id, or null for no collision. Must be pure over the query — it runs on every pointer move of an active drag.

Table of Contents