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

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

@@ -1,6 +1,8 @@
 import * as i0 from '@angular/core';
 import { Signal, Provider } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { BooleanInput } from '@radix-ng/primitives/core';
+export { RdxPointerDragHandlers, usePointerDrag } from '@radix-ng/primitives/core';
 import * as i1 from '@radix-ng/primitives/dialog';
 import { RdxDialogHandle } from '@radix-ng/primitives/dialog';
 import * as _radix_ng_primitives_drawer from '@radix-ng/primitives/drawer';
@@ -183,7 +185,7 @@ interface RdxDrawerRootContext {
     /** Reports the popup's measured size (px) so the provider can expose it. */
     reportPopupHeight: (height: number) => void;
 }
-declare const injectRdxDrawerRootContext: (optional?: boolean) => RdxDrawerRootContext | null;
+declare const injectRdxDrawerRootContext: _radix_ng_primitives_core.InjectContext<RdxDrawerRootContext>;
 declare const provideRdxDrawerRootContext: (useFactory: () => RdxDrawerRootContext) => i0.Provider;
 /**
  * Groups all parts of the drawer.
@@ -413,30 +415,6 @@ declare const RdxDrawerHandle: typeof RdxDialogHandle;
 type RdxDrawerHandle<Payload = unknown> = RdxDialogHandle<Payload>;
 declare function createRdxDrawerHandle<Payload = unknown>(): RdxDrawerHandle<Payload>;
 
-interface RdxPointerDragHandlers {
-    /** Whether a press may begin a drag (e.g. enabled, not on an opt-out element, at a scroll edge). */
-    canStart: (event: PointerEvent) => boolean;
-    /** A drag actually began (the pointer moved past the start threshold). */
-    onStart: (event: PointerEvent) => void;
-    /** Pointer moved during a drag. Return `false` to end the gesture early (treated as not committed). */
-    onMove: (event: PointerEvent) => void | boolean;
-    /** The drag ended. `committed` is true only for a normal `pointerup`, false for cancel/lost-capture/early-stop. */
-    onEnd: (event: PointerEvent, committed: boolean) => void;
-}
-/**
- * Shared pointer-drag lifecycle for the drawer gestures (popup swipe and swipe-area open).
- *
- * A press only becomes a drag once the pointer moves past {@link DRAG_THRESHOLD}; until then it is a
- * plain tap, so clicks on buttons inside the drawer keep working (the gesture never captures the
- * pointer for a tap). Once dragging, the pointer is captured so a drag that leaves the element still
- * completes, and `lostpointercapture` / `pointercancel` count as a non-committed end — a swallowed
- * `pointerup` (native context menu, OS gesture, tab switch) can never wedge the gesture. No-op
- * outside the browser, keeping SSR safe.
- *
- * Must be called from an injection context (a directive/component constructor).
- */
-declare function usePointerDrag(handlers: RdxPointerDragHandlers): void;
-
 declare const drawerImports: (typeof RdxDrawerProviderDirective)[];
 declare class RdxDrawerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<RdxDrawerModule, never>;
@@ -444,5 +422,5 @@ declare class RdxDrawerModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<RdxDrawerModule>;
 }
 
