@radix-ng/primitives 1.0.0-beta.2 → 1.0.0-beta.4

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

@@ -1,7 +1,8 @@
 import * as i0 from '@angular/core';
-import { Type, Provider, InputSignal, WritableSignal, ModelSignal, Signal, InjectionToken, InputSignalWithTransform, OutputRef, ElementRef, Injector, EffectRef, EffectCleanupRegisterFn, CreateEffectOptions } from '@angular/core';
+import { Type, Provider, InputSignal, WritableSignal, ModelSignal, Signal, InjectionToken, InputSignalWithTransform, OutputRef, Injector, ElementRef, EffectRef, EffectCleanupRegisterFn, CreateEffectOptions } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { DateValue, Time, CalendarDateTime, ZonedDateTime } from '@internationalized/date';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 
 type DataOrientation = 'vertical' | 'horizontal';
 /** Layout direction for bidirectional text. */
@@ -548,6 +549,74 @@ declare function handleCalendarInitialFocus(calendar: HTMLElement): void;
 declare function normalizeHourCycle(hourCycle: HourCycle): "h11" | "h23" | undefined;
 declare function normalizeHour12(hourCycle: HourCycle): boolean | undefined;
 
+/**
+ * Base URL of the documentation site. Each primitive's docs are also served as plain
+ * Markdown at `/<section>/<slug>.md`, which both humans and AI agents can open.
+ */
+declare const DOCS_BASE_URL = "https://radix-ng.com";
+/**
+ * Full URL to a primitive's plain-Markdown docs page.
+ * @param docsPath Documentation path for the owning primitive (e.g. `'components/select'`).
+ */
+declare function docsUrl(docsPath: string): string;
+/**
+ * Emits a deduplicated dev-mode `console.warn` for a recoverable misuse.
+ *
+ * No-op outside `isDevMode()`, so production builds stay silent (and the message
+ * assembly tree-shakes out). Dedupes per `code` per page load, replacing the
+ * hand-rolled `warned` flags individual primitives used to carry.
+ *
+ * @param code Stable, greppable `<primitive>/<slug>` identifier (e.g. `'select/trigger-element'`).
+ * @param message Human-readable explanation of the misuse and how to fix it.
+ * @param docsPath Optional docs path appended as a `See <url>` hint (e.g. `'components/select'`).
+ */
+declare function rdxDevWarning(code: string, message: string, docsPath?: string): void;
+/**
+ * Throws a dev-mode `Error` for unrecoverable misuse (broken markup that cannot work).
+ *
+ * Unlike {@link rdxDevWarning} this always throws when reached — callers that want the
+ * check to stay dev-only should guard the call with `isDevMode()`.
+ *
+ * @param code Stable, greppable `<primitive>/<slug>` identifier (e.g. `'popover/portal-on-element'`).
+ * @param message Human-readable explanation of the misuse and how to fix it.
+ * @param docsPath Optional docs path appended as a `See <url>` hint (e.g. `'components/popover'`).
+ */
+declare function rdxDevError(code: string, message: string, docsPath?: string): never;
+/**
+ * Test-only: clears the per-code dedup set so warning specs stay isolated from one another.
+ */
+declare function resetRdxDevWarnings(): void;
+/**
+ * Dev-mode check: warns when a trigger part sits on a host element that is neither natively
+ * interactive (`<button>`, `<a>`, `<input>`) nor made focusable with `tabindex`.
+ *
+ * Only meaningful for triggers whose selector accepts arbitrary elements **and** that do not
+ * adapt their own ARIA/keyboard handling for non-button hosts — triggers scoped to
+ * `button[...]` already enforce this at the selector level, and triggers that auto-apply
+ * `role`/`tabindex` (e.g. `rdxMenuTrigger`) handle it themselves.
+ *
+ * Must be called inside an injection context (a directive constructor), where the host element
+ * already exists. No-op outside `isDevMode()` and on synthetic hosts (component / `ng-template`),
+ * where `HOST_TAG_NAME` is absent.
+ *
+ * @param triggerName Selector name used in the message, e.g. `'rdxPreviewCardTrigger'`.
+ * @param code Stable diagnostics code, e.g. `'preview-card/trigger-element'`.
+ * @param docsPath Docs path for the See-link, e.g. `'components/preview-card'`.
+ */
+declare function rdxCheckTriggerElement(triggerName: string, code: string, docsPath: string): void;
+/**
+ * Dev-mode check: warns when a label part sits on a non-`<label>` host. The `for` attribute only
+ * associates a `<label>` with a control, so a label part placed on any other element is not
+ * programmatically connected to its control.
+ *
+ * Must be called inside an injection context. No-op outside `isDevMode()` and on synthetic hosts.
+ *
+ * @param labelName Selector name used in the message, e.g. `'rdxFieldLabel'`.
+ * @param code Stable diagnostics code, e.g. `'field/unassociated-label'`.
+ * @param docsPath Docs path for the See-link, e.g. `'components/field'`.
+ */
+declare function rdxCheckLabelElement(labelName: string, code: string, docsPath: string): void;
+
 declare function handleAndDispatchCustomEvent<E extends CustomEvent, OriginalEvent extends Event>(name: string, handler: ((event: E) => void) | undefined, detail: {
     originalEvent: OriginalEvent;
 } & (E extends CustomEvent<infer D> ? D : never)): void;
@@ -790,6 +859,658 @@ interface RdxFormCheckboxControl extends RdxFormUiControl {
     readonly value?: undefined;
 }
 
