@formancy/angular 0.1.0 → 0.2.0

package/types/formancy-angular.d.ts

@@ -1,8 +1,8 @@
-import * as i0 from '@angular/core';
+import * as _angular_core from '@angular/core';
 import { InjectionToken, Provider, Signal, Type, OnChanges, OnDestroy, Injector, OnInit } from '@angular/core';
 import * as _formancy_core from '@formancy/core';
 import { FormEngine, FieldSnapshot, Path } from '@formancy/core';
-import { FieldType, FieldDef } from '@formancy/spec';
+import { FieldType, RemoteOption, FieldDef, LayoutNode, RichInline, RichBlock, RichCommand } from '@formancy/spec';
 import * as _formancy_angular from '@formancy/angular';
 
 /**
@@ -39,6 +39,8 @@ interface RepeaterBinding {
     rowIds: Signal<readonly string[]>;
     addRow(): void;
     removeRow(index: number): void;
+    /** Move a row. The keyboard route to reordering; a drag is a second route to this. */
+    moveRow(from: number, to: number): void;
 }
 /**
  * A repeater's live row count as a signal — the Angular half of React's
@@ -110,6 +112,75 @@ interface FormancyRegistry {
 declare const FORMANCY_REGISTRY: InjectionToken<FormancyRegistry>;
 declare function provideFormancyRegistry(registry: FormancyRegistry): Provider[];
 
+/**
+ * A field's options, from the document or from the deployment.
+ *
+ * The same contract the React binding states in `use-sourced-options.ts`, written
+ * out here rather than shared: the async lifecycle is expressed in this framework's
+ * own primitives, and a shared abstraction would report that both bindings
+ * implemented it when one had not.
+ *
+ * `optionsSource` decides which answers EXIST rather than how they are shown, so the
+ * plain `<select>` honours it as well as the typeahead — one ignoring it would render
+ * an empty chooser over a field that collects something.
+ */
+interface SourcedOptionsState {
+    /** The rows a source returned, empty until one does. */
+    rows: Signal<readonly RemoteOption[]>;
+    /** Names for values the form already holds, so a resumed draft is not blank. */
+    named: Signal<ReadonlyMap<string, string>>;
+    /** The document names a source this deployment does not have. */
+    unavailable: Signal<boolean>;
+    /** A request is in flight. The control says `aria-busy`; it never disables itself. */
+    busy: Signal<boolean>;
+    /** The one thing the field says out loud, or the empty string. */
+    status: Signal<string>;
+    /** Whether this field is sourced at all. False is the ordinary case. */
+    sourced: Signal<boolean>;
+}
+
+/**
+ * Where a file goes, and what the submission remembers about it.
+ *
+ * The same contract the React binding uses, with the same reasoning: this
+ * package has no opinion about the destination, so the one field works against
+ * local disk, S3 or a customer's own service without any of them becoming a
+ * dependency of a renderer.
+ *
+ * The bytes never pass through the submission. What is stored is what the file
+ * *is* and where it went, so a submission read back years later is small and
+ * says what was attached even if the object store has since been emptied.
+ */
+interface StoredFile {
+    /** Stable within the submission; how a row is keyed and removed. */
+    id: string;
+    name: string;
+    size: number;
+    contentType: string;
+    /** Where the bytes are, in whatever the host's storage calls a location. */
+    storageKey: string;
+}
+/**
+ * Uploads one file and reports what was stored.
+ *
+ * Rejecting is a real answer: the field says so out loud rather than dropping
+ * the file, because a submission somebody believes carries their evidence and
+ * does not is the worst outcome available here.
+ */
+type Uploader = (file: File) => Promise<StoredFile>;
+/**
+ * Optional by design. A form with no file fields needs no uploader, and a file
+ * field without one renders read-only and says why — which beats turning a
+ * form that mostly works into a failed injection.
+ */
+declare const FORMANCY_UPLOADER: InjectionToken<Uploader>;
+declare function injectUploader(): Uploader | null;
+/** Providing one, for a host that has somewhere to put bytes. */
+declare function provideFormancyUploader(upload: Uploader): {
+    provide: InjectionToken<Uploader>;
+    useValue: Uploader;
+};
+
 /**
  * The built-in unstyled field components — the Angular rendering of the same
  * decisions React's defaults made. Zero CSS; `data-formancy-part` is the
@@ -123,80 +194,158 @@ declare function provideFormancyRegistry(registry: FormancyRegistry): Provider[]
 /** Shared unstyled shell: real label, projected control, error text as the
  *  describedby target. */
 declare class FormancyFieldShell {
-    readonly field: i0.InputSignal<FieldBinding>;
-    readonly label: i0.InputSignal<string>;
-    protected readonly showError: i0.Signal<boolean>;
-    protected readonly errorText: i0.Signal<string>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyFieldShell, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyFieldShell, "formancy-field-shell", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+    readonly field: _angular_core.InputSignal<FieldBinding>;
+    readonly label: _angular_core.InputSignal<string>;
+    /** Inert here; read by tools outside the renderer. See FormancyLayout. */
+    readonly path: _angular_core.InputSignal<string>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    protected readonly errorText: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyFieldShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyFieldShell, "formancy-field-shell", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "path": { "alias": "path"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
 }
 /** The state every leaf control shares; components extend it so the templates
  *  stay the only per-type code. Context comes through DI (see registry.ts). */
 declare abstract class FieldComponentBase {
     protected readonly context: _formancy_angular.FormancyFieldContext;
     protected readonly field: FieldBinding;
-    protected readonly control: i0.Signal<_formancy_core.ControlProps>;
-    private readonly engine;
+    protected readonly control: _angular_core.Signal<_formancy_core.ControlProps>;
+    protected readonly engine: _formancy_core.FormEngine;
     /**
      * Option labels resolved to strings, since a label may be a reference into
      * the message catalogue. Falling back to the stored value keeps an
      * untranslated option selectable rather than blank.
      */
-    protected readonly options: i0.Signal<readonly {
+    protected readonly options: _angular_core.Signal<readonly {
+        value: string;
+        label: string;
+    }[]>;
+    /**
+     * What the control types into, when it has something to type into.
+     *
+     * A plain `<select>` never writes to it, so its source is asked for everything and
+     * shows what fits; the typeahead writes every keystroke.
+     */
+    protected readonly sourceQuery: _angular_core.WritableSignal<string>;
+    /** The remote half, or an inert one for the ordinary field that lists its options. */
+    protected readonly remote: SourcedOptionsState;
+    /**
+     * Whether THIS component is the one that will render the field.
+     *
+     * True for every control but the select that hands over to the typeahead, which
+     * overrides it. Both extend this base, so without the distinction a sourced
+     * typeahead asked its source twice and read one set of answers.
+     */
+    protected sourceEnabled(): boolean;
+    /**
+     * The options to offer: the document's, or the deployment's.
+     *
+     * The stored answer is always offerable even when the current query does not match
+     * it — a control that dropped it would show an empty box over an answer the form
+     * holds, and the next blur would look like the person cleared it.
+     */
+    protected readonly offered: _angular_core.Signal<readonly {
         value: string;
         label: string;
     }[]>;
 }
+/**
+ * A single-line answer, and — with `widget: "scanner"` — a camera route to the same
+ * string.
+ *
+ * The input is the control in both cases, never a second one beside it: typing is the
+ * accessibility floor and the fallback at once, so it is what is always there and the
+ * scan button is what is sometimes added. With no scanner supplied the markup is the
+ * default control exactly, because a Scan button that opens nothing is worse than no
+ * button ([0071](../../../docs/decisions/0071-a-scanner-is-supplied-not-built.md)).
+ *
+ * The React binding renders the same three elements for the same reasons.
+ */
 declare class FormancyTextField extends FieldComponentBase {
-    protected readonly text: i0.Signal<string>;
+    private readonly scan;
+    protected readonly scanning: _angular_core.WritableSignal<boolean>;
+    /** A device failure, held here rather than in the field's errors. See above. */
+    private readonly trouble;
+    protected readonly text: _angular_core.Signal<string>;
+    /**
+     * A computed over the field's SIGNAL, not over `engine.getFieldSnapshot` — the
+     * widget can arrive with a new document, and a plain method call is not a
+     * dependency an OnPush component re-runs for.
+     */
+    protected readonly scannable: _angular_core.Signal<boolean>;
+    protected readonly status: _angular_core.Signal<string>;
     protected onInput(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyTextField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyTextField, "formancy-text-field", never, {}, {}, never, never, true, never>;
+    /**
+     * The ONE place a text field's answer is written, typed or scanned.
+     *
+     * Structural rather than careful: the parameter is a `string`, so there is no path
+     * from the camera to `setValue` that could store something typing could not — the
+     * line a widget may never cross
+     * ([0065](../../../docs/decisions/0065-a-widget-is-authored-not-registered.md)).
+     */
+    private commit;
+    protected read(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyTextField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyTextField, "formancy-text-field", never, {}, {}, never, never, true, never>;
 }
 declare class FormancyTextareaField extends FieldComponentBase {
-    protected readonly text: i0.Signal<string>;
+    protected readonly text: _angular_core.Signal<string>;
     protected onInput(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyTextareaField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyTextareaField, "formancy-textarea-field", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyTextareaField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyTextareaField, "formancy-textarea-field", never, {}, {}, never, never, true, never>;
 }
 declare class FormancyNumberField extends FieldComponentBase {
-    protected readonly text: i0.Signal<string>;
+    protected readonly text: _angular_core.Signal<string>;
     protected onInput(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyNumberField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyNumberField, "formancy-number-field", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyNumberField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyNumberField, "formancy-number-field", never, {}, {}, never, never, true, never>;
 }
 declare class FormancyCheckboxField extends FieldComponentBase {
-    protected readonly checked: i0.Signal<boolean>;
+    protected readonly checked: _angular_core.Signal<boolean>;
+    /**
+     * `widget: "toggle"` is a part name and NOT `role="switch"`.
+     *
+     * ARIA's switch means a control that takes effect when you operate it, and a form
+     * field sets a value submitted later or never — so announcing "switch" describes
+     * it incorrectly to the people who rely on the description. A role is also not
+     * paint: changing it would make this the first widget to change what a control
+     * claims to be, which is the line the widget mechanism exists to hold. The switch
+     * is CSS, and conformance keeps finding this by role `checkbox` either way.
+     *
+     * Null rather than absent when there is no widget, because Angular omits an
+     * attribute bound to null — which is what keeps an ordinary checkbox's markup
+     * exactly as it was.
+     */
+    protected readonly part: _angular_core.Signal<"toggle" | null>;
     protected onChange(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyCheckboxField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyCheckboxField, "formancy-checkbox-field", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyCheckboxField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyCheckboxField, "formancy-checkbox-field", never, {}, {}, never, never, true, never>;
 }
 declare class FormancyDateField extends FieldComponentBase {
-    protected readonly text: i0.Signal<string>;
+    protected readonly text: _angular_core.Signal<string>;
     protected onInput(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyDateField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyDateField, "formancy-date-field", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyDateField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyDateField, "formancy-date-field", never, {}, {}, never, never, true, never>;
 }
 declare class FormancySelectField extends FieldComponentBase {
-    protected readonly selected: i0.Signal<string>;
+    protected readonly typeahead: _angular_core.Signal<boolean>;
+    /** The name the document gave, for the message when this deployment has no such source. */
+    protected readonly sourceName: _angular_core.Signal<string>;
+    /** This one hands over to the typeahead, which does its own asking. */
+    protected sourceEnabled(): boolean;
+    protected readonly selected: _angular_core.Signal<string>;
     protected onChange(event: Event): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancySelectField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancySelectField, "formancy-select-field", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancySelectField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancySelectField, "formancy-select-field", never, {}, {}, never, never, true, never>;
 }
 declare class FormancyRadioGroupField extends FieldComponentBase {
-    protected readonly showError: i0.Signal<boolean>;
-    protected readonly errorText: i0.Signal<string>;
+    protected readonly showError: _angular_core.Signal<boolean>;
+    protected readonly errorText: _angular_core.Signal<string>;
     protected optionId(option: {
         value: string;
     }): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyRadioGroupField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyRadioGroupField, "formancy-radio-group-field", never, {}, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyRadioGroupField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyRadioGroupField, "formancy-radio-group-field", never, {}, {}, never, never, true, never>;
 }
-/**
- * The built-in unstyled components. `null` means the type renders nothing here:
- * hidden and static are non-inputs, and the container types are laid out by
- * their own machinery, not by a leaf slot.
- */
 declare const DEFAULT_FIELD_COMPONENTS: Record<FieldType, Type<unknown> | null>;
 
 interface SubmitOutcome {
@@ -214,13 +363,13 @@ interface SubmitOutcome {
  */
 declare class FormancyComponentOutlet implements OnChanges, OnDestroy {
     private readonly container;
-    readonly formancyOutlet: i0.InputSignal<Type<unknown>>;
-    readonly formancyOutletInjector: i0.InputSignal<Injector>;
+    readonly formancyOutlet: _angular_core.InputSignal<Type<unknown>>;
+    readonly formancyOutletInjector: _angular_core.InputSignal<Injector>;
     private ref;
     ngOnChanges(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyComponentOutlet, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FormancyComponentOutlet, "[formancyOutlet]", never, { "formancyOutlet": { "alias": "formancyOutlet"; "required": true; "isSignal": true; }; "formancyOutletInjector": { "alias": "formancyOutletInjector"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyComponentOutlet, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FormancyComponentOutlet, "[formancyOutlet]", never, { "formancyOutlet": { "alias": "formancyOutlet"; "required": true; "isSignal": true; }; "formancyOutletInjector": { "alias": "formancyOutletInjector"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 /**
  * One field's slot: resolve the component through the registry (per-path beats
@@ -236,22 +385,27 @@ declare class FormancyComponentOutlet implements OnChanges, OnDestroy {
 declare class FormancyFieldSlot implements OnInit {
     private readonly registry;
     private readonly injector;
-    readonly path: i0.InputSignal<string>;
-    readonly fallbackLabel: i0.InputSignal<string | undefined>;
+    readonly path: _angular_core.InputSignal<string>;
+    readonly fallbackLabel: _angular_core.InputSignal<string | undefined>;
     protected state?: {
         snapshot: Signal<FieldSnapshot>;
         component: Type<unknown> | null;
         injector: Injector;
     };
     ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyFieldSlot, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyFieldSlot, "formancy-field", never, { "path": { "alias": "path"; "required": true; "isSignal": true; }; "fallbackLabel": { "alias": "fallbackLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyFieldSlot, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyFieldSlot, "formancy-field", never, { "path": { "alias": "path"; "required": true; "isSignal": true; }; "fallbackLabel": { "alias": "fallbackLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 interface RepeaterRow {
     index: number;
     /** The row's stable identity, which `@for` tracks instead of its position. */
     id: string;
-    wires: readonly string[];
+    /** Each field of the row: its key within the row, and its positional wire.
+     *  Tracked by `key`, bound by `wire`. */
+    children: ReadonlyArray<{
+        key: string;
+        wire: string;
+    }>;
 }
 /**
  * A repeater's own chrome: a named fieldset, one row div per item with the row
@@ -262,8 +416,11 @@ interface RepeaterRow {
 declare class FormancyRepeaterSection implements OnInit {
     private readonly engine;
     private readonly injector;
-    readonly wire: i0.InputSignal<string>;
-    readonly labels: i0.InputSignal<Record<string, string> | undefined>;
+    readonly wire: _angular_core.InputSignal<string>;
+    readonly labels: _angular_core.InputSignal<Record<string, string> | undefined>;
+    /** The repeater's own definition, kept because the column plan reads `widget`,
+     *  `columns` and the child labels off it on every render. */
+    protected definition: FieldDef | undefined;
     protected state?: {
         repeater: RepeaterBinding;
         label: string;
@@ -271,10 +428,83 @@ declare class FormancyRepeaterSection implements OnInit {
         removeLabel: string;
         rows: Signal<readonly RepeaterRow[]>;
     };
+    /**
+     * The columns the grid shows, in the order it shows them, or an empty list when the
+     * widget was not asked for.
+     *
+     * `columns` without the widget stays inert on purpose: 0066 lets an author write the
+     * arrangement before a renderer honours it, and a repeater that silently became a grid
+     * because somebody sized its columns would be the opposite of that.
+     *
+     * The React binding computes the same list with the same helper, for the same reasons.
+     */
+    protected readonly plan: Signal<readonly {
+        key: string;
+        heading: string;
+        align: string | null;
+        width?: number;
+    }[]>;
+    /**
+     * The authored ratios, as ONE custom property rather than as `grid-template-columns`.
+     *
+     * A property lays nothing out by itself, so a theme's narrow-screen media query
+     * replaces its own declaration and wins rather than losing to an inline one it cannot
+     * outrank. It also carries a value space no attribute could enumerate: `width` is a
+     * number with `exclusiveMinimum: 0`, so 1.5 is legal and nothing bounds it from above.
+     *
+     * Nothing at all when no column was sized, so the theme's fallback is live code.
+     */
+    protected trackStyle(): Record<string, string>;
+    /**
+     * The controls in one cell: every leaf inside the row that belongs to that column's
+     * child field.
+     *
+     * One child, because a grid's rows are FLAT: a child holding fields of its own is
+     * refused when the document is saved (0078). This walked the whole subtree under the
+     * child while a group could be a column, and every clause that made that walk safe is
+     * gone with the arrangement it served.
+     *
+     * Still a filter over the children that EXIST rather than the wire the column implies,
+     * so a document nobody validated renders an empty cell rather than a field the engine
+     * does not have.
+     */
+    protected cellChildren(row: RepeaterRow, key: string): readonly RepeaterRow['children'][number][];
     ngOnInit(): void;
     protected fallbackFor(instanceWire: string): string | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyRepeaterSection, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyRepeaterSection, "formancy-repeater", never, { "wire": { "alias": "wire"; "required": true; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyRepeaterSection, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyRepeaterSection, "formancy-repeater", never, { "wire": { "alias": "wire"; "required": true; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class FormancyLayout {
+    readonly nodes: _angular_core.InputSignal<readonly LayoutNode[]>;
+    readonly labels: _angular_core.InputSignal<Record<string, string> | undefined>;
+    /** Index path of the container these nodes are the children of. */
+    readonly at: _angular_core.InputSignal<string>;
+    private readonly engine;
+    constructor();
+    /** The span as a number CSS can count with, and nothing at all for `all`.
+     *
+     *  A style OBJECT rather than `[style.--fm-span]`: both set a custom property --
+     *  measured, both work -- and the object form lets this return nothing for `all`
+     *  without binding an empty string. */
+    protected spanStyle(node: LayoutNode): Record<string, string>;
+    /** This node's index path, as the dotted string the attribute carries. */
+    protected pathOf(index: number): string;
+    /**
+     * Headings are cached per node. Minting an id inside the template would give
+     * a different one on every change-detection pass, leaving aria-labelledby
+     * pointing at an element that no longer exists.
+     */
+    private readonly headings;
+    private static counter;
+    /** A tabs node's own name, for the tab strip. Null when it has none. */
+    protected stripLabelFor(node: LayoutNode): string | null;
+    protected isRepeater(path: string): boolean;
+    protected headingFor(node: LayoutNode): {
+        id: string;
+        text: string;
+    } | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyLayout, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyLayout, "formancy-layout", never, { "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "at": { "alias": "at"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 /**
  * Renders the whole form from the engine: one slot per field, resolved through
@@ -294,9 +524,14 @@ declare class FormancyForm {
      * `items[].name`). A `label` on the model definition wins — that is how
      * fixture schemas carry text until the spec's i18n section lands.
      */
-    readonly labels: i0.InputSignal<Record<string, string> | undefined>;
-    readonly submitLabel: i0.InputSignal<string | undefined>;
-    readonly submitted: i0.OutputEmitterRef<SubmitOutcome>;
+    readonly labels: _angular_core.InputSignal<Record<string, string> | undefined>;
+    /**
+     * Render a named entry from the schema's `layouts` instead of model order.
+     * Unknown or absent, the form falls back to model order.
+     */
+    readonly layout: _angular_core.InputSignal<string | undefined>;
+    readonly submitLabel: _angular_core.InputSignal<string | undefined>;
+    readonly submitted: _angular_core.OutputEmitterRef<SubmitOutcome>;
     protected readonly pages: readonly {
         key: string;
         def: FieldDef;
@@ -305,6 +540,11 @@ declare class FormancyForm {
     protected readonly staticWires: string[];
     protected readonly staticOnPage: Signal<string[]>;
     protected readonly repeatersOnPage: Signal<string[]>;
+    /**
+     * The nodes of the named layout, or undefined to fall back to model order —
+     * a mistyped layout name should not produce an empty form.
+     */
+    protected readonly arrangement: Signal<readonly LayoutNode[] | undefined>;
     protected fallbackFor(wire: string): string | undefined;
     protected pageLabel(page: {
         key: string;
@@ -312,8 +552,8 @@ declare class FormancyForm {
     }): string;
     protected onNext(): void;
     protected onSubmit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyForm, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyForm, "formancy-form", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "submitLabel": { "alias": "submitLabel"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyForm, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyForm, "formancy-form", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "submitLabel": { "alias": "submitLabel"; "required": false; "isSignal": true; }; }, { "submitted": "submitted"; }, never, never, true, never>;
 }
 
 /**
@@ -326,7 +566,7 @@ declare class FormancyForm {
  * problem" already means to assistive tech.
  */
 declare class FormancyErrorSummary {
-    readonly labels: i0.InputSignal<Record<string, string> | undefined>;
+    readonly labels: _angular_core.InputSignal<Record<string, string> | undefined>;
     private readonly engine;
     private readonly region;
     protected readonly errors: Signal<ReadonlyArray<{
@@ -338,9 +578,288 @@ declare class FormancyErrorSummary {
     protected labelFor(path: string): string;
     protected controlIdOf(path: string): string;
     protected focusControl(event: Event, path: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormancyErrorSummary, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormancyErrorSummary, "formancy-error-summary", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyErrorSummary, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyErrorSummary, "formancy-error-summary", never, { "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * One run of inline nodes, recursing through its own selector.
+ *
+ * Angular has no fragment component, so emphasis inside emphasis is expressed
+ * by the component referring to itself — which is why it is its own
+ * declaration rather than part of the block template below.
+ */
+declare class FormancyRichInline {
+    readonly nodes: _angular_core.InputSignal<readonly RichInline[]>;
+    protected asText(node: RichInline): string;
+    protected childrenOf(node: RichInline): readonly RichInline[];
+    protected hrefOf(node: RichInline): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyRichInline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyRichInline, "formancy-rich-inline", never, { "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * Showing a `richtext` answer, from the same parser the React renderer uses.
+ *
+ * No `[innerHTML]`, and no `DomSanitizer` — there is nothing to sanitise. The
+ * stored answer is parsed into a typed tree in `@formancy/spec`, and every
+ * element here is created by Angular from that tree, so the characters
+ * somebody typed arrive as interpolated text and cannot become markup however
+ * they are spelled ([0052](../../../docs/decisions/0052-richtext-is-not-html.md)).
+ *
+ * Both renderers building the same tree into the same elements is the promise
+ * the engine makes across browser and server, applied to presentation: two
+ * implementations, one meaning.
+ */
+declare class FormancyRichText {
+    readonly source: _angular_core.InputSignal<string>;
+    protected readonly blocks: _angular_core.Signal<RichBlock[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyRichText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyRichText, "formancy-rich-text", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { DEFAULT_FIELD_COMPONENTS, FORMANCY_ENGINE, FORMANCY_FIELD_CONTEXT, FORMANCY_REGISTRY, FormancyCheckboxField, FormancyComponentOutlet, FormancyDateField, FormancyErrorSummary, FormancyFieldShell, FormancyFieldSlot, FormancyForm, FormancyNumberField, FormancyRadioGroupField, FormancyRepeaterSection, FormancySelectField, FormancyTextField, FormancyTextareaField, injectEngine, injectField, injectFieldContext, injectRepeater, injectSubmit, injectWizard, provideFormancy, provideFormancyRegistry };
-export type { FieldBinding, FormancyFieldContext, FormancyRegistry, RepeaterBinding, SubmitOutcome, WizardBinding };
+/**
+ * Telling somebody their draft came back changed.
+ *
+ * The same component the React binding has, word for word in what it says,
+ * because the two renderers agreeing about what a form TELLS somebody matters as
+ * much as them agreeing about what it collects.
+ *
+ * The server already does the careful half: a republished form migrates a draft
+ * lazily on resume, and answers whose field no longer exists move to
+ * `data.__orphaned` rather than being deleted
+ * ([0027](../../../docs/decisions/0027-lazy-draft-migration.md)).
+ *
+ * **Nothing showed that to the person.** They resumed a draft, some of their
+ * answers were no longer on the form, and they submitted believing everything
+ * they had typed was in it. The answers are not lost from storage — they are
+ * lost from the submission, and nobody was told.
+ *
+ * The semantics follow `formancy-error-summary`, which solved the same shape of
+ * problem: the container takes focus through `tabindex="-1"` and is deliberately
+ * NOT `role="alert"`, because focusing it already makes a screen reader announce
+ * it and doing both announces it twice.
+ */
+interface ResumeMigration {
+    readonly severity: 'lossy' | 'breaking';
+    readonly changes: ReadonlyArray<{
+        readonly kind: string;
+        readonly path?: string;
+    }>;
+}
+declare class FormancyResumeNotice {
+    /** Omitted when the draft came back unchanged. */
+    readonly migration: _angular_core.InputSignal<ResumeMigration | undefined>;
+    /** Question wording for a field key, since a key is not what the form asked. */
+    readonly labels: _angular_core.InputSignal<Readonly<Record<string, string>>>;
+    protected readonly setAside: _angular_core.Signal<string[]>;
+    protected readonly summary: _angular_core.Signal<string>;
+    private readonly region;
+    private readonly focused;
+    protected labelFor(path: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormancyResumeNotice, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormancyResumeNotice, "formancy-resume-notice", never, { "migration": { "alias": "migration"; "required": false; "isSignal": true; }; "labels": { "alias": "labels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A rich-text editing surface, supplied by the host.
+ *
+ * The same contract the React binding uses, deliberately to the letter: one
+ * interface, one factory, one set of attributes. A renderer that invented its own
+ * shape here would be the drift the conformance suite exists to prevent, except
+ * in the one place the suite cannot see — what the HOST passes in.
+ *
+ * Why the host and not this package: a contenteditable editor means ProseMirror,
+ * which is larger than this entire package, and most forms have no rich-text
+ * field. Without a factory the field is a textarea with a toolbar, which is a
+ * working editor and not a degraded mode
+ * ([0061](../../../docs/decisions/0061-tiptap-over-the-closed-grammar.md)).
+ *
+ * What crosses this boundary is **the stored grammar in both directions, never
+ * markup**. That is the whole reason an editor is admissible: nothing on either
+ * side holds a string of HTML, so no consumer of an answer becomes a sanitiser
+ * ([0052](../../../docs/decisions/0052-richtext-is-not-html.md)).
+ */
+interface RichTextEditorHandle {
+    /** The stored answer, in the grammar. */
+    value: () => string;
+    /** Replace the content when the form's value changes underneath the editor. */
+    setValue: (value: string) => void;
+    /**
+     * Run a formatting command, so the field's own toolbar keeps working.
+     *
+     * Needed because an editor library brings keyboard shortcuts and no toolbar
+     * UI. Leaving the field's toolbar out made Bold reachable by Ctrl+B and by no
+     * visible control, which is a regression against the `<textarea>` it replaced
+     * and unusable for anybody who does not know the shortcut.
+     *
+     * The commands are the grammar's whole surface — the same `RichCommand`
+     * values the textarea's toolbar uses — so one toolbar drives either surface
+     * and the two cannot offer different things.
+     */
+    run: (command: RichCommand, href?: string) => void;
+    /** Whether the command is on at the caret, for the toolbar's pressed state. */
+    isActive: (command: RichCommand) => boolean;
+    destroy: () => void;
+}
+interface RichTextEditorMount {
+    /** Where to mount. The host's factory owns what it puts inside. */
+    readonly element: Element;
+    /** The stored answer to open with, in the grammar. */
+    readonly value: string;
+    /** Called with the new stored answer, in the grammar. */
+    readonly onChange: (value: string) => void;
+    readonly editable: boolean;
+    /**
+     * Attributes for the editing surface itself, so the ENGINE keeps owning the
+     * accessibility wiring.
+     *
+     * These ids are minted by `@formancy/core` and composed centrally, which is
+     * what makes `aria-describedby` identical in both renderers rather than
+     * correct in one of them. An editor package that labelled its own surface
+     * would be a third implementation, and the one nobody tests.
+     */
+    readonly attributes: Readonly<Record<string, string>>;
+}
+type RichTextEditorFactory = (mount: RichTextEditorMount) => RichTextEditorHandle;
+/**
+ * Optional by design, and its absence costs less than the uploader's.
+ *
+ * A missing uploader makes a file field read-only, because there is nowhere to
+ * put the bytes. A missing editor costs only the WYSIWYG surface: the answer is
+ * still editable, still valid, and still the same grammar.
+ */
+declare const FORMANCY_RICH_TEXT_EDITOR: InjectionToken<RichTextEditorFactory>;
+declare function injectRichTextEditorFactory(): RichTextEditorFactory | null;
+/** Providing one, for a host that wants the contenteditable surface. */
+declare function provideFormancyRichTextEditor(make: RichTextEditorFactory): {
+    provide: InjectionToken<RichTextEditorFactory>;
+    useValue: RichTextEditorFactory;
+};
+
+/**
+ * What a source is asked for.
+ *
+ * Declared here as well as in `@formancy/react` and deliberately not shared, exactly
+ * as `ScanRequest` and `Scanner` are declared twice. A host contract each binding
+ * states in its own words is a contract each binding can be read on its own.
+ *
+ * `kind` is a flat discriminator rather than a union of two interfaces: a host
+ * written in plain JavaScript must be harmless, and a shape it can read with one
+ * `if` is a shape it gets right.
+ */
+interface OptionsRequest {
+    /**
+     * `search` — somebody is typing and wants matching rows.
+     * `labels` — the form holds these values already and needs their names.
+     */
+    kind: 'search' | 'labels';
+    /** The name the document gave, which the deployment resolves. */
+    source: string;
+    /** The field's data path, e.g. `canton` or `people[1].canton`. */
+    path: string;
+    /** What was typed. Empty on a `labels` request. */
+    query: string;
+    /** The stored values to name. Empty on a `search`. */
+    values: readonly string[];
+    /**
+     * The locale the form is being resolved in — the engine's, which is the host's own
+     * `locale` when it passed one and the document's default otherwise.
+     *
+     * A remote label is a plain string, never a `{$t}` reference: nothing can check a
+     * reference that arrives at runtime, and an unchecked one resolves to nothing and
+     * shows an opaque identifier. So the source answers in the right language instead.
+     */
+    locale: string;
+    /** How many rows the control can show. A hint: the control caps what arrives anyway. */
+    limit: number;
+    /** Aborted when the answer stops being wanted — a newer keystroke, or a destroy. */
+    signal: AbortSignal;
+}
+/**
+ * Where one named list of options comes from.
+ *
+ * The third instance of the inversion the uploader and the scanner already are: the
+ * document names a list, the deployment says what that name means, and nothing in
+ * formancy ever makes a request of its own. A URL in a form document would be a
+ * deployment detail in a portable format, unfixable once published, and an SSRF
+ * surface on a self-hosted instance.
+ */
+interface OptionsSource {
+    resolve(request: OptionsRequest): Promise<readonly RemoteOption[]>;
+    /** How long to wait after a keystroke before asking. The control has a default. */
+    debounceMs?: number;
+    /** Below this many characters, do not ask at all. The control says so on screen. */
+    minQueryLength?: number;
+    /** How many rows to show at once. */
+    maxRows?: number;
+}
+/**
+ * Every source this deployment has, by the name a document would use.
+ *
+ * A MAP rather than one resolver function, and that is the one deliberate difference
+ * from `Scanner`. The control has to know **synchronously** whether a name resolves,
+ * because absence here is the *file field's* branch and not the scanner's: a text
+ * field with no scanner still collects the answer by typing, but a select whose
+ * options come only from a source collects nothing at all, so it must say so instead
+ * of rendering an empty chooser.
+ */
+type OptionsSources = Readonly<Record<string, OptionsSource>>;
+/**
+ * Optional, and what its absence costs depends on the document. A form with no
+ * sourced field never needs one; a field that names a source renders a message where
+ * its chooser would be, exactly as the file field does without an uploader.
+ */
+declare const FORMANCY_OPTIONS_SOURCES: InjectionToken<Readonly<Record<string, OptionsSource>>>;
+declare function injectOptionsSources(): OptionsSources | null;
+/** Providing them, for a host that has the lists a document names. */
+declare function provideFormancyOptionsSources(sources: OptionsSources): {
+    provide: InjectionToken<Readonly<Record<string, OptionsSource>>>;
+    useValue: Readonly<Record<string, OptionsSource>>;
+};
+
+/**
+ * What a scanner is asked to read.
+ *
+ * The same contract the React binding declares: the field's resolved label, so a host's
+ * camera sheet can say what it is looking for, and its data path, so a host can meter
+ * one field's scans.
+ *
+ * **Nothing about the format is here.** `pattern` is the field's and the engine checks
+ * it; a scanner told to pre-filter would be a second validator drifting from the first.
+ */
+interface ScanRequest {
+    /** The field's label, resolved through the message catalogue. */
+    label: string;
+    /** The field's data path, e.g. `serial` or `items[1].serial`. */
+    path: string;
+}
+/**
+ * Reads a code and reports the text on it.
+ *
+ * The camera, the permission prompt, the viewfinder and the decoding all belong to
+ * whoever mounted the form ([0071](../../../docs/decisions/0071-a-scanner-is-supplied-not-built.md)).
+ *
+ * **Resolving with `null` means nobody scanned anything** — the sheet was closed. Not a
+ * failure, and the field says nothing about it. **Rejecting means the device did not
+ * work**, and the field says so in its status region rather than its error region,
+ * because a hardware problem is not a wrong answer.
+ *
+ * **A scanner may not pre-validate**: a value the field's `pattern` refuses is still
+ * what the camera read, and dropping it would leave the field looking empty.
+ */
+type Scanner = (request: ScanRequest) => Promise<string | null>;
+/**
+ * Optional by design. A `scanner` widget with no scanner behind it renders the ordinary
+ * text input and no button — typing was always the field's primary route, so there is
+ * nothing to disable and a Scan button that opened nothing would be worse.
+ */
+declare const FORMANCY_SCANNER: InjectionToken<Scanner>;
+declare function injectScanner(): Scanner | null;
+/** Providing one, for a host that has a camera and a decoder. */
+declare function provideFormancyScanner(scan: Scanner): {
+    provide: InjectionToken<Scanner>;
+    useValue: Scanner;
+};
+
+export { DEFAULT_FIELD_COMPONENTS, FORMANCY_ENGINE, FORMANCY_FIELD_CONTEXT, FORMANCY_OPTIONS_SOURCES, FORMANCY_REGISTRY, FORMANCY_RICH_TEXT_EDITOR, FORMANCY_SCANNER, FORMANCY_UPLOADER, FormancyCheckboxField, FormancyComponentOutlet, FormancyDateField, FormancyErrorSummary, FormancyFieldShell, FormancyFieldSlot, FormancyForm, FormancyLayout, FormancyNumberField, FormancyRadioGroupField, FormancyRepeaterSection, FormancyResumeNotice, FormancyRichInline, FormancyRichText, FormancySelectField, FormancyTextField, FormancyTextareaField, injectEngine, injectField, injectFieldContext, injectOptionsSources, injectRepeater, injectRichTextEditorFactory, injectScanner, injectSubmit, injectUploader, injectWizard, provideFormancy, provideFormancyOptionsSources, provideFormancyRegistry, provideFormancyRichTextEditor, provideFormancyScanner, provideFormancyUploader };
+export type { FieldBinding, FormancyFieldContext, FormancyRegistry, OptionsRequest, OptionsSource, OptionsSources, RepeaterBinding, ResumeMigration, RichTextEditorFactory, RichTextEditorHandle, RichTextEditorMount, ScanRequest, Scanner, StoredFile, SubmitOutcome, Uploader, WizardBinding };