@radix-ng/primitives 1.0.0-beta.3 → 1.0.0-beta.5

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

@@ -26,7 +26,8 @@ declare class RdxDateFieldRootDirective {
      * The locale to use for formatting dates.
      */
     readonly locale: _angular_core.InputSignal<string>;
-    readonly dir: _angular_core.InputSignal<Direction>;
+    readonly dirInput: _angular_core.InputSignal<Direction | undefined>;
+    readonly dir: Signal<Direction>;
     /**
      * The minimum valid date that can be entered.
      */
@@ -138,7 +139,7 @@ declare class RdxDateFieldRootDirective {
      */
     setFocusedElement(el: HTMLElement): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDateFieldRootDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDateFieldRootDirective, "[rdxDateFieldRoot]", ["rdxDateFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, ["segmentInputs"], never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDateFieldRootDirective, "[rdxDateFieldRoot]", ["rdxDateFieldRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isDateUnavailable": { "alias": "isDateUnavailable"; "required": false; "isSignal": true; }; "hourCycle": { "alias": "hourCycle"; "required": false; "isSignal": true; }; "granularity": { "alias": "granularity"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "hideTimeZone": { "alias": "hideTimeZone"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "placeholder": "placeholderChange"; }, ["segmentInputs"], never, true, never>;
 }
 
 declare class RdxDateFieldInputDirective {

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

@@ -3,10 +3,11 @@ import { InjectionToken, Provider, Signal, ElementRef } from '@angular/core';
 import * as i1 from '@radix-ng/primitives/portal';
 import { RdxPortalContainer } from '@radix-ng/primitives/portal';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { RdxTransitionStatus, BooleanInput } from '@radix-ng/primitives/core';
+import { RdxTransitionStatus, BooleanInput, RdxCancelableChangeEventDetails, RdxFloatingRootContext } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_floating_focus_manager from '@radix-ng/primitives/floating-focus-manager';
+import { RdxInteractionType } from '@radix-ng/primitives/floating-focus-manager';
 import * as _radix_ng_primitives_dialog from '@radix-ng/primitives/dialog';
-import * as i1$1 from '@radix-ng/primitives/dismissable-layer';
-import * as i2 from '@radix-ng/primitives/focus-scope';
+import { RdxOutsidePressDomEvent } from '@radix-ng/primitives/dismissable-layer';
 
 /**
  * Structural directive that teleports the dialog content (backdrop + popup) into a container (default
@@ -81,18 +82,21 @@ declare function provideRdxDialogVariant(variant: Partial<RdxDialogVariant>): Pr
 
 type RdxDialogModal = boolean | 'trap-focus';
 type RdxDialogOpenChangeReason = 'trigger-press' | 'close-press' | 'outside-press' | 'focus-out' | 'escape-key' | 'swipe' | 'imperative-action' | 'none';
+type RdxDialogOpenChangeEventDetails = RdxCancelableChangeEventDetails<RdxDialogOpenChangeReason>;
 interface RdxDialogOpenChange {
     open: boolean;
     triggerId: string | null;
     trigger: HTMLElement | undefined;
     reason: RdxDialogOpenChangeReason;
     event: Event;
+    eventDetails: RdxDialogOpenChangeEventDetails;
 }
 interface RdxDialogRootContext {
     contentId: string;
     titleId: Signal<string | undefined>;
     descriptionId: Signal<string | undefined>;
     isOpen: Signal<boolean>;
+    present: Signal<boolean>;
     /** Effective modality (the variant can pin this to `true`). */
     modal: Signal<RdxDialogModal>;
     /** Effective outside-press / focus-out dismissal flag (the variant can force it on). */
@@ -103,6 +107,8 @@ interface RdxDialogRootContext {
     trigger: Signal<HTMLElement | undefined>;
     triggers: Signal<HTMLElement[]>;
     payload: Signal<unknown>;
+    openInteractionType: Signal<RdxInteractionType>;
+    closeInteractionType: Signal<RdxInteractionType>;
     /** Whether this dialog is nested in another; constant, fixed at construction. */
     nested: boolean;
     nestedDialogOpen: Signal<boolean>;
@@ -110,6 +116,7 @@ interface RdxDialogRootContext {
     setDescriptionId: (id: string | undefined) => void;
     registerTransitionElement: (element: HTMLElement) => () => void;
     registerTrigger: (id: string, trigger: HTMLElement, payload: () => unknown) => () => void;
+    setTriggerOpenInteractionType: (type: RdxInteractionType) => void;
     open: (trigger?: HTMLElement, payload?: unknown, triggerId?: string, reason?: RdxDialogOpenChangeReason, event?: Event) => void;
     close: (reason?: RdxDialogOpenChangeReason, event?: Event) => void;
     toggle: (triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event) => void;
@@ -175,6 +182,11 @@ declare class RdxDialogRoot {
     readonly triggers: _angular_core.WritableSignal<HTMLElement[]>;
     readonly payload: _angular_core.WritableSignal<unknown>;
     readonly nestedOpenCount: _angular_core.WritableSignal<number>;
+    readonly openInteractionType: _angular_core.WritableSignal<RdxInteractionType>;
+    readonly closeInteractionType: _angular_core.WritableSignal<RdxInteractionType>;
+    private readonly preventUnmountOnClose;
+    private readonly pendingTriggerOpenInteractionType;
+    readonly present: Signal<boolean>;
     /** Whether this dialog is rendered inside another dialog. Fixed at construction. */
     readonly nested: boolean;
     readonly nestedDialogOpen: Signal<boolean>;
@@ -184,16 +196,24 @@ declare class RdxDialogRoot {
     readonly effectiveModal: Signal<RdxDialogModal>;
     /** Effective dismissal flag: disabled when the input asks, or when the variant forces it (alerts). */
     readonly effectiveDisablePointerDismissal: Signal<boolean>;
+    /**
+     * The shared per-popup floating context (ADR 0015 §1) — `open` mirrors the dialog's open state, the
+     * trigger registry is bridged from {@link registerTrigger}, and the reference / floating elements are
+     * set by the trigger / popup. The new dismissal + focus engines read this once the popup migrates.
+     */
+    readonly floatingContext: RdxFloatingRootContext;
     constructor();
     show(trigger?: HTMLElement | undefined, payload?: unknown, triggerId?: string, reason?: RdxDialogOpenChangeReason, event?: Event): void;
     close(reason?: RdxDialogOpenChangeReason, event?: Event): void;
     toggle(triggerId: string, trigger: HTMLElement, payload?: unknown, event?: Event): void;
+    setTriggerOpenInteractionType(type: RdxInteractionType): void;
     registerTrigger(id: string, trigger: HTMLElement, payload: () => unknown): () => void;
     /** Increments the nested-open counter and returns a release callback that decrements it. */
     openNestedChild(): () => void;
     private syncTriggerId;
-    private emitOpenChange;
+    private createOpenChangeEvent;
     private emitOpenChangeComplete;
+    private consumeOpenInteractionType;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogRoot, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogRoot, "[rdxDialogRoot]", ["rdxDialogRoot"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "triggerId": { "alias": "triggerId"; "required": false; "isSignal": true; }; "defaultTriggerId": { "alias": "defaultTriggerId"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "disablePointerDismissal": { "alias": "disablePointerDismissal"; "required": false; "isSignal": true; }; "handle": { "alias": "handle"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "triggerId": "triggerIdChange"; "onOpenChange": "onOpenChange"; "onOpenChangeComplete": "onOpenChangeComplete"; }, never, never, true, never>;
 }
@@ -224,19 +244,28 @@ declare class RdxDialogTrigger {
     protected readonly triggerId: _angular_core.Signal<string>;
     protected readonly rootContext: _angular_core.Signal<_radix_ng_primitives_dialog.RdxDialogRootContext | null>;
     protected readonly isOpen: _angular_core.Signal<boolean>;
+    protected readonly triggerInteraction: _radix_ng_primitives_floating_focus_manager.RdxTriggerInteraction;
     constructor();
     protected handleClick(event: MouseEvent): void;
+    protected handlePointerDown(event: PointerEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogTrigger, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogTrigger, "button[rdxDialogTrigger]", ["rdxDialogTrigger"], { "handle": { "alias": "handle"; "required": false; "isSignal": true; }; "payload": { "alias": "payload"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
  * An overlay displayed beneath the dialog popup.
+ *
+ * Decorative-only, so it carries `role="presentation"` (Base UI `DialogBackdrop`). By default a **nested**
+ * dialog renders no backdrop — the parent's already dims the page; stacking a second one double-darkens
+ * and intercepts the parent's outside-press. Set `forceRender` to opt back in.
  */
 declare class RdxDialogBackdrop {
     protected readonly rootContext: _radix_ng_primitives_dialog.RdxDialogRootContext;
+    /** Render the backdrop even for a nested dialog (off by default, matching Base UI). */
+    readonly forceRender: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogBackdrop, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogBackdrop, "[rdxDialogBackdrop]", ["rdxDialogBackdrop"], {}, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogBackdrop, "[rdxDialogBackdrop]", ["rdxDialogBackdrop"], { "forceRender": { "alias": "forceRender"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -253,40 +282,67 @@ declare class RdxDialogViewport {
 
 /**
  * A container for the dialog contents.
+ *
+ * **ADR 0015/0017 Phase-4 migration — Dialog is the PILOT cutover onto the new floating dismissal +
+ * focus engine. Browser-verified** by `apps/visual-regression/tests/dialog.behavior.spec.ts` (trap,
+ * initial / return focus, Escape / outside-press / focus-out dismissal, nested-Escape deepest-first,
+ * backdrop-not-marked).
+ *
+ * **Mapping (legacy → new):**
+ * - `RdxDismissableLayer` (legacy) → `RdxFloatingNodeRegistration` (registers the tree node) +
+ *   `RdxDismiss` (Escape / outside-press; reads the root context + node).
+ * - `RdxFocusScope` (direct) → `RdxFloatingFocusManager` (composes the reworked focus scope; trap +
+ *   markOthers + close-on-focus-out), driven by `provideFloatingFocusManagerConfig`.
+ * - `disableOutsidePointerEvents` → the focus manager's `inert` pass marks outside elements
+ *   non-interactive for a modal (finding #4), scoped to siblings of the popup's ancestor chain instead
+ *   of a global `body { pointer-events: none }` lock — so the popup needs no `pointer-events: auto`.
+ * - focus-out close moved from the dismissal capability (`focusOutside: () => false`) to the manager
+ *   (`manager.focusOut`), per ADR 0017 §3.
+ * - `isEventOnTrigger` preventDefault → removed: the trigger is in `context.triggers`, so the engine
+ *   treats a press/focus on it as **inside** (no close-then-reopen).
+ *
+ * **Parity notes:**
+ * - **Lifecycle split (resolved 2026-06-16):** `enabled` is `open || transitionStatus === 'ending'`, so
+ *   the trap / return-focus machinery survives the exit animation, while the manager's marker + isolation
+ *   passes additionally key off `open` and release at close-start (Base UI `markOthers` gating).
+ * - **`trap-focus` split:** the manager traps focus for `modal === true` and `'trap-focus'`, but applies
+ *   real `inert` isolation only for `modal === true`, matching Base UI's public contract that
+ *   `modal="trap-focus"` leaves outside pointer interaction enabled.
+ * - **`returnFocus` orchestration (resolved 2026-06-16):** the manager now owns the return-focus *target*
+ *   via the focus scope's `returnFocus` config seam (the scope owns the *timing* — its queued post-unmount
+ *   frame). Dialog leaves it at the default (`returnFocus: true` → return to the element focused before
+ *   open), so behavior is unchanged; a consumer can now also pass `false` / an element / a callback.
  */
 declare class RdxDialogPopup {
     protected readonly rootContext: _radix_ng_primitives_dialog.RdxDialogRootContext;
-    private readonly dismissableLayer;
+    private readonly host;
+    private readonly floatingContext;
+    private readonly registration;
+    private readonly focusManager;
     private readonly focusScope;
-    private dismissDetails;
-    /**
-     * Event handler called when the escape key is down. Can be prevented.
-     */
-    readonly escapeKeyDown: _angular_core.OutputRef<KeyboardEvent>;
-    /**
-     * Event handler called when a pointerdown event happens outside of the popup. Can be prevented.
-     */
-    readonly pointerDownOutside: _angular_core.OutputRef<PointerEvent>;
-    /**
-     * Event handler called when focus moves outside of the popup. Can be prevented.
-     */
-    readonly focusOutside: _angular_core.OutputRef<FocusEvent>;
-    /**
-     * Event handler called when an interaction happens outside of the popup. Can be prevented.
-     */
-    readonly interactOutside: _angular_core.OutputRef<PointerEvent | FocusEvent>;
-    /**
-     * Event handler called before focus moves into the popup. Can be prevented.
-     */
+    /** 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. */
+    readonly pointerDownOutside: _angular_core.OutputEmitterRef<RdxOutsidePressDomEvent>;
+    /** Event handler called when focus moves outside of the popup. Can be prevented. */
+    readonly focusOutside: _angular_core.OutputEmitterRef<FocusEvent>;
+    /** Event handler called when an interaction (pointer / focus) happens outside of the popup. */
+    readonly interactOutside: _angular_core.OutputEmitterRef<RdxOutsidePressDomEvent | FocusEvent>;
+    /** Event handler called before focus moves into the popup. Can be prevented. */
     readonly openAutoFocus: _angular_core.OutputRef<Event>;
-    /**
-     * Event handler called before focus returns after the popup is removed. Can be prevented.
-     */
+    /** Event handler called before focus returns after the popup is removed. Can be prevented. */
     readonly closeAutoFocus: _angular_core.OutputRef<Event>;
     constructor();
-    private isEventOnTrigger;
+    /** This dialog is the topmost (deepest open) one — it has no open nested dialog above it. */
+    private isTopmost;
+    /**
+     * Composite navigation keys (arrows / Home / End) are kept inside the dialog (Base UI `DialogPopup`):
+     * a dialog opened from inside a Menu / Menubar / Composite must not let an arrow press bubble out and
+     * move the outer collection's active item.
+     */
+    protected onKeyDown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDialogPopup, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogPopup, "[rdxDialogPopup]", ["rdxDialogPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof i1$1.RdxDismissableLayer; inputs: {}; outputs: {}; }, { directive: typeof i2.RdxFocusScope; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDialogPopup, "[rdxDialogPopup]", ["rdxDialogPopup"], {}, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "openAutoFocus": "openAutoFocus"; "closeAutoFocus": "closeAutoFocus"; }, never, never, true, [{ directive: typeof _radix_ng_primitives_core.RdxFloatingNodeRegistration; inputs: {}; outputs: {}; }, { directive: typeof _radix_ng_primitives_floating_focus_manager.RdxFloatingFocusManager; inputs: {}; outputs: {}; }]>;
 }
 
 /**
@@ -328,4 +384,4 @@ declare class RdxDialogModule {
 }
 
 export { RDX_DIALOG_VARIANT, RdxDialogBackdrop, RdxDialogClose, RdxDialogDescription, RdxDialogHandle, RdxDialogModule, RdxDialogPopup, RdxDialogPortal, RdxDialogPortalMisuseGuard, RdxDialogRoot, RdxDialogTitle, RdxDialogTrigger, RdxDialogViewport, createRdxDialogHandle, dialogImports, injectRdxDialogRootContext, provideRdxDialogRootContext, provideRdxDialogVariant };
-export type { RdxDialogModal, RdxDialogOpenChange, RdxDialogOpenChangeReason, RdxDialogRole, RdxDialogRootContext, RdxDialogVariant };
+export type { RdxDialogModal, RdxDialogOpenChange, RdxDialogOpenChangeEventDetails, RdxDialogOpenChangeReason, RdxDialogRole, RdxDialogRootContext, RdxDialogVariant };

package/types/radix-ng-primitives-direction-provider.d.ts

@@ -0,0 +1,41 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import { Direction } from '@radix-ng/primitives/core';
+
+type RdxDirectionValue = Direction | Signal<Direction> | (() => Direction);
+declare const RDX_DIRECTION: InjectionToken<Signal<Direction>>;
+/**
+ * Provides a primitive behavior direction through Angular DI.
+ */
+declare function provideDirection(direction: RdxDirectionValue): Provider;
+/**
+ * Provides a reading direction for descendant primitives.
+ *
+ * This controls primitive behavior only. Set the native `dir` attribute or CSS `direction`
+ * separately when the DOM itself should render right-to-left.
+ */
+declare class RdxDirectionProvider {
+    private readonly parentDirection;
+    /**
+     * The reading direction for descendant primitives.
+     *
+     * @defaultValue 'ltr'
+     */
+    readonly directionInput: _angular_core.InputSignal<Direction | undefined>;
+    /** Alias for Angular templates that prefer `[dir]`. */
+    readonly dirInput: _angular_core.InputSignal<Direction | undefined>;
+    readonly direction: Signal<Direction>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDirectionProvider, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDirectionProvider, "[rdxDirectionProvider]", ["rdxDirectionProvider"], { "directionInput": { "alias": "direction"; "required": false; "isSignal": true; }; "dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Reads the effective primitive direction.
+ *
+ * Priority: explicit local input, nearest DI direction provider, global `provideRadixNG({ dir })`.
+ */
+declare function injectDirection(localDirection?: Signal<Direction | undefined>): Signal<Direction>;
+
+declare const directionProviderImports: (typeof RdxDirectionProvider)[];
+
+export { RDX_DIRECTION, RdxDirectionProvider, directionProviderImports, injectDirection, provideDirection };
+export type { RdxDirectionValue };

package/types/radix-ng-primitives-dismissable-layer.d.ts

@@ -1,6 +1,137 @@
-import * as _angular_core from '@angular/core';
-import { Signal, InjectionToken, Provider } from '@angular/core';
-import { BooleanInput } from '@radix-ng/primitives/core';
+import { RdxFloatingRootContext, RdxFloatingNode, BooleanInput } from '@radix-ng/primitives/core';
+import * as i0 from '@angular/core';
+
+/** Why a dismissal was requested — mirrors Base UI's open-change `reason` strings (`useDismiss.ts`). */
+type RdxDismissReason = 'escape-key' | 'outside-press' | 'focus-outside';
+type RdxOutsidePressDomEvent = MouseEvent | PointerEvent | TouchEvent;
+/**
+ * Configuration for {@link RdxDismiss}. Every flag is a getter so it can be a signal
+ * read (reactive) or a plain predicate. The `on*` pre-hooks are **preventable**: call
+ * `event.preventDefault()` inside one to veto that dismissal (the layer then stays open).
+ */
+/** When an outside press dismisses: `'sloppy'` closes on `pointerdown`, `'intentional'` on `click`. */
+type RdxOutsidePressEvent = 'sloppy' | 'intentional';
+/**
+ * `outsidePressEvent` config (Base UI). Either a single mode for every pointer type, or a per-pointer-type
+ * map (`{ mouse, touch, pen }`) resolved against the pointer type of the active press. A missing key falls
+ * back to `'sloppy'`.
+ */
+type RdxOutsidePressEventConfig = RdxOutsidePressEvent | {
+    mouse?: RdxOutsidePressEvent;
+    touch?: RdxOutsidePressEvent;
+    pen?: RdxOutsidePressEvent;
+};
+interface RdxDismissProps {
+    /** Whole-capability gate (on top of `context.open()`). Default `() => true`. */
+    enabled?: () => boolean;
+    /** Whether Escape requests dismissal. Default `() => true`. */
+    escapeKey?: () => boolean;
+    /**
+     * Whether this layer's Escape **bubbles** to ancestor layers (Base UI `bubbles.escapeKey`). Default
+     * `() => false` — Escape closes only the deepest layer. `true` re-emits to the parent too (this is
+     * Menu's `closeParentOnEsc`: a submenu's Escape also closes the parent menu).
+     */
+    escapeKeyBubbles?: () => boolean;
+    /**
+     * Whether an outside pointer press requests dismissal. Default `() => true`. Receives the press
+     * **event**, so a layer can decide per target / button / pointer (e.g. Dialog: only the topmost
+     * dialog dismisses; only its own backdrop counts).
+     */
+    outsidePress?: (event: Event) => boolean;
+    /**
+     * When an outside press dismisses (Base UI `outsidePressEvent`). `'sloppy'` (default) closes on
+     * `pointerdown` — immediate, OS-like. `'intentional'` closes on `click` — requires a full
+     * press-and-release on the same outside target, and suppresses the click when the press **started
+     * inside** (so selecting text and dragging out does not dismiss). May be a per-pointer-type map
+     * resolved against the active press (`{ mouse: 'intentional', touch: 'sloppy' }`).
+     */
+    outsidePressEvent?: () => RdxOutsidePressEventConfig;
+    /**
+     * Whether this layer's outside-press **bubbles** to ancestor layers (Base UI `bubbles.outsidePress`).
+     * Default `() => true` — an outside press closes the whole stack. `false` makes an open non-bubbling
+     * child block the parent (only the deepest closes).
+     */
+    outsidePressBubbles?: () => boolean;
+    /** Whether focus leaving the layer requests dismissal. Default `() => true`. */
+    focusOutside?: () => boolean;
+    /** Preventable pre-hook for Escape. */
+    onEscapeKeyDown?: (event: KeyboardEvent) => void;
+    /** Preventable pre-hook for an outside pointer press. */
+    onPointerDownOutside?: (event: RdxOutsidePressDomEvent) => void;
+    /** Preventable pre-hook for focus moving outside. */
+    onFocusOutside?: (event: FocusEvent) => void;
+    /** Called when a non-prevented dismissal is requested. */
+    onDismiss?: (reason: RdxDismissReason, event: Event) => void;
+}
+/**
+ * The **dismiss** mechanism (ADR 0015) — the Angular counterpart of Base UI's `useDismiss`. It
+ * **references** a {@link RdxFloatingRootContext} (mandatory: `open` / `triggers` / elements live there)
+ * and a {@link RdxFloatingNode} (**optional**: a node-optional / Navigation-Menu state has `node ===
+ * null`); it never creates them. It listens for Escape / outside-press / focus-out and **requests** a
+ * dismissal via `onDismiss` when an interaction lands outside the logical layer and this layer owns the
+ * event.
+ *
+ * **Logical, not DOM-order, containment.** "Inside" is resolved through the shared tree — this popup's
+ * floating element + its registered triggers, **plus** the same for every open descendant node, **plus**
+ * this layer's own {@link branches}. So a portal-relocated child still counts as inside its parent — which
+ * a DOM-order containment check cannot do.
+ *
+ * **Ownership & propagation (`hasBlockingChild`).** Each layer publishes per-event `bubbles` flags
+ * (`escapeKeyBubbles` default `false`, `outsidePressBubbles` default `true`); an ancestor reads its open
+ * children's flags via {@link childBubbles}. A non-bubbling layer **yields** to a non-bubbling open child,
+ * so by default Escape closes only the **deepest** layer while an outside press closes the **whole stack**.
+ * A layer with `escapeKeyBubbles = true` re-emits to its parent (Menu's `closeParentOnEsc`). The owning
+ * non-bubbling Escape layer also `stopPropagation()`s so the key does not reach app handlers.
+ *
+ * **Press / IME hardening.** Outside-press honors `outsidePressEvent` (`'sloppy'` → `pointerdown`,
+ * `'intentional'` → `click` with press-start-inside drag-out suppression), ignores non-primary mouse
+ * buttons and scrollbar presses, resets on `pointercancel`, and ignores Escape while an IME composition is
+ * active. **Touch** sloppy-mode gesture hardening (long-press / drag-distance thresholds) is ported here
+ * but only unit-exercisable via synthetic events — real on-device behavior is covered by
+ * `apps/visual-regression` (Playwright).
+ *
+ * **Scope.** Must be constructed in an injection context (`DestroyRef` / `PLATFORM_ID`). No-op on the
+ * server.
+ */
+declare class RdxDismiss {
+    readonly context: RdxFloatingRootContext;
+    readonly node: () => RdxFloatingNode | null;
+    /** This layer's own inside-content set (branches that live outside the popup DOM). */
+    readonly branches: Set<Element>;
+    /** This mechanism's active-ness: the popup is open **and** dismissal is enabled. */
+    readonly active: () => boolean;
+    constructor(context: RdxFloatingRootContext, node: () => RdxFloatingNode | null, config?: RdxDismissProps);
+    /**
+     * Whether `target` is logically inside this layer: within this popup's floating element or one of its
+     * registered triggers, within any **open descendant** node's floating element / triggers, or within a
+     * registered branch.
+     */
+    private isInside;
+    /** `target` is inside a context's floating element or one of its registered triggers. */
+    private contextContains;
+    /**
+     * Whether an open descendant blocks this layer for `reason` (so it should yield). A child blocks when
+     * it does **not** let the event bubble past it ({@link childBubbles} is `false`). Base UI's
+     * `hasBlockingChild` (`useDismiss.ts:170`) is a capability-local function — **not** a tree method — so
+     * the tree stays neutral.
+     */
+    private hasBlockingChild;
+}
+
+/**
+ * Marks its host as **inside** the enclosing floating layer (ADR 0015): a pointer / focus interaction on
+ * it does not count as "outside", so it never dismisses the popup. It registers the host into the
+ * floating root context's trigger registry — {@link RdxDismiss}'s `isInside` check reads it.
+ *
+ * Use it for an element that lives **outside** the popup DOM but logically belongs to the layer — e.g. a
+ * Combobox input / trigger / chips / clear button that keeps focus (or is clicked) while the listbox is
+ * open.
+ */
+declare class RdxFloatingInsideElement {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxFloatingInsideElement, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxFloatingInsideElement, "[rdxFloatingInside]", ["rdxFloatingInside"], {}, {}, never, never, true, never>;
+}
 
 /**
  * Listens for when focus happens outside a DOM subtree.
@@ -8,16 +139,16 @@ import { BooleanInput } from '@radix-ng/primitives/core';
  */
 declare class RdxFocusOutside {
     #private;
-    readonly enabledInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly enabledInput: i0.InputSignalWithTransform<boolean, BooleanInput>;
     set enabled(value: boolean);
     get enabled(): boolean;
-    readonly focusOutside: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly focusOutside: i0.OutputEmitterRef<FocusEvent>;
     private readonly isFocusInsideDOMTree;
     private readonly focusCaptureHandler;
     private readonly blurCaptureHandler;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFocusOutside, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFocusOutside, "[rdxFocusOutside]", ["rdxFocusOutside"], { "enabledInput": { "alias": "enabled"; "required": false; "isSignal": true; }; }, { "focusOutside": "focusOutside"; }, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxFocusOutside, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxFocusOutside, "[rdxFocusOutside]", ["rdxFocusOutside"], { "enabledInput": { "alias": "enabled"; "required": false; "isSignal": true; }; }, { "focusOutside": "focusOutside"; }, never, never, true, never>;
 }
 /**
  * Listens for `pointerdown` outside a DOM subtree. We use `pointerdown` rather than `pointerup`
@@ -27,108 +158,25 @@ declare class RdxFocusOutside {
 declare class RdxPointerDownOutside {
     #private;
     private readonly elementRef;
-    readonly enabledInput: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
+    readonly enabledInput: i0.InputSignalWithTransform<boolean, BooleanInput>;
     set enabled(value: boolean);
     get enabled(): boolean;
-    readonly pointerDownOutside: _angular_core.OutputEmitterRef<PointerEvent>;
+    readonly pointerDownOutside: i0.OutputEmitterRef<PointerEvent>;
     private readonly isPointerInsideDOMTree;
     private readonly handleAndDispatchPointerDownOutsideEvent;
     private handleClick?;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxPointerDownOutside, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxPointerDownOutside, "[rdxPointerDownOutside]", ["rdxPointerDownOutside"], { "enabledInput": { "alias": "enabled"; "required": false; "isSignal": true; }; }, { "pointerDownOutside": "pointerDownOutside"; }, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxPointerDownOutside, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxPointerDownOutside, "[rdxPointerDownOutside]", ["rdxPointerDownOutside"], { "enabledInput": { "alias": "enabled"; "required": false; "isSignal": true; }; }, { "pointerDownOutside": "pointerDownOutside"; }, never, never, true, never>;
 }
 declare class RdxEscapeKeyDown {
     private readonly elementRef;
     private readonly destroyRef;
-    readonly escapeKeyDown: _angular_core.OutputEmitterRef<KeyboardEvent>;
+    readonly escapeKeyDown: i0.OutputEmitterRef<KeyboardEvent>;
     constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEscapeKeyDown, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEscapeKeyDown, "[rdxEscapeKeyDown]", ["rdxEscapeKeyDown"], {}, { "escapeKeyDown": "escapeKeyDown"; }, never, never, true, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxEscapeKeyDown, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxEscapeKeyDown, "[rdxEscapeKeyDown]", ["rdxEscapeKeyDown"], {}, { "escapeKeyDown": "escapeKeyDown"; }, never, never, true, never>;
 }
 
-declare class RdxDismissableLayer {
-    private readonly elementRef;
-    private readonly injector;
-    private readonly destroyRef;
-    private readonly context;
-    private readonly config;
-    private readonly rdxPointerDownOutside;
-    private readonly rdxFocusOutside;
-    private readonly rdxEscapeKeyDown;
-    /**
-     * 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 `DismissableLayer`.
-     * Can be prevented.
-     */
-    readonly pointerDownOutside: _angular_core.OutputEmitterRef<PointerEvent>;
-    /**
-     * Event handler called when the focus moves outside of the `DismissableLayer`.
-     * Can be prevented.
-     */
-    readonly focusOutside: _angular_core.OutputEmitterRef<FocusEvent>;
-    /**
-     * Event handler called when an interaction happens outside the `DismissableLayer`.
-     * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.
-     * Can be prevented.
-     */
-    readonly interactOutside: _angular_core.OutputEmitterRef<FocusEvent | PointerEvent>;
-    /**
-     * Handler called when the `DismissableLayer` should be dismissed
-     */
-    readonly dismiss: _angular_core.OutputEmitterRef<void>;
-    /**
-     * When `true`, hover/focus/click interactions will be disabled on elements outside
-     * the `DismissableLayer`. Users will need to click twice on outside elements to
-     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
-     */
-    readonly disableOutsidePointerEvents: _angular_core.InputSignalWithTransform<boolean | undefined, BooleanInput>;
-    readonly isOutsidePointerEventsDisabled: _angular_core.Signal<boolean>;
-    protected readonly isBodyPointerEventsDisabled: _angular_core.Signal<boolean>;
-    protected readonly isPointerEventsEnabled: _angular_core.Signal<boolean>;
-    private readonly index;
-    /** The topmost layer in the stack — the only one that should react to the Escape key. */
-    private readonly isHighestLayer;
-    constructor();
-    /**
-     * Toggles `pointer-events: none` on the document body while any layer has
-     * `disableOutsidePointerEvents`. Ownership is shared across all layers via
-     * {@link originalBodyPointerEvents}: the original value is saved only on the global
-     * `0 -> >0` transition and restored only when the count returns to `0`.
-     */
-    private setupBodyPointerEvents;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDismissableLayer, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDismissableLayer, "[rdxDismissableLayer]", ["rdxDismissableLayer"], { "disableOutsidePointerEvents": { "alias": "disableOutsidePointerEvents"; "required": false; "isSignal": true; }; }, { "escapeKeyDown": "escapeKeyDown"; "pointerDownOutside": "pointerDownOutside"; "focusOutside": "focusOutside"; "interactOutside": "interactOutside"; "dismiss": "dismiss"; }, never, never, true, [{ directive: typeof RdxPointerDownOutside; inputs: {}; outputs: {}; }, { directive: typeof RdxFocusOutside; inputs: {}; outputs: {}; }, { directive: typeof RdxEscapeKeyDown; inputs: {}; outputs: {}; }]>;
-}
-
-declare class RdxDismissableLayerBranch {
-    private readonly elementRef;
-    private readonly destroyRef;
-    private readonly dismissableLayersContext;
-    constructor();
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxDismissableLayerBranch, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxDismissableLayerBranch, "[rdxDismissableLayerBranch]", never, {}, {}, never, never, true, never>;
-}
-
-declare const RdxDismissableLayersContextToken: InjectionToken<{
-    layersRoot: _angular_core.WritableSignal<RdxDismissableLayer[]>;
-    layersWithOutsidePointerEventsDisabled: Signal<RdxDismissableLayer[]>;
-    branches: _angular_core.WritableSignal<HTMLElement[]>;
-}>;
-type RdxDismissableLayerConfig = {
-    /**
-     * When `true`, hover/focus/click interactions will be disabled on elements outside
-     * the `DismissableLayer`. Users will need to click twice on outside elements to
-     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
-     */
-    disableOutsidePointerEvents: Signal<boolean>;
-};
-declare const RdxDismissableLayerConfigToken: InjectionToken<RdxDismissableLayerConfig>;
-declare function provideRdxDismissableLayerConfig(factory: () => RdxDismissableLayerConfig): Provider;
-
-export { RdxDismissableLayer, RdxDismissableLayerBranch, RdxDismissableLayerConfigToken, RdxDismissableLayersContextToken, RdxEscapeKeyDown, RdxFocusOutside, RdxPointerDownOutside, provideRdxDismissableLayerConfig };
-export type { RdxDismissableLayerConfig };
+export { RdxDismiss, RdxEscapeKeyDown, RdxFloatingInsideElement, RdxFocusOutside, RdxPointerDownOutside };
+export type { RdxDismissProps, RdxDismissReason, RdxOutsidePressDomEvent, RdxOutsidePressEvent, RdxOutsidePressEventConfig };

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

@@ -1,12 +1,18 @@
 import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal } from '@angular/core';
 import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
-import { BooleanInput, NumberInput } from '@radix-ng/primitives/core';
+import { BooleanInput, NumberInput, RdxCancelableChangeEventDetails } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/dismissable-layer';
 import * as _radix_ng_primitives_editable from '@radix-ng/primitives/editable';
 
 type EditableActivationMode = 'focus' | 'dblclick' | 'none';
 type EditableSubmitMode = 'blur' | 'enter' | 'none' | 'both';
+type RdxEditableValueChangeReason = 'submit' | 'none';
+type RdxEditableValueChangeEventDetails = RdxCancelableChangeEventDetails<RdxEditableValueChangeReason>;
+interface RdxEditableValueChangeEvent {
+    value: string;
+    eventDetails: RdxEditableValueChangeEventDetails;
+}
 type EditableRootContext = {
     disabled: Signal<boolean>;
     value: Signal<string | undefined>;
@@ -20,7 +26,7 @@ type EditableRootContext = {
     activationMode: Signal<EditableActivationMode>;
     edit: () => void;
     cancel: () => void;
-    submit: () => void;
+    submit: (event?: Event) => void;
     maxLength: Signal<number | undefined>;
     required: Signal<boolean>;
     startWithEditMode: Signal<boolean>;
@@ -57,7 +63,7 @@ declare class RdxEditableRoot {
     readonly autoResize: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly required: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     /** Emitted when the value is committed (on submit). */
-    readonly onValueChange: _angular_core.OutputEmitterRef<string>;
+    readonly onValueChange: _angular_core.OutputEmitterRef<RdxEditableValueChangeEvent>;
     readonly isEmpty: Signal<boolean>;
     readonly $placeholder: Signal<{
         edit: string;
@@ -75,7 +81,7 @@ declare class RdxEditableRoot {
     constructor();
     canActivateOnFocus(): boolean;
     handleDismiss(): void;
-    submit(): void;
+    submit(event?: Event): void;
     cancel(): void;
     edit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableRoot, never>;
@@ -144,4 +150,4 @@ declare class RdxEditableModule {
 }
 
 export { RdxEditableArea, RdxEditableCancelTrigger, RdxEditableEditTrigger, RdxEditableInput, RdxEditableModule, RdxEditablePreview, RdxEditableRoot, RdxEditableSubmitTrigger, injectEditableRootContext, provideEditableRootContext };
-export type { EditableActivationMode, EditableRootContext, EditableSubmitMode };
+export type { EditableActivationMode, EditableRootContext, EditableSubmitMode, RdxEditableValueChangeEvent, RdxEditableValueChangeEventDetails, RdxEditableValueChangeReason };

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

@@ -188,6 +188,7 @@ declare class RdxFieldLabel {
      */
     readonly id: _angular_core.InputSignal<string>;
     readonly htmlFor: () => string;
+    constructor();
     protected readonly dataAttr: (value: boolean) => "" | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFieldLabel, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFieldLabel, "[rdxFieldLabel]", ["rdxFieldLabel"], { "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;