-export { RdxDrawerBackdrop, RdxDrawerClose, RdxDrawerContent, RdxDrawerDescription, RdxDrawerHandle, RdxDrawerIndent, RdxDrawerIndentBackground, RdxDrawerModule, RdxDrawerPopup, RdxDrawerPortal, RdxDrawerPortalPresence, RdxDrawerProvider, RdxDrawerProviderDirective, RdxDrawerRoot, RdxDrawerSwipeArea, RdxDrawerTitle, RdxDrawerTrigger, RdxDrawerViewport, buildSnapEntries, createRdxDrawerHandle, dismissUnitVector, drawerImports, injectRdxDrawerRootContext, provideRdxDrawerProvider, provideRdxDrawerRootContext, resolveSnapTarget, snapPointReveal, useDrawerSwipe, usePointerDrag };
-export type { RdxDrawerRegistration, RdxDrawerRelease, RdxDrawerRootContext, RdxDrawerSnapEntry, RdxDrawerSnapPoint, RdxDrawerSnapResolveOptions, RdxDrawerSnapTarget, RdxDrawerSwipeConfig, RdxDrawerSwipeDirection, RdxPointerDragHandlers };
+export { RdxDrawerBackdrop, RdxDrawerClose, RdxDrawerContent, RdxDrawerDescription, RdxDrawerHandle, RdxDrawerIndent, RdxDrawerIndentBackground, RdxDrawerModule, RdxDrawerPopup, RdxDrawerPortal, RdxDrawerPortalPresence, RdxDrawerProvider, RdxDrawerProviderDirective, RdxDrawerRoot, RdxDrawerSwipeArea, RdxDrawerTitle, RdxDrawerTrigger, RdxDrawerViewport, buildSnapEntries, createRdxDrawerHandle, dismissUnitVector, drawerImports, injectRdxDrawerRootContext, provideRdxDrawerProvider, provideRdxDrawerRootContext, resolveSnapTarget, snapPointReveal, useDrawerSwipe };
+export type { RdxDrawerRegistration, RdxDrawerRelease, RdxDrawerRootContext, RdxDrawerSnapEntry, RdxDrawerSnapPoint, RdxDrawerSnapResolveOptions, RdxDrawerSnapTarget, RdxDrawerSwipeConfig, RdxDrawerSwipeDirection };

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

@@ -1,70 +1,147 @@
 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 * as i1 from '@radix-ng/primitives/dismissable-layer';
-import { RdxPointerDownOutside } 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 EditableRootContext = {
     disabled: Signal<boolean>;
-    value: Signal<string | null | undefined>;
+    value: Signal<string | undefined>;
     inputValue: WritableSignal<string | undefined>;
     placeholder: Signal<{
         edit: string;
         preview: string;
     }>;
     isEditing: Signal<boolean>;
-    submitMode: Signal<SubmitMode>;
-    activationMode: Signal<ActivationMode>;
+    submitMode: Signal<EditableSubmitMode>;
+    activationMode: Signal<EditableActivationMode>;
     edit: () => void;
     cancel: () => void;
     submit: () => void;
     maxLength: Signal<number | undefined>;
+    required: Signal<boolean>;
     startWithEditMode: Signal<boolean>;
     isEmpty: Signal<boolean>;
     readonly: Signal<boolean>;
     selectOnFocus: Signal<boolean>;
     autoResize: Signal<boolean>;
     inputRef: WritableSignal<HTMLInputElement | undefined>;
+    previewRef: WritableSignal<HTMLElement | undefined>;
+    canActivateOnFocus: () => boolean;
 };
-declare const injectEditableRootContext: (optional?: boolean) => EditableRootContext | null;
+declare const injectEditableRootContext: _radix_ng_primitives_core.InjectContext<EditableRootContext>;
 declare const provideEditableRootContext: (useFactory: () => EditableRootContext) => _angular_core.Provider;