+interface RdxCancelableChangeEventDetails<Reason extends string = string> {
+    reason: Reason;
+    event: Event;
+    trigger: HTMLElement | undefined;
+    cancel: () => void;
+    isCanceled: () => boolean;
+    preventUnmountOnClose: () => void;
+}
+interface RdxCancelableChangeEventTransaction<Reason extends string = string> {
+    eventDetails: RdxCancelableChangeEventDetails<Reason>;
+    shouldPreventUnmountOnClose: () => boolean;
+}
+declare function createCancelableChangeEventDetails<Reason extends string>(reason: Reason, event: Event, trigger?: HTMLElement): RdxCancelableChangeEventTransaction<Reason>;
+
+/**
+ * The typed event map for the **shared tree-level coordination channel** on {@link RdxFloatingTree}.
+ * Neutral by design — it ships no events initially. Each capability (hover-close, virtual focus, menu
+ * coordination, list navigation) **augments** this interface via module augmentation rather than
+ * emitting untyped strings:
+ *
+ * ```ts
+ * declare module '@radix-ng/primitives/core' {
+ *   interface RdxFloatingEventMap {
+ *     virtualfocus: { id: string; element: HTMLElement | null };
+ *   }
+ * }
+ * ```
+ *
+ * **`openchange` belongs here only per-popup, not per-tree.** Base UI emits `openchange` on the
+ * per-popup `FloatingRootStore.events` (`FloatingRootStore.ts:121`), not on the shared
+ * `FloatingTreeStore.events`. For open-state changes, use {@link RdxFloatingRootContextEventMap} on
+ * the popup's {@link RdxFloatingRootContext.events}, not this tree-level channel.
+ */
+interface RdxFloatingEventMap {
+}
+/**
+ * The typed event map for the **per-popup events channel** on {@link RdxFloatingRootContext} —
+ * the Angular counterpart of Base UI's `FloatingRootStore.events` (`FloatingRootStore.ts:121`).
+ * Unlike the tree channel (one per coordinating root shared by all nested popups), this channel
+ * lives **on the root context** so each popup has its own scoped emitter with no cross-popup bleed.
+ */
+interface RdxFloatingRootContextEventMap {
+    /** The popup's open-state changed. `reason` mirrors Base UI open-change reason strings. */
+    openchange: {
+        open: boolean;
+        reason?: string;
+        event?: Event;
+    };
+}
+/**
+ * Neutral typed event channel — the Angular counterpart of Base UI's `createEventEmitter()`, typed
+ * over `M` (a {@link RdxFloatingEventMap} sub-type for tree-level or a
+ * {@link RdxFloatingRootContextEventMap} sub-type for per-popup).
+ */
+interface RdxFloatingEvents<M extends object = RdxFloatingEventMap> {
+    emit<K extends keyof M>(event: K, data: M[K]): void;
+    on<K extends keyof M>(event: K, listener: (data: M[K]) => void): void;
+    off<K extends keyof M>(event: K, listener: (data: M[K]) => void): void;
+}
+/**
+ * Creates an {@link RdxFloatingEvents} emitter backed by `Map<event, Set<listener>>`, mirroring Base
+ * UI's implementation: synchronous dispatch, set-deduplicated listeners, no replay.
+ *
+ * **Snapshot dispatch:** `emit()` snapshots the listener set before iterating so that a listener
+ * calling `on()`/`off()` during dispatch does not cause skip/revisit issues.
+ */
+declare function createFloatingEvents<M extends object = RdxFloatingEventMap>(): RdxFloatingEvents<M>;
+
+/**
+ * The shared **mounted / open** lifecycle contract every floating capability reads (ADR 0015 §1,
+ * cross-cutting across ADRs 0015/0016/0017). It separates *presence* from *activeness*, which Base
+ * UI keeps distinct (`DialogStore` / `popupStoreUtils`):
+ *
+ * - **`mounted()`** — the node/popup is rendered. Stays `true` through an animated exit (Base UI's
+ *   `FloatingFocusManager` is `disabled={!mounted}`, so the focus trap survives the exit).
+ * - **`open()`** — the popup is logically open. Flips to `false` **immediately** on close, *before*
+ *   unmount.
+ *
+ * The interesting middle state is **closed-but-mounted** (`mounted() && !open()`): an animated exit,
+ * or a popup deliberately kept mounted after close. Its effects are **per-effect**, matching Base UI
+ * (it is *not* "everything off"):
+ *
+ * | concern                          | on `open() === false` (still mounted) |
+ * | -------------------------------- | ------------------------------------- |
+ * | dismissal (Escape/outside-press) | **inactive** — capability reads `open()` |
+ * | `markOthers` marker / aria-hidden| **released**                          |
+ * | internal backdrop                | **`inert`**                           |
+ * | scroll lock                      | **unlocked** (predicate keys off `open()`) |
+ * | focus trap + return-focus        | **persist until unmount** (read `mounted()`) |
+ *
+ * So every consumer reads `open()` for behavior and `mounted()` for presence — never conflating them.
+ *
+ * @remarks
+ * `preventUnmountOnClose` (Base UI's per-close one-shot that holds a popup *mounted after close*) is a
+ * **close-transaction** concern, not a standing boolean — modeling it as a persistent
+ * `signal<boolean>` would pin the popup mounted forever after the first prevented close. Whether Radix
+ * exposes it publicly or maps it onto `RdxPortalPresence` (keep-mounted) is pinned in ADR 0015/0017
+ * Phase 0; it is intentionally **not** baked into this contract.
+ */
+interface RdxFloatingLifecycle {
+    /** Presence: the node/popup is rendered (stays `true` during an animated exit). */
+    readonly mounted: () => boolean;
+    /** Activeness: the popup is open (flips `false` immediately on close, before unmount). */
+    readonly open: () => boolean;
+}
+
+/**
+ * Per-popup store of active **trigger** elements — the Angular counterpart of Base UI's
+ * `triggerElements` (`PopupTriggerMap`) on each `FloatingRootStore`. One registry lives on each
+ * {@link RdxFloatingRootContext} (NOT on the shared tree, and NOT on the node — the context can exist
+ * without a node, e.g. the node-optional Navigation Menu case). Scoping it per-context is what keeps
+ * one independent popup's trigger from counting as inside-content for an unrelated popup.
+ *
+ * Within its context it is read by **both** the dismissal engine (ADR 0015 — outside-press / focus-out
+ * containment) and the focus manager (ADR 0017 — inside-element checks), so the two never drift into
+ * different inside-element sets (ADR 0015 §1 pillar 3, §2). A trigger is plain inside-content: it has
+ * **no** floating node and **no** parent — only its membership is stored here.
+ *
+ * Matching mirrors Base UI's `isTargetInsideEnabledTrigger`: a target counts when it is exactly a
+ * registered element ({@link hasElement}) **or** a descendant of one ({@link hasMatchingElement}).
+ * Membership is by **reference** (`Set.has` / `Node.contains`), so it stays correct **cross-realm** for
+ * elements from another `Window` / iframe — where `target instanceof Element` against the local realm
+ * would wrongly return `false`.
+ */
+declare class RdxTriggerRegistry {
+    private readonly elements;
+    /** Registers `element` as a trigger. Idempotent. */
+    add(element: Element): void;
+    /** Removes `element` from the registry. */
+    delete(element: Element): void;
+    /**
+     * Exact membership — Base UI `triggerElements.hasElement(target)`. Uses reference identity
+     * (`Set.has`), **not** `instanceof Element`, so a trigger from another realm/iframe still matches.
+     */
+    hasElement(target: EventTarget | Node | null): boolean;
+    /**
+     * Ancestor match — Base UI `hasMatchingElement((t) => contains(t, target))`: `true` when any
+     * registered trigger contains `target`. Catches a press/focus landing on a child of the trigger.
+     */
+    hasMatchingElement(target: Node | null): boolean;
+    /** `true` when `target` is a registered trigger or lives inside one. */
+    contains(target: EventTarget | Node | null): boolean;
+}
+
+/** Initialization for a {@link RdxFloatingRootContext}. */
+interface RdxFloatingRootContextInit {
+    ownerDocument: Document;
+    /** Popup open-state lifecycle. Defaults to `() => false`. */
+    open?: () => boolean;
+    floatingElement?: HTMLElement | null;
+    referenceElement?: Element | null;
+}
+/**
+ * The per-popup **root context / store** — the Angular counterpart of Base UI's `FloatingRootStore`
+ * (`FloatingRootContext`). It is a **separate entity from {@link RdxFloatingNode}** (which is only
+ * `id` + `parent` + a context ref), mirroring Base UI: the node carries tree membership, the root
+ * context carries the popup's `open`, elements, and trigger registry.
+ *
+ * Crucially it can exist **without** a node — the `getEmptyRootContext()` analog ({@link
+ * createFloatingRootContext}) — which is what lets a **node-optional** capability (Navigation Menu,
+ * ADR 0015 §1 / ADR 0017 #12) still read `open()`, `triggers`, and the elements while its tree node is
+ * temporarily absent. A dismissal/focus capability therefore references a root context **mandatorily**
+ * and a node **optionally**.
+ *
+ * `floatingElement` / `referenceElement` are exposed read-only and mutated **only** through the
+ * validated setters, so a consumer cannot bypass the owner-`Document` invariant with a raw assignment.
+ */
+declare class RdxFloatingRootContext {
+    readonly ownerDocument: Document;
+    /** Neutral popup open-state lifecycle (singular). Tree traversal's `onlyOpen` filter reads this. */
+    readonly open: () => boolean;
+    /** Per-popup trigger registry (Base UI `triggerElements`), read by both dismissal and focus. */
+    readonly triggers: RdxTriggerRegistry;
+    /**
+     * Per-popup typed event channel (Base UI `FloatingRootStore.events`). Scoped to this popup,
+     * so open-change events carry no cross-popup bleed. Use `events.emit('openchange', …)` when
+     * the popup's `open` state changes; dismissal / focus manager subscribe here, not on the tree.
+     */
+    readonly events: RdxFloatingEvents<RdxFloatingRootContextEventMap>;
+    private floatingElementRef;
+    private referenceElementRef;
+    private readonly floatingElementsRef;
+    constructor(init: RdxFloatingRootContextInit);
+    /** The floating (popup) element, once it renders. `null` while mounted-but-not-yet-rendered. */
+    get floatingElement(): HTMLElement | null;
+    /** The reference (anchor / trigger) element the popup is positioned against. */
+    get referenceElement(): Element | null;
+    /**
+     * **All** of this layer's own root elements — the popup plus any extra roots a primitive owns (e.g.
+     * a Dialog backdrop relocated as a separate body sibling). This is DOM-footprint bookkeeping for
+     * primitive-specific checks; `markOthers` keep-sets are intentionally narrower and do not include
+     * sibling roots such as backdrops. Distinct from {@link floatingElement} (the single popup, used for
+     * press / focus containment).
+     */
+    get floatingElements(): ReadonlySet<Element>;
+    /** Assigns the floating (popup) element, validating it shares this context's `ownerDocument`. */
+    setFloatingElement(element: HTMLElement | null): void;
+    /** Registers an additional owned root element (e.g. a backdrop) into {@link floatingElements}. */
+    addFloatingElement(element: Element): void;
+    /** Removes a previously {@link addFloatingElement | added} owned root element. */
+    removeFloatingElement(element: Element): void;
+    /** Assigns the reference element, validating it shares this context's `ownerDocument`. */
+    setReferenceElement(element: Element | null): void;
+    private assertSameDocument;
+}
+/**
+ * Creates a standalone {@link RdxFloatingRootContext} **without** a tree node — the Angular counterpart
+ * of Base UI's `getEmptyRootContext()`. Use it for a node-optional capability that needs a root context
+ * before (or without) registering a floating node.
+ */
+declare function createFloatingRootContext(init: RdxFloatingRootContextInit): RdxFloatingRootContext;
+
+/**
+ * Module-private construction key. The {@link RdxFloatingNode} constructor requires it, and its type is
+ * a non-exported `unique symbol`, so consumers can neither name it (compile error) nor produce it
+ * (runtime guard) — a node can only be created through {@link RdxFloatingTree.register}, never a loose
+ * `new RdxFloatingNode(...)` that would exist outside `tree.all`.
+ */
+declare const NODE_CONSTRUCT_KEY: unique symbol;
+/**
+ * A neutral node in the shared floating tree — the Angular counterpart of Base UI's `FloatingNode`
+ * (`{ id, parentId, context? }`). It is deliberately **lightweight**: tree membership only. The
+ * popup's `open` state, trigger registry, and elements live on the separate {@link
+ * RdxFloatingRootContext}, exactly as Base UI splits `FloatingNode` from `FloatingRootStore`.
+ *
+ * `parent` and `context` are exposed **read-only**; they are mutated **only** through {@link
+ * RdxFloatingTree.setParent} / {@link RdxFloatingTree.setContext} (which enforce the cycle and
+ * owner-`Document` invariants). The backing state is held in a module-private `WeakMap`, so a consumer
+ * cannot reach around the tree with `node.parent = …` / `node.context = …`.
+ *
+ * `context` may be `null` (a contextless intermediate node). Open-ness is read from the context — there
+ * is no `open` on the node — and tree traversal's `onlyOpen` filter reads `node.context?.open()`,
+ * mirroring Base UI's `getNodeChildren` filtering on `child.context?.open`. Presence (`mounted`) is
+ * implicit: a node is mounted **iff** it is registered in the tree.
+ */
+declare class RdxFloatingNode {
+    readonly id: string;
+    /** Which tree (store) this node belongs to — Base UI's `externalTree`. */
+    readonly tree: RdxFloatingTree;
+    /** @internal — constructed only by {@link RdxFloatingTree.register} (guarded by a module-private key). */
+    constructor(construct: typeof NODE_CONSTRUCT_KEY, id: string, tree: RdxFloatingTree, parent: RdxFloatingNode | null, context: RdxFloatingRootContext | null);
+    /** Resolved **logical** parent (DI-derived). Reassign via {@link RdxFloatingTree.setParent}. */
+    get parent(): RdxFloatingNode | null;
+    /** The per-popup root context/store. `null` for a contextless node. Reassign via `tree.setContext`. */
+    get context(): RdxFloatingRootContext | null;
+}
+/**
+ * Discriminated parent-assignment override (ADR 0015 §1). A nullable optional would collapse
+ * `undefined`/`null` in Angular signals, so "no override" (`inherit`) and "explicit independent root"
+ * (`root`) must be **distinct** values — they must not both reduce to `parent == null`.
+ */
+type RdxFloatingParentOverride = {
+    kind: 'inherit';
+} | {
+    kind: 'root';
+} | {
+    kind: 'node';
+    parent: RdxFloatingNode;
+};
+/** Initialization for {@link RdxFloatingTree.register}. The caller resolves `inherit` before calling. */
+interface RdxFloatingNodeInit {
+    id: string;
+    /** Already-resolved logical parent (`null` for a root). */
+    parent: RdxFloatingNode | null;
+    /** The per-popup root context. `null` for a contextless intermediate node. */
+    context: RdxFloatingRootContext | null;
+}
+/**
+ * The shared floating tree (node store) — the Angular counterpart of Base UI's `FloatingTreeStore`.
+ *
+ * It owns a flat set of {@link RdxFloatingNode | nodes} linked by `parent`, an adjacency index for
+ * O(1) child lookup, and a neutral typed {@link RdxFloatingEvents | event channel}. It owns **neither**
+ * trigger registries **nor** `open` state — those live per-popup on each {@link RdxFloatingRootContext}
+ * (Base UI keeps them on the root store, not the tree store). Dismissal (ADR 0015) and the focus
+ * manager (ADR 0017) read the **same** nodes, traversal, and events; neither owns the tree.
+ *
+ * Ancestry is **logical** (DI-derived), not DOM-derived, so portal relocation never changes ownership
+ * (ADR 0015 §1). Independent roots are **not** coordinated against each other (Base UI parity): the
+ * tree only answers questions *within* itself.
+ *
+ * **Performance:** `isRegistered()` is O(1) via `nodeSet`; `directChildren()` is O(1) via the
+ * `childrenOf` adjacency map; `ancestors()` is O(depth); `children()` is O(n) total.
+ */
+declare class RdxFloatingTree {
+    /**
+     * Neutral typed event channel (hover-close, virtual focus, menu coordination, list nav). Private to
+     * this tree, which is scoped-by-default (one per coordinating root via `provideFloatingTree()`), so
+     * events never leak across unrelated popups — matching Base UI's per-`FloatingTree` events.
+     */
+    readonly events: RdxFloatingEvents;
+    /** O(1) membership test and snapshot for `all`. */
+    private readonly nodeSet;
+    /**
+     * Adjacency index: maps each node (or `null` for root nodes) to its direct children in
+     * registration order. Maintained in sync by `register`, `unregister`, and `setParent`.
+     * Eliminates the O(n) `filter` per node in recursive traversal. Invariant: only **non-empty**
+     * arrays are stored — an entry is pruned the moment its last child leaves, so a key never
+     * outlives its node (see `removeFromChildrenOf`).
+     */
+    private readonly childrenOf;
+    /** Registers a new node. `init.parent` must already be resolved (DI layer handles `inherit`). */
+    register(init: RdxFloatingNodeInit): RdxFloatingNode;
+    /** Removes a node from the tree. Children are **not** removed — they keep their `parent` reference. */
+    unregister(node: RdxFloatingNode): void;
+    /**
+     * Associates / re-associates / clears a node's root context after registration (Base UI attaches
+     * the context once the floating element resolves). Validates the new context's owner-`Document`
+     * against the nearest context-bearing **ancestor** (through contextless intermediates) **and**
+     * every context-bearing **descendant**, so a contextless intermediate can never bridge two
+     * documents. Allows the `null → context → null` lifecycle.
+     */
+    setContext(node: RdxFloatingNode, context: RdxFloatingRootContext | null): void;
+    /** Reparents an existing node (detached composition / explicit `node` override), with cycle guard. */
+    setParent(node: RdxFloatingNode, parent: RdxFloatingNode | null): void;
+    /**
+     * Direct + transitive children, in registration order. The `onlyOpen` filter (default `true`)
+     * filters the **result** by each node's `context?.open()` lifecycle but **never** aborts recursion
+     * at a closed node, so a keep-mounted/closed parent never hides an open grandchild (Base UI
+     * `getNodeChildren`, ADR 0015 §1 traversal contract).
+     *
+     * Dismissal children queries pass `onlyOpen: true` (the `hasBlockingChild` pattern in the
+     * capability). The focus manager's focus-return check passes `onlyOpen: false` explicitly (Base UI
+     * `FloatingFocusManager.tsx:842`) — so focus inside a closed-but-mounted descendant still counts as
+     * "inside the tree". Always pass `onlyOpen` explicitly for non-dismissal paths; do not inherit the
+     * default.
+     */
+    children(node: RdxFloatingNode, options?: {
+        onlyOpen?: boolean;
+    }): RdxFloatingNode[];
+    /**
+     * Logical ancestors of `node`, nearest first (Base UI `getNodeAncestors`). The walk **stops at an
+     * unregistered node**: Base UI resolves ancestry by `parentId` lookup in the live nodes array, so
+     * unregistering a parent breaks the chain (a removed middle node truncates ancestry — its children
+     * keep the raw `parent` identity but it no longer appears as an ancestor). This avoids a "ghost"
+     * ancestor lingering in DI-ownership / document / dismissal/focus traversal when Angular destroys a
+     * parent before its child.
+     */
+    ancestors(node: RdxFloatingNode): RdxFloatingNode[];
+    /** Snapshot of all registered nodes (debugging / diagnostics). Registration order is preserved. */
+    get all(): readonly RdxFloatingNode[];
+    /** Direct children of `parent` in registration order. O(1) via the adjacency map. */
+    private directChildren;
+    private addToChildrenOf;
+    private removeFromChildrenOf;
+    /**
+     * Nearest context-bearing node walking up from `node` (inclusive), skipping contextless ancestors.
+     * Stops at an unregistered node (same ghost-ancestry rule as {@link ancestors}).
+     */
+    private nearestContext;
+    /** All contexts among `node`'s transitive descendants (skips `node` itself). */
+    private descendantContexts;
+    /**
+     * Dev-only: validates every context in `node`'s subtree (node + transitive descendants) against
+     * the nearest context-bearing ancestor walking up from `newParent`. Shared between `setParent`
+     * (moves a subtree under a new parent) to keep the document-consistency rule in one place.
+     */
+    private assertSubtreeDocuments;
+    /** Whether `node` is currently registered in this tree. O(1). */
+    private isRegistered;
+    /**
+     * Guards that `node` actually belongs to **this** tree and is still registered — so a tree can
+     * never mutate/traverse a node owned by another tree (which would leave `node.tree` pointing
+     * elsewhere while its ancestry leads here) or one that was already unregistered.
+     */
+    private assertOwnedNode;
+    /** A parent (when given) must belong to this tree **and** still be registered. */
+    private assertRegisterableParent;
+    /** Owner-`Document` consistency between a node's context and a related (ancestor/descendant) context. */
+    private assertContextDocument;
+}
+
+/**
+ * Registers a {@link RdxFloatingNode} into the shared {@link RdxFloatingTree} for its DI subtree and
+ * propagates the registration handle to descendants — the reusable Angular counterpart of mounting a
+ * Base UI `<FloatingNode>` (ADR 0015 §1, Phase 1). It is the **single** place that runs the handle
+ * pattern; the dismissal capability (ADR 0015) and the focus manager (ADR 0017) **consume** the node /
+ * context / tree it registers, they do not re-implement registration.
+ *
+ * **What it owns vs. what it reads.** It provides its own {@link RdxFloatingRegistrationContext} (so
+ * descendants resolve it with `skipSelf`) and registers/unregisters a node reactively. It does **not**
+ * create the tree or the root context — a coordination-boundary primitive root supplies those
+ * (`provideFloatingTree()` inherit-or-create + `provideFloatingRootContext()`); this directive injects
+ * them. With **no** enclosing tree it runs **node-optional** (`status() === 'detached'`, `node() ===
+ * null`), reading its context directly — the standalone `rdxDismissableLayer` case.
+ *
+ * **Resolution (per {@link RdxFloatingParentOverride}).** Only an `inherit` node depends on the DI
+ * parent, so only it waits on a `pending` parent; `root` / `node` overrides are independent and register
+ * immediately. The node carries the injected {@link RDX_FLOATING_ROOT_CONTEXT} (or `null` for a
+ * contextless intermediate). All teardown (re-resolution **and** destroy) unregisters the node and
+ * reverts the handle.
+ */
+declare class RdxFloatingNodeRegistration {
+    /** Explicit tree for detached sibling composition — Base UI's `externalTree`. */
+    readonly externalTree: i0.InputSignal<RdxFloatingTree | null>;
+    /** How this node's logical parent is resolved. Defaults to `inherit` (nearest DI ancestor). */
+    readonly parentOverride: i0.InputSignal<RdxFloatingParentOverride>;
+    /** Own handle — the WRITER side (concrete class); this directive is the only writer. */
+    private readonly selfReg;
+    /** Nearest ancestor handle — the READER side (reader-typed token), or `null` at the top. */
+    private readonly parentReg;
+    /** The enclosing tree, if a coordination boundary provided one (else node-optional). */
+    private readonly ambientTree;
+    /** This node's per-popup context, or `null` for a contextless intermediate node. */
+    private readonly rootContext;
+    private readonly nodeId;
+    /** This directive's node once registered (`null` while `pending` / `detached`). */
+    readonly node: Signal<RdxFloatingNode | null>;
+    /** Lifecycle phase of this directive's registration (`pending` | `detached` | `registered`). */
+    readonly status: Signal<_radix_ng_primitives_core.RdxFloatingRegistrationStatus>;
+    /** The tree this node joined (`null` until `registered`). */
+    readonly tree: Signal<RdxFloatingTree | null>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RdxFloatingNodeRegistration, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RdxFloatingNodeRegistration, "[rdxFloatingNode]", ["rdxFloatingNode"], { "externalTree": { "alias": "externalTree"; "required": false; "isSignal": true; }; "parentOverride": { "alias": "parentOverride"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** The three lifecycle phases of a {@link RdxFloatingRegistrationContext} (see {@link RegistrationState}). */
+type RdxFloatingRegistrationStatus = 'pending' | 'detached' | 'registered';
+/**
+ * The **read-only projection** of a registration handle — what a **descendant** injects (it reads its
+ * nearest ancestor's handle to resolve its logical parent, ADR 0015 §1). It deliberately exposes only
+ * the reactive reads (`status` / `tree` / `node`) and **not** the writers (`register` / `markDetached` /
+ * `clear`), which belong solely to the directive that owns the handle: a descendant must never be able
+ * to clear or re-point its parent's registration. The {@link RDX_FLOATING_REGISTRATION} token is typed
+ * as this reader, so the ergonomic, cast-free injection path is read-only; the owning directive uses the
+ * concrete {@link RdxFloatingRegistrationContext} type (the writer) for its own handle.
+ */
+interface RdxFloatingRegistrationReader {
+    readonly status: Signal<RdxFloatingRegistrationStatus>;
+    readonly tree: Signal<RdxFloatingTree | null>;
+    readonly node: Signal<RdxFloatingNode | null>;
+}
+/**
+ * A **stable DI handle** created at injector formation time and filled in at runtime once the
+ * registration directive resolves its `externalTree` / `parentOverride` inputs.
+ *
+ * **Why a handle, not direct token replacement.** Angular injectors are sealed at creation — a
+ * directive that resolves its tree from a runtime `externalTree` input cannot change what
+ * `RDX_FLOATING_TREE` resolves to for its subtree afterwards. The handle is the object that _is_
+ * provided at creation; its internal state signal changes at runtime. Descendants inject the handle
+ * (with `skipSelf: true`) and read `parentReg.tree()` / `parentReg.node()` reactively — they never
+ * depend on tokens being swapped post-construction.
+ *
+ * **Atomicity.** `tree` and `node` are **not** separate `WritableSignal`s — independent `.set()`
+ * calls would create intermediate states where `node.tree !== tree`. Instead there is **one** private
+ * {@link RegistrationState} signal; `register(tree, node)` sets the `registered` payload after asserting
+ * `node.tree === tree`, `markDetached()` records "resolved, no node", and `clear()` reverts to
+ * `pending`. The `tree`/`node`/`status` reads are `computed()` over that one signal, so they can never
+ * disagree.
+ *
+ * **Registration directive usage pattern:**
+ *
+ * ```ts
+ * @Directive({ providers: [provideFloatingRegistration()] })
+ * class SomeFloatingDirective {
+ *   // Own handle — the WRITER side. Inject the concrete type so register()/markDetached()/clear() are
+ *   // available; this is the only place that writes this handle.
+ *   private readonly selfReg = inject(RdxFloatingRegistrationContext);
+ *   // Parent handle — the READER side (token is reader-typed). A descendant can read status/tree/node
+ *   // but cannot mutate the parent's registration.
+ *   private readonly parentReg  = inject(RDX_FLOATING_REGISTRATION, { optional: true, skipSelf: true });
+ *   private readonly ambientTree = inject(RDX_FLOATING_TREE, { optional: true });
+ *
+ *   constructor() {
+ *     effect((onCleanup) => {
+ *       const override = this.parentOverride(); // { kind: 'inherit' | 'root' | 'node' }
+ *
+ *       // ONLY an `inherit` node depends on the DI parent, so only it waits on a `pending` parent (a
+ *       // `pending` parent is NOT "no parent"; reading status() subscribes us, so we re-run when it
+ *       // flips). `root` / `node` overrides are independent of the DI ancestor and register NOW —
+ *       // waiting on the DI parent would wrongly stall them, or strand them if that parent is destroyed.
+ *       if (override.kind === 'inherit' && this.parentReg?.status() === 'pending') return;
+ *
+ *       // Logical parent from the override (DI parent only for `inherit`; a `detached` parent reads
+ *       // null → this node becomes a root in its tree).
+ *       const parentNode =
+ *         override.kind === 'node' ? override.parent
+ *         : override.kind === 'root' ? null
+ *         : (this.parentReg?.node() ?? null); // 'inherit'
+ *
+ *       // Tree selection (resolveFloatingTree's logic; inject() is illegal inside effect()). A `node`
+ *       // override must join its parent's tree.
+ *       const externalTree = this.externalTreeInput(); // input() signal
+ *       const resolvedTree =
+ *         (override.kind === 'node' ? override.parent.tree : undefined) ??
+ *         externalTree ?? this.parentReg?.tree() ?? this.ambientTree;
+ *       if (!resolvedTree) {
+ *         this.selfReg.markDetached(); // node-optional: resolved, but no tree → no node
+ *         return;
+ *       }
+ *
+ *       const node = resolvedTree.register({ id: ..., parent: parentNode, context: ... });
+ *       this.selfReg.register(resolvedTree, node);
+ *
+ *       onCleanup(() => {
+ *         resolvedTree.unregister(node);
+ *         this.selfReg.clear(); // transient: back to 'pending' until the effect re-resolves
+ *       });
+ *     });
+ *   }
+ * }
+ * ```
+ */
+declare class RdxFloatingRegistrationContext implements RdxFloatingRegistrationReader {
+    private readonly _state;
+    /**
+     * Lifecycle phase: `pending` (resolving — children must wait), `detached` (resolved, node-optional),
+     * or `registered`. A `computed()` over the one internal state signal. See {@link RegistrationState}.
+     */
+    readonly status: Signal<RdxFloatingRegistrationStatus>;
+    /**
+     * The tree this directive joined, or `null` unless `status() === 'registered'`. A `computed()`
+     * derived from the internal state — always consistent with {@link node} and {@link status}.
+     */
+    readonly tree: Signal<RdxFloatingTree | null>;
+    /**
+     * The node this directive registered, or `null` unless `status() === 'registered'`. A `computed()`
+     * derived from the internal state — always consistent with {@link tree}
+     * (`node.tree === tree` is invariant in the `registered` state).
+     */
+    readonly node: Signal<RdxFloatingNode | null>;
+    /**
+     * Atomically records the resolved tree and the registered node (`status → 'registered'`). Asserts
+     * `node.tree === tree` so no state where `tree` and `node` point to different stores can exist.
+     * Called by the directive inside `effect()` after `tree.register(…)` succeeds.
+     */
+    register(tree: RdxFloatingTree, node: RdxFloatingNode): void;
+    /**
+     * Records that the directive **resolved but has no node** (`status → 'detached'`): node-optional —
+     * no tree was available (e.g. a standalone `rdxDismissableLayer`). Distinct from `pending`: a child
+     * treats a `detached` parent as absent (inherits `null`), whereas it must **wait** on a `pending` one.
+     */
+    markDetached(): void;
+    /**
+     * Reverts to `pending` (the `onCleanup` counterpart of {@link register} / {@link markDetached}).
+     * Called after `tree.unregister(node)` so the handle re-enters the "resolving" phase until the
+     * directive's effect re-runs; `tree`/`node` read `null` again.
+     */
+    clear(): void;
+}
+/**
+ * DI token for the nearest ancestor's registration handle, **typed as the read-only
+ * {@link RdxFloatingRegistrationReader}**. A descendant injects it with `{ optional: true, skipSelf:
+ * true }` to read its parent's `status` / `tree` / `node` — and, because the token is reader-typed,
+ * **cannot** call the parent's writers (`register` / `markDetached` / `clear`) without a deliberate
+ * cast. The owning directive writes through its own handle, which it injects by the concrete
+ * {@link RdxFloatingRegistrationContext} type instead (see {@link provideFloatingRegistration}).
+ */
+declare const RDX_FLOATING_REGISTRATION: InjectionToken<RdxFloatingRegistrationReader>;
+/**
+ * Seals a fresh registration handle into this directive's injector at creation time. Returns **two**
+ * providers backed by **one** instance: the concrete {@link RdxFloatingRegistrationContext} (the
+ * writer, injected by the owning directive) and a reader-typed {@link RDX_FLOATING_REGISTRATION} alias
+ * (`useExisting`) that descendants inject. Splitting writer from reader is what stops a descendant from
+ * mutating its parent's registration. Call this in a directive's `providers` array; the directive then
+ * calls `selfReg.register(tree, node)` / `markDetached()` / `clear()` on its own (writer) handle.
+ */
+declare function provideFloatingRegistration(): Provider[];
+
+/** Default marker attribute on the imperatively-created internal backdrop element. */
+declare const RDX_INTERNAL_BACKDROP_ATTR = "data-rdx-internal-backdrop";
+interface RdxInternalBackdropOptions {
+    /** Whether the backdrop should exist (modal && reason-appropriate). Reactive — read in an effect. */
+    shouldRender: () => boolean;
+    /** Whether the popup is open. Reactive — drives `inert` during the closed-but-mounted exit window. */
+    isOpen: () => boolean;
+    /**
+     * The element to keep interactive through a clip-path "cutout" (e.g. the trigger, so a toggle-close
+     * click still reaches it), or `null` for a full backdrop. Read once when the backdrop is created.
+     */
+    cutout?: () => Element | null;
+    /** Marker attribute applied to the backdrop. Defaults to {@link RDX_INTERNAL_BACKDROP_ATTR}. */
+    marker?: string;
+    /** Let pointer/wheel events pass through the backdrop while keeping it mounted for lifecycle parity. */
+    passThrough?: () => boolean;
+}
+/**
+ * Renders Base UI's **internal backdrop** for a modal floating popup: a full-viewport element that
+ * intercepts background pointer events (so the page behind the popup is non-interactive) **and** is
+ * itself the outside-press target — clicking it lets the dismissal capability close the popup. This is
+ * why a plain `inert` pass on outside elements is not enough: an inert element dispatches no pointer
+ * event, so the popup could never close on an outside click. An optional clip-path cutout keeps the
+ * trigger (or another region) clickable.
+ *
+ * Inserted as a **sibling before the positioner** — a sibling, not a child: a `position: fixed` element
+ * inside a transformed positioner would be clipped to the positioner's box, not the viewport. The
+ * positioner's own stacking (its `z-index`) keeps the popup above the backdrop.
+ *
+ * Call from the positioner directive inside `afterNextRender` (so the structural portal has already
+ * relocated the positioner into its container).
+ */
+declare function setupInternalBackdrop(positioner: HTMLElement, injector: Injector, options: RdxInternalBackdropOptions): void;
+
+/**
+ * The nearest shared {@link RdxFloatingTree}. **Scoped-by-default, sharing explicit** — strict Base UI
+ * parity: Base UI creates a `FloatingTree` only at the **coordination boundary** (e.g. a top-level Menu
+ * renders `<FloatingTree>`, a nested submenu does **not** — it inherits the parent's store,
+ * `MenuRoot.tsx:533`). There is deliberately **no** application-root provider, so the token resolves only
+ * under a root that opts in with {@link provideFloatingTree}; elsewhere injecting it optionally yields
+ * `null` and the primitive is its own independent root (`parent === null`).
+ */
+declare const RDX_FLOATING_TREE: InjectionToken<RdxFloatingTree>;
+/**
+ * Provides a {@link RdxFloatingTree} for a subtree — the Angular `FloatingTree` analogue. **Inherit-or-
+ * create:** it returns the **nearest ancestor tree** if one is already provided above, and creates a new
+ * one **only at the top coordination boundary**. This is what makes it safe for a nesting-capable root
+ * (Menu/Menubar/Context Menu/nested Dialog) to put it in `providers` unconditionally — a **nested**
+ * instance inherits the parent's tree (so its node parents correctly), while the **top** instance starts
+ * the store. (An always-new tree on a nested root would split ancestry / throw `cross-tree-parent`.)
+ *
+ * **Tree selection is separate from parent assignment** (Base UI: `tree = externalTree ?? contextTree`,
+ * `parentId = nearest FloatingNodeContext`). This helper + {@link resolveFloatingTree} own tree
+ * selection. Parent assignment is resolved at runtime via the `RdxFloatingRegistrationContext` handle
+ * (`parentReg.node()` in `effect()`). In particular `{ kind: 'root' }` is **not** tree isolation — it
+ * sets `parent = null` **within the same tree**. A genuinely separate tree is supplied explicitly via
+ * `resolveFloatingTree(externalTree)`.
+ */
+declare function provideFloatingTree(): Provider;
+/**
+ * Resolves **which tree** a node joins — the tree-selection contract, the Angular counterpart of Base
+ * UI's `externalTree ?? contextTree` (`FloatingTree.tsx:25`). An explicit `externalTree` wins,
+ * otherwise the nearest injected {@link RDX_FLOATING_TREE} (or `null` → the capability runs
+ * **node-optional**). Parent assignment is separate — resolved reactively via
+ * `parentReg.node()` from the {@link RDX_FLOATING_REGISTRATION} handle, not via a token.
+ *
+ * For a **detached** node registered with an explicit `{ kind: 'node', parent }` override from a sibling
+ * injector, the nearest injected tree may be absent or a *different* tree than `parent.tree` — so the
+ * caller **must** pass `externalTree = override.parent.tree` here, so the node joins its parent's tree (the
+ * cross-tree invariant then holds). Must be called in an injection context when `externalTree` is omitted.
+ */
+declare function resolveFloatingTree(externalTree?: RdxFloatingTree | null): RdxFloatingTree | null;
+/**
+ * The shared per-popup {@link RdxFloatingRootContext} — the Angular counterpart of Base UI's
+ * `FloatingRootContext`, created by `useFloatingRootContext` at the **primitive root** and **received**
+ * by `useDismiss` / `FloatingFocusManager` (they never create their own). Mirroring that: a primitive
+ * root (Dialog/Popover/Menu/…) creates **one** context and provides it here; the dismissal capability
+ * (ADR 0015) and the focus manager (ADR 0017) read the **same** context, so `open`, `triggers`, and the
+ * elements are never split across mechanisms.
+ *
+ * Optional: a **standalone** `rdxDismissableLayer` (no enclosing primitive root) has none, and
+ * {@link injectFloatingRootContext} creates a fallback for that case only.
+ */
+declare const RDX_FLOATING_ROOT_CONTEXT: InjectionToken<RdxFloatingRootContext>;
+/** Provides the shared {@link RdxFloatingRootContext} for a primitive root's subtree. */
+declare function provideFloatingRootContext(factory: () => RdxFloatingRootContext): Provider;
+/**
+ * Returns the shared {@link RdxFloatingRootContext} provided by an enclosing primitive root, or creates
+ * a **standalone fallback** via `fallback()` when none is provided (a bare `rdxDismissableLayer`). Must be
+ * called in an injection context.
+ */
+declare function injectFloatingRootContext(fallback: () => RdxFloatingRootContext): RdxFloatingRootContext;
+
 declare function injectDocument(): Document;
 
 declare function elementSize({ elementRef, injector }: {
@@ -800,7 +1521,13 @@ declare function elementSize({ elementRef, injector }: {
     height: number;
 }>;
 
-declare function getActiveElement(): Element | null;
+/**
+ * The deepest active element, descending into open shadow roots. Pass a specific `root`
+ * (`Document` or `ShadowRoot`) to read focus in that document — defaults to the global `document`
+ * (backward compatible). A focus scope passes its host's `ownerDocument` so it stays correct across
+ * iframes / multi-document environments.
+ */
+declare function getActiveElement(root?: DocumentOrShadowRoot): Element | null;
 
 /**
  * Creates a resize observer effect for element
@@ -817,19 +1544,40 @@ declare function resizeEffect(options: {
     onResize: ResizeObserverCallback;
 }): EffectRef;
 
+/** Marker attribute set on `<html>` while scroll is locked (a strategy-independent test/CSS hook). */
+declare const RDX_SCROLL_LOCKED_ATTR = "data-rdx-scroll-locked";
+interface RdxScrollLockOptions {
+    /** Element whose owner document should be locked. Defaults to Angular's injected DOCUMENT. */
+    referenceElement?: () => Element | null;
+}
 /**
- * Locks page scrolling while `active()` is `true`, and restores the original state when it becomes
- * `false` or the calling context is destroyed.
- *
- * Locks **both** `<body>` and `<html>`: a `body { overflow: hidden }` lock alone does *not* stop the
- * page when `<html>` is the scroller (e.g. a global `overflow-y: scroll`, as Storybook sets), because
- * body-overflow only propagates to the viewport when `<html>`'s overflow is `visible`. The width of
- * the removed scrollbar is added as `padding-right` on `<html>` so the page doesn't shift.
+ * Locks page scrolling while `active()` is `true`, restoring the original state when it becomes `false`
+ * or the calling context is destroyed.
  *
- * Lock ownership is shared across all callers via a single module-level counter, so nested or
- * concurrent overlays compose correctly. Must be called in an injection context.
+ * This is the full Base UI `useScrollLock` behavioral set (ADR 0016 §1): it picks the **overlay** strategy
+ * (plain `overflow: hidden`) for iOS / overlay-scrollbar documents and the **inset** strategy for desktop
+ * scrollbars — the latter preserves the scroll position, reserves the scrollbar gutter (no content shift),
+ * bails out during a Safari pinch-zoom, and re-locks on resize. Locks compose across all callers in the
+ * same document via a shared per-`Document` ref count, and state is isolated per `Document` (iframe-safe).
+ * No-op on the server. Must be called in an injection context.
+ */
+declare function useScrollLock(active: Signal<boolean>, options?: RdxScrollLockOptions): void;
+/** Options for {@link useAnchoredScrollLock}. */
+interface RdxAnchoredScrollLockOptions {
+    /** Whether the popup was opened by **touch** — the near-fullscreen gate applies only then. */
+    touchOpen: () => boolean;
+    /** The popup / positioner element whose width decides the touch gate (measured vs the viewport). */
+    element: () => HTMLElement | null;
+}
+/**
+ * Scroll lock for an **anchored** popup (Base UI `useAnchoredPopupScrollLock`, ADR 0016 §3). For a
+ * non-touch open it behaves exactly like {@link useScrollLock} (locks while `enabled()`). For a **touch**
+ * open it locks **only** when the popup is effectively viewport-width (`popupWidth >= viewportWidth -
+ * 20px`) — otherwise the page stays scrollable so the user can swipe outside to dismiss the popup. The
+ * width is measured off `element()`; reading `offsetWidth` forces layout, so it is accurate even before
+ * the popup is positioned (visibility does not affect layout). Must be called in an injection context.
  */
-declare function useScrollLock(active: Signal<boolean>): void;
+declare function useAnchoredScrollLock(enabled: Signal<boolean>, options: RdxAnchoredScrollLockOptions): void;
 
 type ArrowKeyOptions = 'horizontal' | 'vertical' | 'both';
 interface ArrowNavigationOptions {
@@ -1100,5 +1848,5 @@ declare enum RdxPositionAlign {
     End = "end"
 }
 
-export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RdxControlValueAccessor, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, SHIFT, SPACE, SPACE_CODE, TAB, TIME_GRANULARITIES, a, areAllDaysBetweenValid, clamp, createContent, createContext, createFormatter, createMonth, createMonths, elementSize, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isItemEqualToValue, isNullish, isNumberString, isSegmentNavigationKey, isZonedDateTime, itemToStringLabel, itemToStringValue, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideToken, provideValueAccessor, resizeEffect, roundToStepPrecision, segmentBuilders, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useArrowNavigation, useDateField, useFilter, useGraceArea, useListHighlight, usePointerDrag, useScrollLock, useTransitionStatus, watch };
-export type { AcceptableValue, AnyExceptLiteral, AriaLivePoliteness, BooleanInput, CreateMonthProps, DataOrientation, DateAndTimeSegmentObj, DateFormatterOptions, DateMatcher, DateRange, DateSegmentObj, DateSegmentPart, DateStep, DayPeriod, Direction, EditableSegmentPart, FilterPredicates, Formatter, Granularity, HourCycle, InjectContext, ItemValueComparator, ListHighlight, Month, NonEditableSegmentPart, Nullable, NumberInput, PlaceholderMap, RdxFormCheckboxControl, RdxFormStateInput, RdxFormUiControl, RdxFormValueControl, RdxPointerDragHandlers, RdxTransitionStatus, RdxTransitionStatusRef, RdxValidationError, SafeFunction, SegmentContentObj, SegmentPart, SegmentValueObj, TimeGranularity, TimeSegmentObj, TimeSegmentPart, TimeValue, UseDateFieldProps, UseFilterOptions, UseListHighlightOptions };
+export { A, ALT, ARROW_DOWN, ARROW_LEFT, ARROW_RIGHT, ARROW_UP, ASTERISK, BACKSPACE, CAPS_LOCK, CONTROL, CTRL, DELETE, DOCS_BASE_URL, END, ENTER, ESCAPE, F1, F10, F11, F12, F2, F3, F4, F5, F6, F7, F8, F9, HOME, META, P, PAGE_DOWN, PAGE_UP, RDX_FLOATING_REGISTRATION, RDX_FLOATING_ROOT_CONTEXT, RDX_FLOATING_TREE, RDX_INTERNAL_BACKDROP_ATTR, RDX_SCROLL_LOCKED_ATTR, RdxControlValueAccessor, RdxFloatingNode, RdxFloatingNodeRegistration, RdxFloatingRegistrationContext, RdxFloatingRootContext, RdxFloatingTree, RdxIdGenerator, RdxLiveAnnouncer, RdxPositionAlign, RdxPositionSide, RdxTriggerRegistry, SHIFT, SPACE, SPACE_CODE, TAB, TIME_GRANULARITIES, a, areAllDaysBetweenValid, clamp, createCancelableChangeEventDetails, createContent, createContext, createFloatingEvents, createFloatingRootContext, createFormatter, createMonth, createMonths, docsUrl, elementSize, getActiveElement, getDaysBetween, getDaysInMonth, getDefaultDate, getDefaultTime, getLastFirstDayOfWeek, getMaxTransitionDuration, getNextLastDayOfWeek, getOptsByGranularity, getPlaceholder, getSegmentElements, getWeekNumber, handleAndDispatchCustomEvent, handleCalendarInitialFocus, hasTime, initializeSegmentValues, injectControlValueAccessor, injectDocument, injectFloatingRootContext, injectId, isAcceptableSegmentKey, isAfter, isAfterOrSame, isBefore, isBeforeOrSame, isBetween, isBetweenInclusive, isCalendarDateTime, isEqual, isItemEqualToValue, isNullish, isNumberString, isSegmentNavigationKey, isZonedDateTime, itemToStringLabel, itemToStringValue, j, k, n, normalizeDateStep, normalizeHour12, normalizeHourCycle, p, provideFloatingRegistration, provideFloatingRootContext, provideFloatingTree, provideToken, provideValueAccessor, rdxCheckLabelElement, rdxCheckTriggerElement, rdxDevError, rdxDevWarning, resetRdxDevWarnings, resizeEffect, resolveFloatingTree, roundToStepPrecision, segmentBuilders, setupInternalBackdrop, snapValueToStep, syncSegmentValues, syncTimeSegmentValues, toDate, useAnchoredScrollLock, useArrowNavigation, useDateField, useFilter, useGraceArea, useListHighlight, usePointerDrag, useScrollLock, useTransitionStatus, watch };
+export type { AcceptableValue, AnyExceptLiteral, AriaLivePoliteness, BooleanInput, CreateMonthProps, DataOrientation, DateAndTimeSegmentObj, DateFormatterOptions, DateMatcher, DateRange, DateSegmentObj, DateSegmentPart, DateStep, DayPeriod, Direction, EditableSegmentPart, FilterPredicates, Formatter, Granularity, HourCycle, InjectContext, ItemValueComparator, ListHighlight, Month, NonEditableSegmentPart, Nullable, NumberInput, PlaceholderMap, RdxAnchoredScrollLockOptions, RdxCancelableChangeEventDetails, RdxCancelableChangeEventTransaction, RdxFloatingEventMap, RdxFloatingEvents, RdxFloatingLifecycle, RdxFloatingNodeInit, RdxFloatingParentOverride, RdxFloatingRegistrationReader, RdxFloatingRegistrationStatus, RdxFloatingRootContextEventMap, RdxFloatingRootContextInit, RdxFormCheckboxControl, RdxFormStateInput, RdxFormUiControl, RdxFormValueControl, RdxInternalBackdropOptions, RdxPointerDragHandlers, RdxScrollLockOptions, RdxTransitionStatus, RdxTransitionStatusRef, RdxValidationError, SafeFunction, SegmentContentObj, SegmentPart, SegmentValueObj, TimeGranularity, TimeSegmentObj, TimeSegmentPart, TimeValue, UseDateFieldProps, UseFilterOptions, UseListHighlightOptions };