@radix-ng/primitives 1.0.10 → 1.1.1

package/types/radix-ng-primitives-input.d.ts

@@ -24,6 +24,7 @@ interface RdxInputValueChangeEvent {
 declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | undefined> {
     private readonly element;
     private readonly fieldRootContext;
+    private readonly ngControlState;
     private initialValue;
     private defaultValueApplied;
     private readonly filledValue;
@@ -78,6 +79,8 @@ declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | u
      * @group Props
      */
     readonly invalid: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    /** Whether async validation is pending. Pending inputs publish neither valid nor invalid state. */
+    readonly pending: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /**
      * Whether the input has been touched. A two-way model: the input sets it on
      * blur (emitting `touchedChange`, which Signal Forms' `[formField]` listens
@@ -133,8 +136,11 @@ declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | u
      * @group Emits
      */
     readonly touch: _angular_core.OutputEmitterRef<void>;
-    /** The input's own binary invalidity (its `invalid` input or a non-empty `errors` list). */
+    /** Validation errors from the input and a same-host Reactive/template-driven form control. */
+    readonly validationErrors: _angular_core.Signal<readonly RdxValidationError[]>;
+    /** The input's binary invalidity, including a same-host Reactive/template-driven form control. */
     private readonly ownInvalid;
+    private readonly pendingState;
     /**
      * Tri-state *displayed* validity: inside a `rdxFieldRoot` the field's gated `validState` is the single
      * source (so a field whose `validationMode` defers display (e.g. `onBlur`) keeps the input neutral until revealed), otherwise
@@ -153,11 +159,13 @@ declare class RdxInputDirective implements RdxFormValueControl<RdxInputValue | u
     onFocus(): void;
     onBlur(): void;
     onInput(event: Event): void;
+    /** Reset the interaction baseline; Angular Signal Forms calls this from `FieldState.reset()`. */
+    reset(): void;
     syncFieldState(): void;
     private writeValue;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxInputDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxInputDirective, "input[rdxInput]", ["rdxInput"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "onValueChange": "onValueChange"; "touch": "touch"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxInputDirective, "input[rdxInput]", ["rdxInput"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "pending": { "alias": "pending"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touched": "touchedChange"; "onValueChange": "onValueChange"; "touch": "touch"; }, never, never, true, never>;
 }
 
 export { RdxInputDirective };

package/types/radix-ng-primitives-menu.d.ts

@@ -11,6 +11,29 @@ import * as i1$1 from '@radix-ng/primitives/composite';
 import * as i1$2 from '@radix-ng/primitives/portal';
 import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
 
+/**
+ * Submenu "safe polygon" — a faithful port of Floating UI's `safePolygon` algorithm
+ * (https://floating-ui.com/docs/useHover#safepolygon), adapted to this library.
+ *
+ * While a submenu is open by hover, the parent submenu owns the decision to close itself: a
+ * document-level `mousemove` handler keeps it open as long as the cursor is heading toward the
+ * popup inside a safe quadrilateral (built from the cursor's exit point and the popup rect), and
+ * closes it once the cursor leaves that area. Combined with the pointer-events "tunnel" below
+ * (`applyPointerTunnel`), siblings cannot steal the open submenu during a diagonal traversal.
+ *
+ * Differences from the upstream implementation:
+ * - `elements.domReference` / `elements.floating` → `reference` / `floating` (plain elements).
+ * - `placement.split('-')[0]` → the `side` option (read live from the popup's `data-side`).
+ * - the Floating UI tree (`tree` / `nodeId`) → the `hasOpenChild` callback, backed by the
+ *   module-level open-submenu registry.
+ *
+ * This deliberately does NOT reuse the core `useGraceArea` composable (tooltip / navigation-menu /
+ * popover): that one is a simpler convex-hull grace area with no velocity gating, trough handling, or
+ * pointer-events tunnel — none of which it needs, but all of which the submenu does to match Base UI
+ * and to stop sibling triggers from stealing the open submenu mid-traversal.
+ */
+type MenuSide = 'top' | 'bottom' | 'left' | 'right';
+
 type RdxMenuTransitionStatus = 'starting' | 'ending' | undefined;
 /**
  * Why an open/close happened instantly (no transition). Mirrors Base UI's menu `data-instant`:
@@ -81,6 +104,12 @@ interface RdxMenuRootContext {
     trigger: Signal<HTMLElement | undefined>;
     /** The popup element, once mounted. Used by submenu safe-polygon geometry. */
     popupElement: Signal<HTMLElement | undefined>;
+    /**
+     * The popup's **physical** placed side (`top`/`bottom`/`left`/`right`) for safe-polygon geometry —
+     * never the popup's `data-side`, which is the logical `inline-start`/`inline-end` echo when a logical
+     * side was requested and which the geometry cannot interpret.
+     */
+    popupPhysicalSide: Signal<MenuSide | undefined>;
     beforeContentFocusGuard: Signal<HTMLElement | null>;
     transitionStatus: Signal<RdxMenuTransitionStatus>;
     close: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
@@ -92,7 +121,7 @@ interface RdxMenuRootContext {
     /** Open the menu without moving focus into the popup (used for menubar hover-switching). */
     showWithoutAutoFocus: (reason?: RdxMenuOpenChangeReason, event?: Event) => void;
     registerTrigger: (el: HTMLElement) => () => void;
-    registerPopup: (el: HTMLElement) => () => void;
+    registerPopup: (el: HTMLElement, physicalSide?: Signal<MenuSide | undefined>) => () => void;
     setBeforeContentFocusGuard: (element: HTMLElement | null) => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
     registerPopupArrowNavigationHandler: (handler: (offset: 1 | -1) => boolean) => () => void;
@@ -195,6 +224,9 @@ declare class RdxMenuRoot {
     readonly onOpenChangeComplete: _angular_core.OutputEmitterRef<boolean>;
     readonly trigger: _angular_core.WritableSignal<HTMLElement | undefined>;
     readonly popupElement: _angular_core.WritableSignal<HTMLElement | undefined>;
+    private readonly popupPhysicalSideSource;
+    /** Physical placed side read through the popup's own signal (undefined until the popup is placed). */
+    readonly popupPhysicalSide: Signal<MenuSide | undefined>;
     readonly beforeContentFocusGuard: _angular_core.WritableSignal<HTMLElement | null>;
     readonly transitionStatus: Signal<_radix_ng_primitives_core.RdxTransitionStatus>;
     readonly activeIndex: _angular_core.WritableSignal<number | null>;
@@ -239,7 +271,7 @@ declare class RdxMenuRoot {
      */
     closeEntireMenu(reason?: RdxMenuOpenChangeReason, event?: Event): void;
     registerTrigger(el: HTMLElement): () => void;
-    registerPopup(el: HTMLElement): () => void;
+    registerPopup(el: HTMLElement, physicalSide?: Signal<MenuSide | undefined>): () => void;
     setBeforeContentFocusGuard(element: HTMLElement | null): void;
     registerTransitionElement(element: HTMLElement): () => void;
     registerPopupArrowNavigationHandler(handler: (offset: 1 | -1) => boolean): () => void;
@@ -359,6 +391,15 @@ declare class RdxMenuSubTrigger {
     protected onArrowLeft(event: Event): void;
     protected onPointerMove(event: PointerEvent): void;
     protected onPointerLeave(): void;
+    /**
+     * Backup cancellation for a `pointerleave` that Chrome can drop during a fast pointer sweep across
+     * adjacent triggers, which would otherwise leave the delayed hover-open armed and open a stale
+     * submenu for a trigger the pointer has already left (stranding the parent at `pointer-events: none`).
+     * `pointerout` bubbles, so it also fires while crossing between the trigger's own descendants — those
+     * (where `relatedTarget` is still inside the trigger) must not cancel the pending open. Base UI parity
+     * (`guardStaleOpen`); safe on this single, hover-driven trigger.
+     */
+    protected onPointerOut(event: PointerEvent): void;
     protected clearHighlight(): void;
     private closeSiblingSubmenus;
     private clearSiblingHighlights;
@@ -433,7 +474,7 @@ declare class RdxMenuPopup {
     private search;
     private searchTimer;
     protected readonly align: _angular_core.Signal<"center" | "end" | "start" | undefined>;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1.SideOrLogical | undefined>;
     /**
      * Event handler called when the escape key is pressed. Can be prevented.
      */
@@ -520,7 +561,7 @@ declare class RdxMenuBackdrop {
 declare class RdxMenuArrow {
     protected readonly rootContext: _radix_ng_primitives_menu.RdxMenuRootContext;
     private readonly wrapper;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1.SideOrLogical | undefined>;
     protected readonly align: _angular_core.Signal<"center" | "end" | "start" | undefined>;
     protected readonly uncentered: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxMenuArrow, never>;

package/types/radix-ng-primitives-navigation-menu.d.ts

@@ -383,7 +383,7 @@ declare class RdxNavigationMenuPopup {
     private readonly registration;
     private readonly wrapper;
     private readonly elementRef;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1$1.SideOrLogical | undefined>;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
     protected readonly id: _angular_core.Signal<string>;
     /**
@@ -420,7 +420,7 @@ declare class RdxNavigationMenuPopup {
 declare class RdxNavigationMenuArrow {
     protected readonly rootContext: _radix_ng_primitives_navigation_menu.RdxNavigationMenuRootContext;
     private readonly wrapper;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1$1.SideOrLogical | undefined>;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
     protected readonly uncentered: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxNavigationMenuArrow, never>;

package/types/radix-ng-primitives-number-field.d.ts

@@ -106,9 +106,9 @@ declare class RdxNumberFieldRoot extends RdxFormUiControlBase implements RdxForm
      * @default false
      */
     readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    /** Name of the hidden input rendered by `[rdxNumberFieldHiddenInput]`, for form submission. */
+    /** Name used when serializing this field into native `FormData`. */
     readonly name: _angular_core.InputSignal<string | undefined>;
-    /** Id of the form the hidden input belongs to. Useful when it is rendered outside the form. */
+    /** Id of an external form that owns this field. */
     readonly form: _angular_core.InputSignal<string | undefined>;
     /** The uncontrolled value of the field when it is initially rendered. */
     readonly defaultValue: _angular_core.InputSignal<number | undefined>;
@@ -127,6 +127,8 @@ declare class RdxNumberFieldRoot extends RdxFormUiControlBase implements RdxForm
     readonly isScrubbing: _angular_core.WritableSignal<boolean>;
     /** @ignore The native input element, registered by `[rdxNumberFieldInput]`. */
     readonly inputEl: _angular_core.WritableSignal<HTMLInputElement | undefined>;
+    /** @ignore Optional native number input that owns constraints/autofill and form serialization. */
+    readonly nativeInputEl: _angular_core.WritableSignal<HTMLInputElement | null>;
     /**
      * @ignore Gate that prevents the formatted value from overwriting in-progress typing.
      * Plain field (not a signal): it is toggled imperatively inside event handlers.
@@ -148,6 +150,7 @@ declare class RdxNumberFieldRoot extends RdxFormUiControlBase implements RdxForm
     private readonly parser;
     /** @ignore The current numeric value (`null` when empty). */
     readonly currentValue: _angular_core.Signal<number | null>;
+    private readonly nativeFormControl;
     /** @ignore */
     readonly minWithDefault: _angular_core.Signal<number>;
     /** @ignore */
@@ -174,6 +177,8 @@ declare class RdxNumberFieldRoot extends RdxFormUiControlBase implements RdxForm
     }): number;
     /** @ignore Registers the native input element. */
     registerInput(el: HTMLInputElement): void;
+    /** @ignore Registers the optional native constraint/autofill input. */
+    registerNativeInput(el: HTMLInputElement | null): void;
     /** @ignore Sets the displayed text without changing the numeric value. */
     setInputValue(text: string): void;
     /**
@@ -241,14 +246,16 @@ declare class RdxNumberFieldInput {
 }
 
 /**
- * The hidden native `input[type=number]` that mirrors the field value for native form submission
- * and browser constraint validation (min/max/step/required). Place it inside the root, alongside
- * the visible `[rdxNumberFieldInput]`.
+ * The optional hidden native `input[type=number]` that mirrors the field value for browser constraint
+ * validation (min/max/step/required) and autofill. When present it also owns native form serialization;
+ * without it the root generates a plain hidden entry. Place it inside the root, alongside the visible
+ * `[rdxNumberFieldInput]`.
  *
  * @see https://base-ui.com/react/components/number-field
  */
 declare class RdxNumberFieldHiddenInput {
     protected readonly rootContext: _radix_ng_primitives_number_field.RdxNumberFieldRoot;
+    constructor();
     /** Move focus to the visible input when the hidden one is focused (e.g. via form validation). */
     onFocus(): void;
     /** Handle browser autofill, which writes directly to the hidden numeric input. */

package/types/radix-ng-primitives-popover.d.ts

@@ -304,7 +304,7 @@ declare class RdxPopoverPopup {
     private readonly focusScope;
     private readonly wrapper;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1$1.SideOrLogical | undefined>;
     /** Event handler called when the escape key is down. Can be prevented. */
     readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
     /** Event handler called when a pointerdown event happens outside of the popup. Can be prevented. */
@@ -328,7 +328,7 @@ declare class RdxPopoverPopup {
 declare class RdxPopoverArrow {
     protected readonly rootContext: _radix_ng_primitives_popover.RdxPopoverRootContext;
     private readonly wrapper;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1$1.SideOrLogical | undefined>;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
     protected readonly uncentered: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopoverArrow, never>;

package/types/radix-ng-primitives-popper.d.ts

@@ -1,8 +1,9 @@
 import * as _angular_core from '@angular/core';
 import { ElementRef, Signal, Provider, Type, InjectionToken } from '@angular/core';
 import { ReferenceElement, Placement, Middleware, VirtualElement } from '@floating-ui/dom';
+import * as _radix_ng_primitives_popper from '@radix-ng/primitives/popper';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { NumberInput, BooleanInput } from '@radix-ng/primitives/core';
+import { Direction, NumberInput, BooleanInput } from '@radix-ng/primitives/core';
 
 declare class RdxPopperAnchor {
     readonly elementRef: ElementRef<HTMLElement>;
@@ -25,7 +26,8 @@ declare class RdxPopperContent {
      * simply no-op.
      */
     protected readonly popperContentWrapper: {
-        placedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+        placedSide: _angular_core.Signal<_radix_ng_primitives_popper.SideOrLogical | undefined>;
+        physicalPlacedSide: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
         placedAlign: _angular_core.Signal<"start" | "center" | "end" | undefined>;
         arrowX: _angular_core.Signal<number | undefined>;
         arrowY: _angular_core.Signal<number | undefined>;
@@ -48,6 +50,23 @@ declare const SIDE_OPTIONS: readonly ["top", "right", "bottom", "left"];
 declare const ALIGN_OPTIONS: readonly ["start", "center", "end"];
 type Side = (typeof SIDE_OPTIONS)[number];
 type Align = (typeof ALIGN_OPTIONS)[number];
+/** Logical (writing-direction-relative) inline sides, resolved to a physical {@link Side} by text direction. */
+type LogicalSide = 'inline-start' | 'inline-end';
+/** A physical {@link Side} or a {@link LogicalSide} — accepted by the positioner's `side` input. */
+type SideOrLogical = Side | LogicalSide;
+/**
+ * Resolve a logical inline side to a physical one for the current text direction; physical sides pass
+ * through unchanged (Base UI `useAnchorPositioning`). `inline-start` is the reading-start edge
+ * (`left` in LTR, `right` in RTL); `inline-end` is the reading-end edge.
+ */
+declare function resolvePhysicalSide(side: SideOrLogical, isRtl: boolean): Side;
+/**
+ * Report a rendered physical side back in the same "kind" the consumer requested (Base UI
+ * `getLogicalSide`): when a logical side was requested, a `left`/`right` rendered side is mapped back
+ * to `inline-start`/`inline-end` for the direction (so a post-collision flip surfaces logically); a
+ * physical request, or a `top`/`bottom` rendered side, passes through unchanged.
+ */
+declare function toLogicalSide(requestedSide: SideOrLogical, renderedSide: Side, isRtl: boolean): SideOrLogical;
 /**
  * How the popper avoids collisions with the boundary edges (Base UI `collisionAvoidance`).
  *
@@ -72,11 +91,12 @@ type ResolvedCollisionAvoidance = Required<RdxCollisionAvoidance>;
 /**
  * Function form of `sideOffset` / `alignOffset` (Base UI `OffsetFunction`). Receives the resolved
  * placement and the measured anchor / positioner dimensions, and returns the offset in pixels — e.g.
- * `({ anchor }) => anchor.width` to offset by the trigger's own width. `side` is the physical side the
- * popup is placed against.
+ * `({ anchor }) => anchor.width` to offset by the trigger's own width. `side` is the side the popup is
+ * placed against — reported logically (`inline-start` / `inline-end`) when a logical side was
+ * requested, otherwise physical (Base UI parity).
  */
 type OffsetFunction = (data: {
-    side: Side;
+    side: SideOrLogical;
     align: Align;
     anchor: {
         width: number;
@@ -96,7 +116,8 @@ declare function getSideAndAlignFromPlacement(placement: Placement): readonly ["
 
 type RdxPopperAnchorElement = Element | ElementRef<Element> | VirtualElement | (() => Element | VirtualElement | null) | null | undefined;
 declare const context: () => {
-    placedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedSide: Signal<SideOrLogical | undefined>;
+    physicalPlacedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
     placedAlign: Signal<"start" | "center" | "end" | undefined>;
     arrowX: Signal<number | undefined>;
     arrowY: Signal<number | undefined>;
@@ -106,7 +127,8 @@ declare const context: () => {
 };
 type PopperContentWrapperContext = ReturnType<typeof context>;
 declare const injectPopperContentWrapperContext: _radix_ng_primitives_core.InjectContext<{
-    placedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedSide: Signal<SideOrLogical | undefined>;
+    physicalPlacedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
     placedAlign: Signal<"start" | "center" | "end" | undefined>;
     arrowX: Signal<number | undefined>;
     arrowY: Signal<number | undefined>;
@@ -115,7 +137,8 @@ declare const injectPopperContentWrapperContext: _radix_ng_primitives_core.Injec
     anchorHidden: Signal<boolean>;
 }>;
 declare const providePopperContentWrapperContext: (useFactory: () => {
-    placedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    placedSide: Signal<SideOrLogical | undefined>;
+    physicalPlacedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
     placedAlign: Signal<"start" | "center" | "end" | undefined>;
     arrowX: Signal<number | undefined>;
     arrowY: Signal<number | undefined>;
@@ -136,8 +159,21 @@ declare class RdxPopperContentWrapper {
     /**
      * The preferred side of the anchor to render against when open.
      * Will be reversed when collisions occur and avoidCollisions is enabled.
+     *
+     * Accepts the logical `'inline-start'` / `'inline-end'` in addition to the physical sides; those
+     * resolve to `left` / `right` for the text direction (Base UI parity). The placed side reported via
+     * `data-side` / `placedSide()` echoes the requested kind: logical in → logical out (even after a
+     * collision flip), physical in → physical out.
      */
-    readonly side: _angular_core.InputSignal<"top" | "right" | "bottom" | "left">;
+    readonly side: _angular_core.InputSignal<SideOrLogical>;
+    /**
+     * Text direction, used only to resolve a logical `side` (`inline-start` / `inline-end`) to a
+     * physical one. Falls back to an enclosing direction provider, then `ltr`.
+     */
+    readonly dir: _angular_core.InputSignal<Direction | undefined>;
+    private readonly direction;
+    /** The `side` input with any logical inline value resolved to a physical side for the direction. */
+    private readonly resolvedSide;
     /**
      * Distance between the anchor and the popup in pixels. Also accepts an {@link OffsetFunction} that
      * reads the anchor / positioner dimensions and the resolved side / align.
@@ -253,9 +289,18 @@ declare class RdxPopperContentWrapper {
         align: Align;
     } | undefined>;
     /**
-     * The side the panel is currently placed against.
+     * The physical side the panel is currently placed against. Internal geometry (arrow position,
+     * transform origins) must use this — never {@link placedSide}, which can be logical.
+     */
+    readonly physicalPlacedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    /**
+     * The side the panel is currently placed against, reported in the kind the consumer requested
+     * (Base UI positioner `side`): when a logical `side` was passed, a placed `left`/`right` maps back
+     * to `inline-start`/`inline-end` for the direction — so a post-collision flip stays logical and
+     * `[data-side="inline-start"]` CSS is direction-agnostic. A physical request is always reported
+     * physically.
      */
-    readonly placedSide: Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    readonly placedSide: Signal<SideOrLogical | undefined>;
     /**
      * The current alignment of the panel.
      */
@@ -292,7 +337,7 @@ declare class RdxPopperContentWrapper {
     private readonly afterRenderEffect;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPopperContentWrapper, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionAvoidance": { "alias": "collisionAvoidance"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPopperContentWrapper, "[rdxPopperContentWrapper]", never, { "anchor": { "alias": "anchor"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "collisionAvoidance": { "alias": "collisionAvoidance"; "required": false; "isSignal": true; }; "collisionBoundary": { "alias": "collisionBoundary"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "positionStrategy": { "alias": "positionStrategy"; "required": false; "isSignal": true; }; "updatePositionStrategy": { "alias": "updatePositionStrategy"; "required": false; "isSignal": true; }; }, { "placed": "placed"; }, ["arrow"], never, true, never>;
 }
 /**
  * Providers a "thin" positioner that `extends RdxPopperContentWrapper` must include. Angular
@@ -351,7 +396,7 @@ declare class RdxPopperArrow {
  * `undefined` falls back to the wrapper's built-in default. Consumer template bindings always win.
  */
 interface RdxPopperContentConfig {
-    side?: Side;
+    side?: SideOrLogical;
     align?: Align;
     sideOffset?: number | OffsetFunction;
     alignOffset?: number | OffsetFunction;
@@ -390,5 +435,5 @@ declare function provideRdxPopperContentConfig(config: RdxPopperContentConfig):
 
 declare const popperImports: (typeof RdxPopperAnchor | typeof RdxPopper | typeof RdxPopperContentWrapper | typeof RdxPopperContent)[];
 
-export { DROPDOWN_COLLISION_AVOIDANCE, POPUP_COLLISION_AVOIDANCE, RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, legacyPopperVars, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, provideRdxPopperContentWrapper, transformOrigin };
-export type { Align, OffsetFunction, PopperContentWrapperContext, RdxCollisionAvoidance, RdxPopperAnchorElement, RdxPopperContentConfig, ResolvedCollisionAvoidance, Side };
+export { DROPDOWN_COLLISION_AVOIDANCE, POPUP_COLLISION_AVOIDANCE, RdxPopper, RdxPopperAnchor, RdxPopperArrow, RdxPopperContent, RdxPopperContentConfigToken, RdxPopperContentWrapper, getSideAndAlignFromPlacement, injectPopperContentWrapperContext, isNotNull, legacyPopperVars, popperImports, providePopperContentWrapperContext, provideRdxPopperContentConfig, provideRdxPopperContentWrapper, resolvePhysicalSide, toLogicalSide, transformOrigin };
+export type { Align, LogicalSide, OffsetFunction, PopperContentWrapperContext, RdxCollisionAvoidance, RdxPopperAnchorElement, RdxPopperContentConfig, ResolvedCollisionAvoidance, Side, SideOrLogical };

package/types/radix-ng-primitives-preview-card.d.ts

@@ -268,7 +268,7 @@ declare class RdxPreviewCardPopup {
     private readonly registration;
     private readonly wrapper;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1$1.SideOrLogical | undefined>;
     /**
      * Event handler called when the escape key is down. Can be prevented.
      */
@@ -296,7 +296,7 @@ declare class RdxPreviewCardPopup {
 declare class RdxPreviewCardArrow {
     protected readonly rootContext: _radix_ng_primitives_preview_card.RdxPreviewCardRootContext;
     private readonly wrapper;
-    protected readonly side: _angular_core.Signal<"top" | "right" | "bottom" | "left" | undefined>;
+    protected readonly side: _angular_core.Signal<i1$1.SideOrLogical | undefined>;
     protected readonly align: _angular_core.Signal<"start" | "center" | "end" | undefined>;
     protected readonly uncentered: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPreviewCardArrow, never>;

package/types/radix-ng-primitives-radio.d.ts

@@ -20,6 +20,7 @@ interface RadioRootContext {
     required: Signal<boolean>;
     name: Signal<string | undefined>;
     form: Signal<string | undefined>;
+    registerNativeInput(value: string, input: HTMLInputElement): () => void;
     select(value: string | null, event?: Event, reason?: RdxRadioValueChangeReason): void;
     setArrowNavigation(value: boolean): void;
     isArrowNavigation(): boolean;
@@ -55,6 +56,8 @@ declare class RdxRadioGroupDirective extends RdxFormUiControlBase implements Con
     readonly touchedState: Signal<boolean>;
     readonly dirtyState: Signal<boolean>;
     private readonly arrowNavigation;
+    private readonly nativeInputs;
+    private readonly selectedItemHasNativeInput;
     private readonly itemMetadata;
     private readonly disabledIndices;
     private readonly activeIndex;
@@ -98,6 +101,8 @@ declare class RdxRadioGroupDirective extends RdxFormUiControlBase implements Con
     setDisabledState(isDisabled: boolean): void;
     setArrowNavigation(value: boolean): void;
     isArrowNavigation(): boolean;
+    /** @ignore Register an optional native radio input by its item value. */
+    registerNativeInput(value: string, input: HTMLInputElement): () => void;
     /**
      * Marks the control touched when focus leaves the whole group (Base UI `RadioGroup` parity and the
      * ADR 0004 CVA strategy) — moving focus between items stays inside, so `relatedTarget` is checked.
@@ -128,7 +133,7 @@ declare class RdxRadioItemInputDirective {
     private readonly input;
     readonly name: _angular_core.Signal<string | undefined>;
     readonly form: _angular_core.Signal<string | undefined>;
-    readonly value: _angular_core.Signal<string | undefined>;
+    readonly value: _angular_core.Signal<string>;
     readonly checked: _angular_core.Signal<boolean>;
     readonly required: _angular_core.Signal<boolean>;
     readonly disabled: _angular_core.Signal<boolean>;

package/types/radix-ng-primitives-select.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { Signal, ElementRef, InjectionToken, OutputRef, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { AcceptableValue, RdxCancelableChangeEventDetails, RdxFormUiControlBase, RdxFormValueControl, RdxFloatingRootContext, Direction, ItemValueComparator, RdxTransitionStatus, RdxFormUiStateContext } from '@radix-ng/primitives/core';
+import { AcceptableValue, RdxCancelableChangeEventDetails, RdxFormUiControlBase, RdxFormValueControl, RdxFloatingRootContext, Direction, ItemValueComparator, RdxTransitionStatus, RdxFormUiTouchTarget, RdxFormUiStateContext } from '@radix-ng/primitives/core';
 import * as _radix_ng_primitives_select from '@radix-ng/primitives/select';
 import * as i1 from '@radix-ng/primitives/composite';
 import { RdxCompositeItemRegistration } from '@radix-ng/primitives/composite';
@@ -11,6 +11,7 @@ import { RdxPopperContentWrapper } from '@radix-ng/primitives/popper';
 import * as i2 from '@radix-ng/primitives/floating-focus-manager';
 import { RdxInteractionType } from '@radix-ng/primitives/floating-focus-manager';
 import * as _radix_ng_primitives_types_radix_ng_primitives_core from '@radix-ng/primitives/types/radix-ng-primitives-core';
+import { ControlValueAccessor } from '@angular/forms';
 import * as i1$2 from '@radix-ng/primitives/portal';
 
 declare class RdxSelectGroupLabel {
@@ -365,7 +366,7 @@ interface RdxSelectRootContext extends RdxFormUiStateContext {
 }
 declare const injectSelectRootContext: _radix_ng_primitives_core.InjectContext<RdxSelectRootContext>;
 declare const provideSelectRootContext: (useFactory: () => RdxSelectRootContext) => _angular_core.Provider;
-declare class RdxSelectRoot extends RdxFormUiControlBase implements RdxFormValueControl<AcceptableValue | AcceptableValue[] | undefined> {
+declare class RdxSelectRoot extends RdxFormUiControlBase implements ControlValueAccessor, RdxFormValueControl<AcceptableValue | AcceptableValue[] | undefined> {
     readonly contentId: string;
     readonly open: _angular_core.ModelSignal<boolean>;
     /** Whether the current open was initiated by **touch** (ADR 0016 §3 — gates the anchored scroll lock). */
@@ -385,10 +386,16 @@ declare class RdxSelectRoot extends RdxFormUiControlBase implements RdxFormValue
     readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly cvaDisabled;
+    readonly disabledState: Signal<boolean>;
     /** When `true`, the value cannot be changed by the user (the popup can still be opened to view it). */
     readonly readOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Marks the control as required — reflected on the trigger as `aria-required` / `data-required`. */
     readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Name used when serializing this composite control into native `FormData`. */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /** Id of an external form that owns this control. */
+    readonly form: _angular_core.InputSignal<string | undefined>;
     /** Whether the popup is modal: locks page scroll and makes outside content inert while open. */
     readonly modal: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly dirInput: _angular_core.InputSignal<Direction | undefined>;
@@ -397,6 +404,8 @@ declare class RdxSelectRoot extends RdxFormUiControlBase implements RdxFormValue
     readonly isItemEqualToValue: _angular_core.InputSignal<ItemValueComparator<AcceptableValue> | undefined>;
     /** Converts a value to its display label (used by `RdxSelectValue`). */
     readonly itemToStringLabel: _angular_core.InputSignal<((value: AcceptableValue) => string) | undefined>;
+    /** Converts an item value to the string submitted by a native form. */
+    readonly itemToStringValue: _angular_core.InputSignal<((value: AcceptableValue) => string) | undefined>;
     /** Emits before an open-state change is committed; call `eventDetails.cancel()` to veto it. */
     readonly onOpenChange: _angular_core.OutputEmitterRef<RdxSelectOpenChangeEvent>;
     /** Emits before a value change is committed; call `eventDetails.cancel()` to veto it. */
@@ -411,6 +420,7 @@ declare class RdxSelectRoot extends RdxFormUiControlBase implements RdxFormValue
     readonly isEmptyModelValue: Signal<boolean>;
     private hasAppliedDefaultValue;
     private hasAppliedDefaultOpen;
+    private readonly nativeFormControl;
     constructor();
     readonly optionsSet: WritableSignal<Set<SelectOption>>;
     readonly nativeSelectKey: Signal<string>;
@@ -423,8 +433,20 @@ declare class RdxSelectRoot extends RdxFormUiControlBase implements RdxFormValue
     getOption(value: SelectOption['value']): SelectOption | undefined;
     setValue(value: AcceptableValue | undefined, reason?: RdxSelectValueChangeReason, event?: Event): boolean;
     setOpen(open: boolean, reason?: RdxSelectOpenChangeReason, event?: Event): boolean;
+    /** @ignore Bridge the CVA touched callback into the shared Signal Forms UI-state path. */
+    protected formUiTouchTarget(): RdxFormUiTouchTarget;
+    /** @ignore Write a form-owned value without emitting a user change. */
+    writeValue(value: AcceptableValue | AcceptableValue[] | undefined): void;
+    /** @ignore Register the Reactive Forms / ngModel value callback. */
+    registerOnChange(fn: (value: AcceptableValue | AcceptableValue[] | undefined) => void): void;
+    /** @ignore Register the Reactive Forms / ngModel touched callback. */
+    registerOnTouched(fn: () => void): void;
+    /** @ignore Merge form-owned disabled state with the public disabled input. */
+    setDisabledState(isDisabled: boolean): void;
+    private onChange?;
+    private onTouched?;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxSelectRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectRoot, "[rdxSelectRoot]", ["rdxSelectRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "isItemEqualToValue": { "alias": "isItemEqualToValue"; "required": false; "isSignal": true; }; "itemToStringLabel": { "alias": "itemToStringLabel"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "value": "valueChange"; "onOpenChange": "onOpenChange"; "onValueChange": "onValueChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxSelectRoot, "[rdxSelectRoot]", ["rdxSelectRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "isItemEqualToValue": { "alias": "isItemEqualToValue"; "required": false; "isSignal": true; }; "itemToStringLabel": { "alias": "itemToStringLabel"; "required": false; "isSignal": true; }; "itemToStringValue": { "alias": "itemToStringValue"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "value": "valueChange"; "onOpenChange": "onOpenChange"; "onValueChange": "onValueChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, [{ directive: typeof i1$1.RdxPopper; inputs: {}; outputs: {}; }]>;
 }
 
 declare class RdxSelectScrollButtonBase {
@@ -474,7 +496,6 @@ declare class RdxSelectTrigger {
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     readonly isDisabled: _angular_core.Signal<boolean>;
     protected readonly triggerInteraction: i2.RdxTriggerInteraction;
-    protected readonly invalidState: _angular_core.Signal<boolean>;
     /**
      * Tri-state *displayed* validity: when inside a `rdxFieldRoot` the field's gated `validState` is the
      * single source (so the field's `validationMode` keeps the trigger neutral until revealed), otherwise