-type ActivationMode = 'focus' | 'dblclick' | 'none';
-type SubmitMode = 'blur' | 'enter' | 'none' | 'both';
 /**
  * @group Components
  */
 declare class RdxEditableRoot {
     private readonly focusOutside;
-    readonly pointerDownOutside: RdxPointerDownOutside;
+    private readonly pointerDownOutside;
     readonly value: _angular_core.ModelSignal<string | undefined>;
+    /** Uncontrolled initial value. */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
     readonly placeholder: _angular_core.InputSignal<string>;
     readonly disabled: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly readonly: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
     readonly selectOnFocus: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly submitMode: _angular_core.InputSignal<SubmitMode>;
+    readonly submitMode: _angular_core.InputSignal<EditableSubmitMode>;
     readonly maxLength: _angular_core.InputSignalWithTransform<number | undefined, NumberInput>;
     /**
      * Whether to start with the edit mode active
      */
     readonly startWithEditMode: _angular_core.InputSignalWithTransform<boolean, BooleanInput>;
-    readonly activationMode: _angular_core.InputSignal<ActivationMode>;
+    readonly activationMode: _angular_core.InputSignal<EditableActivationMode>;
     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 isEmpty: Signal<boolean>;
-    readonly $placeholder: Signal<string | {
+    readonly $placeholder: Signal<{
         edit: string;
         preview: string;
     }>;
+    /** Seeded from `startWithEditMode`; flipped imperatively by edit/submit/cancel. */
     readonly isEditing: WritableSignal<boolean>;
+    /** Working copy of the value while editing; reseeded whenever the committed value changes. */
     readonly inputValue: WritableSignal<string | undefined>;
     readonly inputRef: WritableSignal<HTMLInputElement | undefined>;
+    readonly previewRef: WritableSignal<HTMLElement | undefined>;
+    private restoreFocusOnExit;
+    /** True while focus is being restored programmatically, to avoid re-entering edit mode. */
+    private suppressFocusActivation;
     constructor();
+    canActivateOnFocus(): boolean;
     handleDismiss(): void;
     submit(): void;
     cancel(): void;
     edit(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableRoot, "[rdxEditableRoot]", ["rdxEditableRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; "isSignal": true; }; "submitMode": { "alias": "submitMode"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "startWithEditMode": { "alias": "startWithEditMode"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, [{ directive: typeof i1.RdxFocusOutside; inputs: {}; outputs: {}; }, { directive: typeof i1.RdxPointerDownOutside; inputs: {}; outputs: {}; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableRoot, "[rdxEditableRoot]", ["rdxEditableRoot"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; "isSignal": true; }; "submitMode": { "alias": "submitMode"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "startWithEditMode": { "alias": "startWithEditMode"; "required": false; "isSignal": true; }; "activationMode": { "alias": "activationMode"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "onValueChange": "onValueChange"; }, never, never, true, [{ directive: typeof i1.RdxFocusOutside; inputs: {}; outputs: {}; }, { directive: typeof i1.RdxPointerDownOutside; inputs: {}; outputs: {}; }]>;
 }
 
-export { RdxEditableRoot, injectEditableRootContext, provideEditableRootContext };
+declare class RdxEditableArea {
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableArea, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableArea, "[rdxEditableArea]", never, {}, {}, never, never, true, never>;
+}
+
+declare class RdxEditablePreview {
+    private readonly elementRef;
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    readonly placeholder: _angular_core.Signal<string>;
+    constructor();
+    handleFocus(): void;
+    handleDoubleClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditablePreview, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditablePreview, "span[rdxEditablePreview]", ["rdxEditablePreview"], {}, {}, never, never, true, never>;
+}
+
+declare class RdxEditableInput {
+    private readonly inputRef;
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    /** Accessible label for the input. Override to localize. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.Signal<string>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    constructor();
+    handleInput(event: Event): void;
+    handleSubmitKeyDown(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableInput, "input[rdxEditableInput]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxEditableEditTrigger {
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    /** Accessible label for the trigger. Override to localize. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableEditTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableEditTrigger, "button[rdxEditableEditTrigger]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxEditableSubmitTrigger {
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    /** Accessible label for the trigger. Override to localize. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableSubmitTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableSubmitTrigger, "button[rdxEditableSubmitTrigger]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxEditableCancelTrigger {
+    protected readonly rootContext: _radix_ng_primitives_editable.EditableRootContext;
+    /** Accessible label for the trigger. Override to localize. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableCancelTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxEditableCancelTrigger, "button[rdxEditableCancelTrigger]", never, { "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class RdxEditableModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxEditableModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxEditableModule, never, [typeof RdxEditableRoot, typeof RdxEditableArea, typeof RdxEditablePreview, typeof RdxEditableInput, typeof RdxEditableEditTrigger, typeof RdxEditableSubmitTrigger, typeof RdxEditableCancelTrigger], [typeof RdxEditableRoot, typeof RdxEditableArea, typeof RdxEditablePreview, typeof RdxEditableInput, typeof RdxEditableEditTrigger, typeof RdxEditableSubmitTrigger, typeof RdxEditableCancelTrigger]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxEditableModule>;
+}
+
+export { RdxEditableArea, RdxEditableCancelTrigger, RdxEditableEditTrigger, RdxEditableInput, RdxEditableModule, RdxEditablePreview, RdxEditableRoot, RdxEditableSubmitTrigger, injectEditableRootContext, provideEditableRootContext };
+export type { EditableActivationMode, EditableRootContext, EditableSubmitMode };

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

@@ -1,6 +1,7 @@
 import * as _radix_ng_primitives_field from '@radix-ng/primitives/field';
 import * as _angular_core from '@angular/core';
-import { BooleanInput } from '@radix-ng/primitives/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import { BooleanInput, RdxValidationError } from '@radix-ng/primitives/core';
 
 /**
  * Connects a form control to the field label, description, error, and state.
@@ -10,8 +11,11 @@ import { BooleanInput } from '@radix-ng/primitives/core';
 declare class RdxFieldControl {
     protected readonly rootContext: {
         controlId: _angular_core.WritableSignal<string>;
+        name: _angular_core.InputSignal<string | undefined>;
         descriptionIds: _angular_core.WritableSignal<string[]>;
         errorIds: _angular_core.WritableSignal<string[]>;
+        messages: _angular_core.Signal<string[]>;
+        notifyEdited: () => void;
         invalidState: _angular_core.Signal<boolean>;
         disabledState: _angular_core.Signal<boolean>;
         requiredState: _angular_core.Signal<boolean>;
@@ -59,8 +63,11 @@ declare class RdxFieldControl {
 declare class RdxFieldDescription {
     protected readonly rootContext: {
         controlId: _angular_core.WritableSignal<string>;
+        name: _angular_core.InputSignal<string | undefined>;
         descriptionIds: _angular_core.WritableSignal<string[]>;
         errorIds: _angular_core.WritableSignal<string[]>;
+        messages: _angular_core.Signal<string[]>;
+        notifyEdited: () => void;
         invalidState: _angular_core.Signal<boolean>;
         disabledState: _angular_core.Signal<boolean>;
         requiredState: _angular_core.Signal<boolean>;
@@ -100,8 +107,11 @@ declare class RdxFieldDescription {
 declare class RdxFieldError {
     protected readonly rootContext: {
         controlId: _angular_core.WritableSignal<string>;
+        name: _angular_core.InputSignal<string | undefined>;
         descriptionIds: _angular_core.WritableSignal<string[]>;
         errorIds: _angular_core.WritableSignal<string[]>;
+        messages: _angular_core.Signal<string[]>;
+        notifyEdited: () => void;
         invalidState: _angular_core.Signal<boolean>;
         disabledState: _angular_core.Signal<boolean>;
         requiredState: _angular_core.Signal<boolean>;
@@ -127,6 +137,12 @@ declare class RdxFieldError {
      * @group Props
      */
     readonly id: _angular_core.InputSignal<string>;
+    /**
+     * The field's external messages (state provider's, then enclosing Form's), `[]` when none. Render
+     * them explicitly via the `exportAs` reference — the directive never injects text content itself:
+     * `<p rdxFieldError #err="rdxFieldError">{{ err.messages().join(' ') }}</p>`.
+     */
+    readonly messages: _angular_core.Signal<string[]>;
     constructor();
     protected readonly dataAttr: (value: boolean) => "" | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFieldError, never>;
@@ -141,8 +157,11 @@ declare class RdxFieldError {
 declare class RdxFieldLabel {
     protected readonly rootContext: {
         controlId: _angular_core.WritableSignal<string>;
+        name: _angular_core.InputSignal<string | undefined>;
         descriptionIds: _angular_core.WritableSignal<string[]>;
         errorIds: _angular_core.WritableSignal<string[]>;
+        messages: _angular_core.Signal<string[]>;
+        notifyEdited: () => void;
         invalidState: _angular_core.Signal<boolean>;
         disabledState: _angular_core.Signal<boolean>;
         requiredState: _angular_core.Signal<boolean>;
@@ -194,11 +213,23 @@ interface RdxFieldState {
     touched?: () => boolean;
     filled?: () => boolean;
     focused?: () => boolean;
+    /**
+     * Optional source of error *content* (not just the invalid boolean). When provided and non-empty
+     * it forces `invalidState` true, and its messages (`message ?? kind` per error) surface through
+     * `RdxFieldError.messages()` ahead of any enclosing Form's external messages. Uses `core`'s
+     * framework-free shim type so the seam stays free of `@angular/forms/signals` (ADR 0004 amendment).
+     */
+    errors?: () => RdxValidationError[];
 }
 declare const fieldRootContext: () => {
     controlId: _angular_core.WritableSignal<string>;
+    name: _angular_core.InputSignal<string | undefined>;
     descriptionIds: _angular_core.WritableSignal<string[]>;
     errorIds: _angular_core.WritableSignal<string[]>;
+    /** Combined external messages (state provider's, then enclosing Form's), for `RdxFieldError`. */
+    messages: _angular_core.Signal<string[]>;
+    /** Notify an enclosing Form that this field's control was edited (composite-control opt-in). */
+    notifyEdited: () => void;
     invalidState: _angular_core.Signal<boolean>;
     disabledState: _angular_core.Signal<boolean>;
     requiredState: _angular_core.Signal<boolean>;
@@ -225,10 +256,15 @@ declare const fieldRootContext: () => {
     hasStateProvider: _angular_core.Signal<boolean>;
 };
 type RdxFieldRootContext = ReturnType<typeof fieldRootContext>;
-declare const injectFieldRootContext: (optional?: boolean) => {
+declare const injectFieldRootContext: _radix_ng_primitives_core.InjectContext<{
     controlId: _angular_core.WritableSignal<string>;
+    name: _angular_core.InputSignal<string | undefined>;
     descriptionIds: _angular_core.WritableSignal<string[]>;
     errorIds: _angular_core.WritableSignal<string[]>;
+    /** Combined external messages (state provider's, then enclosing Form's), for `RdxFieldError`. */
+    messages: _angular_core.Signal<string[]>;
+    /** Notify an enclosing Form that this field's control was edited (composite-control opt-in). */
+    notifyEdited: () => void;
     invalidState: _angular_core.Signal<boolean>;
     disabledState: _angular_core.Signal<boolean>;
     requiredState: _angular_core.Signal<boolean>;
@@ -253,11 +289,16 @@ declare const injectFieldRootContext: (optional?: boolean) => {
      */
     setStateProvider: (provider: RdxFieldState | null) => RdxFieldState | null;
     hasStateProvider: _angular_core.Signal<boolean>;
-} | null;
+}>;
 declare const provideFieldRootContext: (useFactory: () => {
     controlId: _angular_core.WritableSignal<string>;
+    name: _angular_core.InputSignal<string | undefined>;
     descriptionIds: _angular_core.WritableSignal<string[]>;
     errorIds: _angular_core.WritableSignal<string[]>;
+    /** Combined external messages (state provider's, then enclosing Form's), for `RdxFieldError`. */
+    messages: _angular_core.Signal<string[]>;
+    /** Notify an enclosing Form that this field's control was edited (composite-control opt-in). */
+    notifyEdited: () => void;
     invalidState: _angular_core.Signal<boolean>;
     disabledState: _angular_core.Signal<boolean>;
     requiredState: _angular_core.Signal<boolean>;
@@ -336,6 +377,15 @@ declare class RdxFieldRoot {
      * @group Props
      */
     readonly focused: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Identifies the field to an enclosing Form for external (server) error matching. Fields without a
+     * `name` never match external errors.
+     *
+     * @group Props
+     */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /** The enclosing Form, if any. All Form-related behavior is a no-op when this is `null`. */
+    private readonly formContext;
     readonly controlId: _angular_core.WritableSignal<string>;
     readonly descriptionIds: _angular_core.WritableSignal<string[]>;
     readonly errorIds: _angular_core.WritableSignal<string[]>;
@@ -347,6 +397,12 @@ declare class RdxFieldRoot {
     private readonly stateProvider;
     /** Whether an external adapter currently owns field state. */
     readonly hasStateProvider: _angular_core.Signal<boolean>;
+    /** Error content from a registered state provider (e.g. a Signal Forms adapter). */
+    private readonly providerErrors;
+    /** External messages from the enclosing Form matched by this field's `name`. */
+    readonly externalErrors: _angular_core.Signal<string[]>;
+    /** Provider messages first (`message ?? kind`), then the Form's external messages. */
+    readonly messages: _angular_core.Signal<string[]>;
     readonly invalidState: _angular_core.Signal<boolean>;
     readonly disabledState: _angular_core.Signal<boolean>;
     readonly requiredState: _angular_core.Signal<boolean>;
@@ -355,6 +411,20 @@ declare class RdxFieldRoot {
     readonly filledState: _angular_core.Signal<boolean>;
     readonly focusedState: _angular_core.Signal<boolean>;
     protected readonly dataAttr: (value: boolean) => "" | undefined;
+    constructor();
+    /** Notify the enclosing Form (if any) that this field's control was edited (clear-on-edit). */
+    notifyEdited(): void;
+    /** Reset interaction state on native form reset: touched/dirty/focused → false, filled re-synced. */
+    resetState(): void;
+    /** Focus the field's control (used by the Form's first-invalid-focus on blocked submit). */
+    private focusControl;
+    private readonly host;
+    /**
+     * The field's control element, found by `controlId` but scoped to this field's own subtree — a
+     * duplicate or consumer-reused id elsewhere on the page can't steal focus/reset. The control
+     * registers its id through `setControlId`, so this matches the same element the labels point at.
+     */
+    private controlElement;
     /**
      * Register an external owner of field state, returning the previous one.
      * @ignore
@@ -366,7 +436,7 @@ declare class RdxFieldRoot {
      */
     private resolve;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFieldRoot, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFieldRoot, "[rdxFieldRoot]", ["rdxFieldRoot"], { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; "focused": { "alias": "focused"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFieldRoot, "[rdxFieldRoot]", ["rdxFieldRoot"], { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "dirty": { "alias": "dirty"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; "focused": { "alias": "focused"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { RdxFieldControl, RdxFieldDescription, RdxFieldError, RdxFieldLabel, RdxFieldRoot, injectFieldRootContext, provideFieldRootContext };

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

@@ -1,4 +1,5 @@
 import * as _angular_core from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { BooleanInput } from '@radix-ng/primitives/core';
 
 /**
@@ -19,9 +20,9 @@ declare const fieldsetRootContext: () => {
     disabledState: _angular_core.Signal<boolean>;
 };
 type RdxFieldsetRootContext = ReturnType<typeof fieldsetRootContext>;
-declare const injectFieldsetRootContext: (optional?: boolean) => {
+declare const injectFieldsetRootContext: _radix_ng_primitives_core.InjectContext<{
     disabledState: _angular_core.Signal<boolean>;
-} | null;
+}>;
 declare const provideFieldsetRootContext: (useFactory: () => {
     disabledState: _angular_core.Signal<boolean>;
 }) => _angular_core.Provider;

package/types/radix-ng-primitives-focus-scope.d.ts

@@ -1,5 +1,6 @@
 import * as _angular_core from '@angular/core';
 import { WritableSignal, Signal, InjectionToken, Provider } from '@angular/core';
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
 import { BooleanInput } from '@radix-ng/primitives/core';
 
 interface FocusScopeAPI {
@@ -12,7 +13,7 @@ interface FocusScopeContext {
     loop?: Signal<boolean>;
     trapped?: Signal<boolean>;
 }
-declare const injectFocusScopeContext: (optional?: boolean) => FocusScopeContext | null;
+declare const injectFocusScopeContext: _radix_ng_primitives_core.InjectContext<FocusScopeContext>;
 declare const provideFocusScopeContext: (useFactory: () => FocusScopeContext) => _angular_core.Provider;
 /**
  * @group Components

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

@@ -0,0 +1,124 @@
+import * as _radix_ng_primitives_core from '@radix-ng/primitives/core';
+import * as _angular_core from '@angular/core';
+
+/** A normalized external-error map: each field name maps to its message(s) in display order. */
+type RdxFormErrors = Record<string, string | string[]>;
+/** Payload of {@link RdxFormRoot.onFormSubmit}. */
+interface RdxFormSubmitEvent {
+    /** The form's values serialized from `FormData` (repeated names collapse into arrays). */
+    values: Record<string, FormDataEntryValue | FormDataEntryValue[]>;
+    /** The original native submit event (already `preventDefault`-ed). */
+    event: SubmitEvent;
+}
+/**
+ * What a {@link RdxFieldRoot} registers with an enclosing Form. Structural `() =>` accessors keep the
+ * Form entry free of any import from `field` (acyclic ng-packagr graph: `field` → `form`).
+ */
+interface RdxFormFieldRegistration {
+    /** The field's `name` (key external errors match against), or `undefined`. */
+    name: () => string | undefined;
+    /** The field's merged invalid state (includes external errors). */
+    invalid: () => boolean;
+    /** Whether the field is dirty. */
+    dirty: () => boolean;
+    /** Whether the field is touched. */
+    touched: () => boolean;
+    /** Focus the field's control (by its `controlId`). */
+    focus: () => void;
+    /** Reset the field's interaction state (touched/dirty/focused → false, filled re-sync). */
+    resetState: () => void;
+}
+/**
+ * External owner of form-level state (e.g. a future Signal Forms `[rdxSignalForm]` adapter). Mirrors
+ * Field's `RdxFieldState` seam one level up. Each member is optional: a provided accessor wins over the
+ * built-in registry/`errors`-input behavior; absent accessors leave the built-in behavior untouched.
+ * Kept as framework-free `() =>` accessors (no `@angular/forms/signals` dependency). See ADR 0004.
+ */
+interface RdxFormState {
+    invalid?: () => boolean;
+    dirty?: () => boolean;
+    touched?: () => boolean;
+    submitting?: () => boolean;
+    /** Per-name external error source; while provided, the `errors` input + clear-on-edit are inert. */
+    errorsFor?: (name: string) => string[];
+}
+declare const formRootContext: () => {
+    errorsFor: (name: string | undefined) => string[];
+    notifyEdited: (name: string | undefined) => void;
+    register: (field: RdxFormFieldRegistration) => () => void;
+    setStateProvider: (provider: RdxFormState | null) => RdxFormState | null;
+    hasStateProvider: _angular_core.Signal<boolean>;
+};
+type RdxFormRootContext = ReturnType<typeof formRootContext>;
+declare const injectFormRootContext: _radix_ng_primitives_core.InjectContext<{
+    errorsFor: (name: string | undefined) => string[];
+    notifyEdited: (name: string | undefined) => void;
+    register: (field: RdxFormFieldRegistration) => () => void;
+    setStateProvider: (provider: RdxFormState | null) => RdxFormState | null;
+    hasStateProvider: _angular_core.Signal<boolean>;
+}>;
+declare const provideFormRootContext: (useFactory: () => {
+    errorsFor: (name: string | undefined) => string[];
+    notifyEdited: (name: string | undefined) => void;
+    register: (field: RdxFormFieldRegistration) => () => void;
+    setStateProvider: (provider: RdxFormState | null) => RdxFormState | null;
+    hasStateProvider: _angular_core.Signal<boolean>;
+}) => _angular_core.Provider;
+/**
+ * The top of the forms layer cake: a single directive on the native `<form>` element that aggregates
+ * field state, maps external (server) errors onto fields by `name`, intercepts submit (values-as-object,
+ * focus the first invalid field), and resets field interaction state on native `reset`. It owns no
+ * values and runs no validation — Angular form systems (or Field inputs) remain the source of validity.
+ *
+ * @group Components
+ */
+declare class RdxFormRoot {
+    private readonly form;
+    /** External/server validation errors keyed by `Field.Root` `name`. */
+    readonly errors: _angular_core.InputSignal<RdxFormErrors | null | undefined>;
+    /** Emits the remaining error map after a field's external error is cleared by a user edit (or reset). */
+    readonly onClearErrors: _angular_core.OutputEmitterRef<RdxFormErrors>;
+    /** Emits the serialized form values when a valid form is submitted. */
+    readonly onFormSubmit: _angular_core.OutputEmitterRef<RdxFormSubmitEvent>;
+    private readonly fields;
+    private readonly stateProvider;
+    /** Whether an external adapter currently owns form-level state. */
+    readonly hasStateProvider: _angular_core.Signal<boolean>;
+    /**
+     * Names whose external error has been cleared by a user edit. Reset to empty whenever a new `errors`
+     * object reference is assigned — the server just spoke, so everything it said is live again.
+     */
+    private readonly clearedNames;
+    /** The `errors` input minus cleared names, normalized to `string[]`. */
+    private readonly effectiveErrors;
+    readonly anyInvalid: _angular_core.Signal<boolean>;
+    readonly anyDirty: _angular_core.Signal<boolean>;
+    readonly anyTouched: _angular_core.Signal<boolean>;
+    readonly submitting: _angular_core.Signal<boolean>;
+    /** Resolve a boolean aggregate: a registered provider's accessor wins, else OR over the registry. */
+    private aggregate;
+    /** Resolves the external messages for a field name (provider source wins over the `errors` input). */
+    errorsFor(name: string | undefined): string[];
+    /** Clears a field's external error after a user edit, emitting the remaining map. */
+    notifyEdited(name: string | undefined): void;
+    register(field: RdxFormFieldRegistration): () => void;
+    /** Register (or clear with `null`) an external owner of form-level state; returns the previous one. */
+    setStateProvider(provider: RdxFormState | null): RdxFormState | null;
+    onSubmit(event: SubmitEvent): void;
+    onReset(): void;
+    private readonly resetTimers;
+    constructor();
+    private remainingErrors;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFormRoot, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<RdxFormRoot, "form[rdxFormRoot]", ["rdxFormRoot"], { "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "onClearErrors": "onClearErrors"; "onFormSubmit": "onFormSubmit"; }, never, never, true, never>;
+}
+
+declare const _importsForm: (typeof RdxFormRoot)[];
+declare class RdxFormModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RdxFormModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<RdxFormModule, never, [typeof RdxFormRoot], [typeof RdxFormRoot]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<RdxFormModule>;
+}
+
+export { RdxFormModule, RdxFormRoot, _importsForm, injectFormRootContext, provideFormRootContext };
+export type { RdxFormErrors, RdxFormFieldRegistration, RdxFormRootContext, RdxFormState, RdxFormSubmitEvent };