ng-form-foundry 0.2.1 → 0.3.1

package/index.d.ts

@@ -1,6 +1,6 @@
 import { FormControl, FormArray, FormGroup } from '@angular/forms';
-import * as i0 from '@angular/core';
-import { OnInit, EventEmitter, AfterViewInit, QueryList, ChangeDetectorRef } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, AfterViewInit, ElementRef, EventEmitter, QueryList, ChangeDetectorRef, OnChanges, SimpleChanges } from '@angular/core';
 import { MatDialog } from '@angular/material/dialog';
 
 type LeafRuntimeType<T> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'enum' ? string | number : never;
@@ -10,6 +10,26 @@ type LeafBase = {
     required?: true | undefined;
     label?: string;
     description?: string;
+    /**
+     * The value may be `null` (JSON Schema `type: [T, 'null']`). Builds a nullable
+     * control (drops `nonNullable`), so `null` is a first-class value the
+     * constraint validators accept and that survives the round-trip. Distinct from
+     * {@link presence}: `nullable` is an explicit `null`, `presence` is an absent key.
+     */
+    nullable?: boolean;
+    /**
+     * Optional scalar whose *presence itself* is data (mirrors {@link NodeGroup.presence}).
+     * Rendered with an on/off toggle; the control is removed from the parent group
+     * when absent (so it drops from `form.value`) and re-added when toggled on. The
+     * builder omits it unless an initial value is supplied.
+     */
+    presence?: boolean;
+    /**
+     * Render the field read-only even when the surrounding form is editable.
+     * Combine with `default` to express a JSON Schema `const` (a fixed,
+     * display-only value); single-element `enum` is the alternative for a constant.
+     */
+    readOnly?: boolean;
 };
 type AnonLeaf = {
     [K in Leaf['type']]: {
@@ -19,10 +39,30 @@ type AnonLeaf = {
 type LeafString = LeafBase & {
     type: 'string';
     default?: LeafRuntimeType<'string'>;
+    /**
+     * Reject values that don't match this regular expression. Follows JSON Schema
+     * `pattern` semantics — an *unanchored* `RegExp.test`, so it matches anywhere
+     * in the value unless the pattern itself anchors with `^`/`$`.
+     */
+    pattern?: string;
+    /** Minimum string length (JSON Schema `minLength`). */
+    minLength?: number;
+    /** Maximum string length (JSON Schema `maxLength`). */
+    maxLength?: number;
+    /** Semantic string format (JSON Schema `format`); adds a matching validator. */
+    format?: 'email' | 'uri' | 'url';
 };
 type LeafNumber = LeafBase & {
     type: 'number';
     default?: LeafRuntimeType<'number'>;
+    /** Require a whole-number value (JSON Schema `type: 'integer'`). */
+    integer?: boolean;
+    /** Inclusive lower bound (JSON Schema `minimum`). */
+    min?: number;
+    /** Inclusive upper bound (JSON Schema `maximum`). */
+    max?: number;
+    /** Require the value to be an integer multiple of this number (JSON Schema `multipleOf`). */
+    multipleOf?: number;
 };
 type LeafBoolean = LeafBase & {
     type: 'boolean';
@@ -37,6 +77,8 @@ type LeafEnum = LeafBase & {
 type Appearance = {
     flatten?: boolean;
     noBorder?: boolean;
+    /** Start this node's section panel collapsed. Ignored when `flatten` is set. */
+    collapsed?: boolean;
 };
 type Leaf = LeafString | LeafNumber | LeafBoolean | LeafEnum;
 type LeafList<TKind extends Leaf['type'] = Leaf['type']> = {
@@ -75,30 +117,163 @@ type NodeGroup = {
     children: Record<string, NodeType>;
     appearance?: Appearance;
 };
+/**
+ * One case of a {@link NodeChoice}: either a record of named fields (an object
+ * branch), or a single node (a *leaf-bodied* case — e.g. an `anyOf` branch that
+ * is a bare scalar). A single node is normalized to a one-field record keyed by
+ * its `name` when the form is built.
+ */
+type ChoiceCase = Record<string, NodeType> | NodeType;
 /**
  * A discriminated selection: the user picks one `case`, and only that case's
  * fields are present. In the form it is a FormGroup holding a `__case` control
  * (the active case name) plus that case's field controls; switching the case
  * swaps the field controls.
+ *
+ * Cases may be **anonymous / auto-named** (any string key) — for JSON Schema
+ * `anyOf`/`oneOf` branches with no name. When a built form is seeded from inline
+ * data that carries no `__case`, the builder **infers** the active case from the
+ * data shape (the case whose fields best match), so a choice round-trips from
+ * real instance data. See the schema reference for the required-set / `const`
+ * discriminator recipe.
  */
 type NodeChoice = {
     kind: 'choice';
     name: string;
     label?: string;
-    cases: Record<string, Record<string, NodeType>>;
+    cases: Record<string, ChoiceCase>;
+    /**
+     * Display labels for cases, keyed by case name — for anonymous/auto-named
+     * branches whose keys are not human-friendly. Falls back to the case name.
+     */
+    caseLabels?: Record<string, string>;
     default?: string;
     mandatory?: boolean;
+    /** Optional choice: rendered with an on/off toggle, omitted from the value when absent. */
+    presence?: boolean;
+    appearance?: Appearance;
 };
-/** The control name that records which case of a {@link NodeChoice} is active. */
+/**
+ * The control name that records which case of a {@link NodeChoice} is active.
+ * The name is reserved: it cannot be used as a case field name (the builder
+ * throws) or as a map entry key (the entry helpers reject it).
+ */
 declare const CASE_KEY = "__case";
-type NodeType = Leaf | LeafList | NodeGroup | NodeGroupList | NodeChoice;
-type DFormControl<T extends NodeType> = T extends Leaf ? FormControl<LeafRuntimeType<T['type']>> : T extends LeafList ? FormArray<FormControl<LeafRuntimeType<T['type']>>> : T extends NodeGroup ? DFormGroup<T> : T extends NodeGroupList ? FormArray<DFormGroup<T['type']>> : T extends NodeChoice ? FormGroup<any> : never;
+/**
+ * An open, arbitrary-keyed record: unlike {@link NodeGroup} (a fixed, declared
+ * key set), a map's keys are runtime data and every value conforms to one shared
+ * `value` schema. Maps JSON Schema `additionalProperties: <schema>` /
+ * `patternProperties`. In the form it is a `FormGroup` whose control *names* are
+ * the entry keys, so `getRawValue()` is the map object directly; the renderer
+ * lets the user add, remove, and rename entries.
+ */
+type NodeMap = {
+    kind: 'map';
+    name: string;
+    label?: string;
+    description?: string;
+    /** The schema every entry's value conforms to. */
+    value: NodeType;
+    /** Label for the key column in the editor. Defaults to "Key". */
+    keyLabel?: string;
+    /** `patternProperties`: entry keys must match this regular expression. */
+    keyPattern?: string;
+    /** Minimum number of entries (JSON Schema `minProperties`). */
+    minEntries?: number;
+    /** Maximum number of entries (JSON Schema `maxProperties`). */
+    maxEntries?: number;
+    /** Optional map: rendered with an on/off toggle, omitted from the value when absent. */
+    presence?: boolean;
+    appearance?: Appearance;
+};
+type NodeType = Leaf | LeafList | NodeGroup | NodeGroupList | NodeChoice | NodeMap;
+type DFormControl<T extends NodeType> = T extends Leaf ? FormControl<LeafRuntimeType<T['type']>> : T extends LeafList ? FormArray<FormControl<LeafRuntimeType<T['type']>>> : T extends NodeGroup ? DFormGroup<T> : T extends NodeGroupList ? FormArray<DFormGroup<T['type']>> : T extends NodeChoice ? FormGroup<any> : T extends NodeMap ? FormGroup<any> : never;
 type FormGroupType<T extends NodeGroup> = {
     [TChild in keyof T['children']]: DFormControl<T['children'][TChild]>;
 };
 type DFormGroup<T extends NodeGroup> = FormGroup<FormGroupType<T>>;
 
+/**
+ * Normalize a {@link ChoiceCase} to a field record. A field record is returned
+ * as-is; a single node (a leaf-bodied case, e.g. a scalar `anyOf` branch) becomes
+ * a one-field record keyed by the node's `name`. The discriminant is a top-level
+ * `kind` string, which a field record never has (its keys are field names).
+ *
+ * Throws when a case field is keyed `__case`: that name is reserved for the
+ * choice discriminator ({@link CASE_KEY}) and a field under it would silently
+ * clobber the active-case control.
+ */
+declare function caseFields(body: ChoiceCase): Record<string, NodeType>;
+/**
+ * The active case of a choice: an explicit `__case` in the initial value, else
+ * the case whose fields best match the initial data (inline wire data carries no
+ * `__case`), else the schema `default`. This lets a choice seed from real
+ * instance data whose branch is discriminated by which fields are present.
+ */
+declare function resolveChoiceCase(choice: NodeChoice, initial?: Record<string, unknown> | null): string | undefined;
+/**
+ * Switch a choice's FormGroup to `caseName`: sets `__case`, removes every other
+ * control, and builds `caseName`'s fields (normalized via {@link caseFields})
+ * with their defaults. Presence fields of the new case start absent — the
+ * switch carries no data that could make them present. An unknown case name
+ * leaves only `__case`. The swap is atomic: one value change fires, and every
+ * observable snapshot has fields matching its discriminator.
+ */
+declare function switchChoiceCase(group: FormGroup, choice: NodeChoice, caseName: string): void;
+/**
+ * Append a map entry built from `map.value` and return its committed key, or
+ * `null` when nothing was added. With no `key`, the first free `keyN`
+ * placeholder is generated (not checked against `keyPattern` — placeholders are
+ * meant to be renamed). An explicit `key` is rejected when it duplicates an
+ * existing entry or violates `keyPattern`. Rejects when `maxEntries` is reached.
+ */
+declare function addMapEntry(group: FormGroup, map: NodeMap, key?: string): string | null;
+/**
+ * Rename entry `oldKey` to `newKey.trim()`, preserving the control instance
+ * (so the value survives) and the entry's position in the group's key order —
+ * the order `getRawValue()` serializes and the tree editor renders. Returns
+ * whether the rename was committed: an empty, reserved (`__case`), unchanged,
+ * duplicate, or `keyPattern`-violating key is a no-op, leaving the entry under
+ * its current name. Entry keys are looked up verbatim — never via
+ * `AbstractControl.get`, which would split keys like `10.0.0.1` into
+ * dot-delimited paths. Emits a single value change.
+ */
+declare function renameMapEntry(group: FormGroup, map: NodeMap, oldKey: string, newKey: string): boolean;
+/** Remove entry `key` unless the map is at `minEntries`. Returns whether it was removed. */
+declare function removeMapEntry(group: FormGroup, map: NodeMap, key: string): boolean;
+/**
+ * Build the `AbstractControl` for a single schema node.
+ *
+ * Dispatches on `node.kind`: a `leaf` becomes a `FormControl`, a `leafList` a
+ * `FormArray` of controls, a `nodeGroup` a nested `FormGroup`, and a
+ * `nodeGroupList` a `FormArray` of groups. `initial` is the runtime value for
+ * this node — a scalar for a leaf, an array for a list, an object for a group —
+ * and seeds the control's value (falling back to the node's `default`).
+ *
+ * Most callers use {@link buildFormFromSchema}; this is exposed for building a
+ * control from a single non-root node.
+ */
 declare function buildControl<T extends NodeType>(node: T, initial?: unknown | null): DFormControl<T> | FormControl<LeafRuntimeType<any>> | FormArray<any>;
+/**
+ * Build a typed `FormGroup` from a root `NodeGroup` schema.
+ *
+ * The returned group's control structure, keys, and value types are inferred
+ * from the schema literal — a `leaf` of `type: 'number'` yields a
+ * `FormControl<number>`, a `nodeGroup` a nested `FormGroup`, and so on. `initial`
+ * is an optional value object keyed by the schema's `children` keys; each child
+ * control is seeded from its matching slice (falling back to the node `default`).
+ *
+ * Presence nodes whose key is absent from `initial` get no control, at any depth
+ * — plain children, list items, map values, and choice case fields alike — so
+ * they are absent from the form value until enabled. A key present with an
+ * explicit `null` keeps its control: `null` is a value, absence is the missing
+ * key.
+ *
+ * Inference only holds when `schema`'s literal type is preserved. Author schemas
+ * with {@link defineSchema} or a `satisfies NodeGroup` annotation — never
+ * `const schema: NodeGroup = ...`, which widens `children` and erases the field
+ * names and value types.
+ */
 declare function buildFormFromSchema<S extends NodeGroup>(schema: S, initial?: Record<string, unknown> | null): DFormGroup<S>;
 /**
  * Capture a schema literal with its exact type while checking it against
@@ -120,40 +295,72 @@ declare function asFormArray(control: any): FormArray;
 declare function asFormGroup(control: any): FormGroup;
 
 declare class DynamicRecursiveFormComponent implements OnInit {
-    schema: NodeGroup;
-    initialValue: any;
-    formGroup: FormGroup<any>;
-    index: number | null;
-    removable: boolean;
-    remove: EventEmitter<any>;
-    title: string;
-    editable: boolean;
-    addButtonCallback: ((index: number) => void) | null;
-    root: boolean;
+    /** The form-description schema to render (a root or nested `NodeGroup`). */
+    readonly schema: _angular_core.InputSignal<NodeGroup>;
+    /** Optional value object to seed the form; keyed by the schema's `children` keys. */
+    readonly initialValue: _angular_core.InputSignal<Record<string, unknown> | null>;
+    /** The reactive group this form binds to. Defaults to an empty group. */
+    readonly formGroup: _angular_core.InputSignal<FormGroup<any>>;
+    /** Index of this form within a parent list, used by `addButtonCallback`. */
+    readonly index: _angular_core.InputSignal<number | null>;
+    /** Whether this form may be removed from a parent list (shows a remove control). */
+    readonly removable: _angular_core.InputSignal<boolean>;
+    /** Emitted when the user removes this form from a parent list. */
+    readonly remove: _angular_core.OutputEmitterRef<void>;
+    /** Card/section title; falls back to the schema label or name. */
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** Whether fields accept input. Two-way: also toggled by the built-in edit control. */
+    readonly editable: _angular_core.ModelSignal<boolean>;
+    /** Invoked with {@link index} to append a new sibling form to a parent list. */
+    readonly addButtonCallback: _angular_core.InputSignal<((index: number) => void) | null>;
+    /**
+     * Key of a presence leaf whose field should grab focus when it renders — lets
+     * a host that added the control itself (e.g. the tree editor's optionals
+     * menu) hand focus to the new field, like the form's own add button does.
+     */
+    readonly focusLeaf: _angular_core.InputSignal<string | null>;
+    /** True when the schema is a root group (rendered flat, without a wrapping card). */
+    readonly root: _angular_core.Signal<boolean>;
     ngOnInit(): void;
-    get nodeGroupChildrenList(): Array<{
+    protected get nodeGroupChildrenList(): Array<{
         key: string;
         value: NodeType;
     }>;
-    emitRemoveEvent(): void;
+    protected emitRemoveEvent(): void;
+    /** The key of the presence leaf the user just enabled; its field grabs focus when rendered. */
+    protected presenceFocusKey: string | null;
+    /**
+     * Add or remove a presence node's control on this form — any presence kind:
+     * group, leaf, map, or choice. Removing it drops the key from `form.value`;
+     * adding it builds the control fresh from its schema (nested presence
+     * children start absent).
+     */
+    toggleNodePresence(key: string, schema: NodeType, present: boolean): void;
     /**
-     * Add or remove a presence group's control on this form. Removing it drops the
-     * group from `form.value`; adding it rebuilds the sub-group from its schema.
+     * {@link toggleNodePresence} for a presence leaf, additionally focusing the
+     * rendered field when the toggle just created it.
      */
-    togglePresence(key: string, schema: NodeGroup, present: boolean): void;
-    protected readonly CASE_KEY = "__case";
-    objectKeys(obj: Record<string, unknown>): string[];
+    toggleLeafPresence(key: string, schema: Leaf, present: boolean): void;
+    protected objectKeys(obj: Record<string, unknown>): string[];
     /** The active case name of a choice control, or null if none is selected. */
-    activeCase(key: string): string | null;
+    protected activeCase(key: string): string | null;
     /** A synthetic flattened NodeGroup used to render the active case's fields against the choice's FormGroup. */
-    caseAsGroup(choice: NodeChoice, caseName: string): NodeGroup;
-    /** Swap a choice's field controls when the selected case changes. */
+    protected caseAsGroup(choice: NodeChoice, caseName: string): NodeGroup;
+    /** The display label for a case: the schema's `caseLabels` entry, else the case name. */
+    caseLabel(choice: NodeChoice, caseName: string): string;
+    /**
+     * A copy of a group flagged to render its fields inline (no inner panel). Used
+     * for a presence group's body, whose container is the presence panel itself, so
+     * the group's own section panel would be a redundant second box.
+     */
+    protected flatGroup(group: NodeGroup): NodeGroup;
+    /** Swap a choice's field controls when the selected case changes. Delegates to {@link switchChoiceCase}. */
     switchCase(key: string, choice: NodeChoice, caseName: string): void;
     protected readonly asFormGroup: typeof asFormGroup;
     protected readonly asFormArray: typeof asFormArray;
     protected readonly asFormControl: typeof asFormControl;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicRecursiveFormComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicRecursiveFormComponent, "nff-dynamic-recursive-form", never, { "schema": { "alias": "schema"; "required": true; }; "initialValue": { "alias": "initialValue"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "index": { "alias": "index"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "title": { "alias": "title"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "addButtonCallback": { "alias": "addButtonCallback"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicRecursiveFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicRecursiveFormComponent, "nff-dynamic-recursive-form", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "initialValue": { "alias": "initialValue"; "required": false; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "addButtonCallback": { "alias": "addButtonCallback"; "required": false; "isSignal": true; }; "focusLeaf": { "alias": "focusLeaf"; "required": false; "isSignal": true; }; }, { "remove": "remove"; "editable": "editableChange"; }, never, never, true, never>;
 }
 
 /** Metadata on a list-container node that lets the tree add items to its FormArray. */
@@ -162,91 +369,260 @@ interface ListRef {
     itemSchema: NodeGroup;
     itemLabel: string;
     minItems: number;
+    maxItems?: number;
 }
-/** A navigable node in the config tree. Groups and list items are tree nodes; leaves are their detail. */
+/** An absent optional (presence) child, offered by its parent node's "+ Optional field" menu. */
+interface OptionalEntry {
+    key: string;
+    schema: NodeType;
+    label: string;
+}
+/**
+ * One flat section of the detail pane. The selected node's subtree renders as a
+ * pre-order list of these — no nesting chrome: each section after the first is
+ * separated by a breadcrumb heading (`trail`), and holds only the node's *own*
+ * fields (`schema` is a leaf-only slice; complex children are sections of their
+ * own, deeper in the list).
+ */
+interface DetailSection {
+    node: TreeNode;
+    /** Selected-node-to-here trail, rendered as the section's breadcrumb heading (omitted on the first section). */
+    trail: TreeNode[];
+    /** Leaf-only slice of the node's own schema, or null when it has no own fields. */
+    schema: NodeGroup | null;
+    /** The group `schema` binds to (the node's group; for a choice, the choice group). */
+    group: FormGroup | null;
+}
+/**
+ * A navigable node in the config tree. Its `id` is the node's stable path from
+ * the root (`system/ntp`, `ifaces/0`, `servers/web1`), so expansion and
+ * selection survive tree rebuilds. Segments are `%`/`/`-escaped, since map
+ * entry keys are arbitrary runtime data; list-item identity is positional.
+ */
 interface TreeNode {
     id: string;
     label: string;
     children: TreeNode[];
-    /** Leaves editable when this node is selected. Empty for list-container nodes. */
-    leaves: {
-        key: string;
-        node: Leaf;
-    }[];
-    leafLists: {
-        key: string;
-        node: LeafList;
-    }[];
-    /** The FormGroup holding this node's leaves, or null for a list-container node. */
+    /** The node's own FormGroup, or null for a list-container or map node. */
     group: FormGroup | null;
+    /** The node's own schema, set on group-backed nodes (groups, list items, group-valued map entries). */
+    schema?: NodeGroup;
     /** Present on a nodeGroupList node: lets a `+` add an item. */
     list?: ListRef;
-    /** Present on a list-item node: the FormArray and current index it can be removed from. */
+    /** Present on a list-item node: its current index in the parent list (removal goes through the parent list array). */
     removable?: {
-        array: FormArray;
         index: number;
     };
-    /** Present on an optional (presence) group node: lets a checkbox add/remove the group. */
-    presence?: {
-        parentGroup: FormGroup;
+    /** Absent optional children of this node, offered by its "+ Optional field" menu (schema order). */
+    optionals?: OptionalEntry[];
+    /** Present on a present optional child node: drives the row's remove control. */
+    presenceRemovable?: {
+        key: string;
+    };
+    /** Present on a choice node: the choice schema and its FormGroup (holding `__case` + the active case's fields). */
+    choice?: {
+        schema: NodeChoice;
+        group: FormGroup;
+    };
+    /** Present on a map node. `complex` maps expand entries as child nodes. */
+    map?: {
+        schema: NodeMap;
+        group: FormGroup;
+        complex: boolean;
+    };
+    /** Present on a complex-map entry node: addresses the entry in its map for remove/rename. */
+    mapEntry?: {
+        mapGroup: FormGroup;
+        mapSchema: NodeMap;
         key: string;
-        schema: NodeGroup;
     };
-    /** For a presence node: whether the group is currently present. */
-    present?: boolean;
 }
 /**
- * A tree/detail editor for a schema-built form: the structure (containers, lists,
- * groups) is a tree on the left, and selecting a node shows that node's leaf
- * fields for editing on the right. A `+` on a list node adds an entry; a delete
- * button on each item removes it. An alternative to the all-in-one
- * {@link DynamicRecursiveFormComponent} for large configs.
+ * A tree/detail editor for a schema-built form: the structure (groups, lists,
+ * maps, choices) is a tree on the left, and selecting a node renders that
+ * node's **entire subtree** on the right as a **flat list of sections** — the
+ * node's own fields first, then every descendant's fields, each separated by a
+ * breadcrumb heading (`Service / Deploy scope / …`) instead of nested panels.
+ * Leaf fields render through {@link DynamicRecursiveFormComponent} with a
+ * leaf-only schema slice; choice selectors, map rows, and add controls render
+ * inline in their section. The tree adds row conveniences of its own: `+` on
+ * list and map rows, a delete control on removable rows, and a
+ * "+ Optional field" menu for absent presence children.
+ *
+ * The tree is **derived state**: any structural change to the form — made
+ * through the tree rows or through the detail sections — triggers a rebuild (a
+ * cheap shape signature over `valueChanges` detects it). Node ids are stable
+ * paths, so expansion and selection survive rebuilds. Swapping the `schema` or
+ * `formGroup` input rebinds the editor to the new pair, resetting expansion
+ * and selection.
+ *
+ * The component draws no outer container — only a divider between the tree and
+ * detail panes — so the embedding client owns the surrounding chrome.
  */
-declare class ConfigEditorComponent implements OnInit {
-    schema: NodeGroup;
-    formGroup: FormGroup;
-    editable: boolean;
+declare class ConfigEditorComponent implements OnDestroy {
+    /** The form-description schema whose structure the tree renders. */
+    readonly schema: _angular_core.InputSignal<NodeGroup>;
+    /** The schema-built reactive group the editor binds to and mutates. */
+    readonly formGroup: _angular_core.InputSignal<FormGroup<any>>;
+    /** Whether fields accept input and structural controls (add/remove/menus) show. */
+    readonly editable: _angular_core.InputSignal<boolean>;
     root: TreeNode;
     selected: TreeNode | null;
+    /** The selected subtree as a flat, breadcrumb-separated section list. */
+    sections: DetailSection[];
+    /** Root-to-selection trail for the detail-pane breadcrumb, computed once per selection. */
+    breadcrumb: TreeNode[];
     readonly expanded: Set<string>;
-    private nextId;
-    ngOnInit(): void;
-    select(node: TreeNode): void;
-    /** Select a child (list item or sub-group) from the detail pane, keeping its parent expanded in the tree. */
-    open(parent: TreeNode, child: TreeNode): void;
+    private shape;
+    private changes?;
+    private readonly host;
+    /** Stable per-instance ids for the shape signature, so replacing a control (setControl) reads as a structural change. */
+    private readonly controlIds;
+    private controlIdSeq;
+    constructor();
+    ngOnDestroy(): void;
+    /** Bind the editor to a schema/form pair: fresh tree, root selection, and shape-sync subscription. */
+    private attach;
+    select(node: TreeNode, reveal?: boolean): void;
     /**
      * Root-to-`target` path for the detail-pane breadcrumb (inclusive of both ends),
-     * or an empty array if `target` is not in the current tree. Searched fresh each
-     * call so it stays correct after add/remove/presence mutations rebuild subtrees.
+     * or an empty array if `target` is not in the current tree.
      */
     pathTo(target: TreeNode): TreeNode[];
-    toggle(node: TreeNode): void;
-    /** Append a new item to a list node's FormArray and to the tree, then select it. */
+    protected toggle(node: TreeNode): void;
+    /** Keyboard access for tree rows: Enter/Space selects, ArrowRight expands, ArrowLeft collapses. */
+    protected onRowKeydown(event: KeyboardEvent, node: TreeNode): void;
+    /** Whether the row shows an expand twisty: it has child rows to reveal (children or an optionals menu row). */
+    protected hasExpandableContent(node: TreeNode): boolean;
+    /**
+     * Whether the node's form subtree holds a validation error. Group/choice, list,
+     * and map nodes each check their backing control; `invalid` aggregates over
+     * descendants, so an error anywhere below lights every ancestor row.
+     */
+    protected hasError(node: TreeNode): boolean;
+    /** Append a new item to a list node's FormArray (up to `maxItems`), then select it. */
     addItem(listNode: TreeNode): void;
-    /** Remove a list item from its FormArray and the tree (down to `minItems`). */
+    /**
+     * Remove a list item from its FormArray (down to `minItems`). List-item
+     * identity is positional, so expansion state under the list is cleared —
+     * otherwise it would silently migrate to the items that shift into the
+     * removed indexes.
+     */
     removeItem(listNode: TreeNode, item: TreeNode): void;
-    /** Enable or disable an optional (presence) group by adding/removing its control. */
-    setPresence(node: TreeNode, present: boolean): void;
-    protected readonly asFormControl: typeof asFormControl;
-    protected readonly asFormArray: typeof asFormArray;
-    private placeholder;
-    /** Re-index and re-label a list node's item children (just "#n") after add/remove. */
-    private renumber;
+    /** The just-added optional leaf (section path + key) whose field grabs focus when rendered. */
+    protected focusSectionId: string | null;
+    protected focusLeafKey: string | null;
+    /** Add an absent optional child from the menu: build its control and select the node it lands on. */
+    addOptional(node: TreeNode, entry: OptionalEntry): void;
+    /** Remove a present optional child node, returning its entry to the parent's menu. */
+    removeOptional(parent: TreeNode, node: TreeNode): void;
+    /** The active case name of a choice node, or null when none is selected. */
+    activeCase(node: TreeNode): string | null;
+    /** The display label of a choice node's active case, or null when no case is selected. */
+    activeCaseLabel(node: TreeNode): string | null;
+    /** The display label for a case: the schema's `caseLabels` entry, else the case name. */
+    protected caseLabel(choice: NodeChoice, caseName: string): string;
+    /** Switch a choice node's active case; the structural sync rebuilds the tree and sections. */
+    switchTreeCase(node: TreeNode, caseName: string): void;
+    protected objectKeys(obj: Record<string, unknown>): string[];
+    /** Append a new entry to a complex map node under a generated unique key, then select it. */
+    addTreeMapEntry(mapNode: TreeNode): void;
+    /** Remove a complex map entry (down to `minEntries`). */
+    removeTreeMapEntry(mapNode: TreeNode, entryNode: TreeNode): void;
+    /**
+     * Commit a rename-on-blur of a map entry's key; on success the entry is
+     * selected under its new path and its fresh key field regains focus (the
+     * rename re-renders the section under a new id, destroying the input that
+     * held focus).
+     */
+    renameTreeMapEntry(entryNode: TreeNode, rawKey: string): void;
+    /** Move keyboard focus to the selected tree row once the action's re-render settles. */
+    private focusSelectedRow;
+    /** A muted hint for a section whose node currently renders no content of its own. */
+    protected emptySectionHint(s: DetailSection): string | null;
+    /** Whether a list node is at `maxItems` (the add control is hidden). */
+    protected listAtMax(node: TreeNode | undefined): boolean;
+    /** Whether a list node is at `minItems` (item remove controls are hidden). */
+    protected listAtMin(node: TreeNode | undefined): boolean;
+    /** Whether a map node is at `maxEntries` (the add control is hidden). */
+    protected mapAtMax(node: TreeNode | undefined): boolean;
+    /** Whether a map node is at `minEntries` (entry remove controls are hidden). */
+    protected mapAtMin(node: TreeNode | undefined): boolean;
+    /** Rebuild the tree from the current form structure if its shape changed. */
+    private syncShape;
+    /**
+     * A cheap structural signature of a control tree: group keys (plus the active
+     * `__case`), array lengths, leaf placeholders. Value edits don't change it;
+     * added/removed/renamed controls and case switches do. Reading `__case` from
+     * any group is safe because the name is reserved (the builder rejects it as a
+     * case field name or map entry key), so only choice groups carry it.
+     */
+    private shapeOf;
+    /** The instance id a container contributes to the shape signature. */
+    private uidOf;
+    /** Rebuild the whole tree from schema + form and refresh the shape signature. */
+    private rebuild;
+    /** Re-point `selected` at the rebuilt tree: same path, else the closest surviving ancestor. */
+    private reconcileSelection;
+    /** The node at `path` in the current tree, or null. Walks by id-prefix segments. */
+    private byPath;
+    /** Select the node at `path`, falling back through its ancestors to the root. */
+    private selectByPath;
+    /**
+     * Flatten a subtree into detail sections, pre-order: the node's own fields
+     * first, then each child as its own breadcrumb-headed section. No nesting
+     * chrome — the headings are the boundaries between children.
+     */
+    private buildSections;
+    /** A section's own renderable fields: a leaf-only schema slice and the group it binds to. */
+    private sectionContent;
+    /**
+     * The node's own fields as a flattened schema: leaf and leafList children
+     * only. Complex children are rendered as sections of their own, so the
+     * embedded form never draws nested section chrome. Null when there are none.
+     */
+    private leafOnly;
     private buildTree;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigEditorComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigEditorComponent, "nff-config-editor", never, { "schema": { "alias": "schema"; "required": true; }; "formGroup": { "alias": "formGroup"; "required": true; }; "editable": { "alias": "editable"; "required": false; }; }, {}, never, never, true, never>;
+    /** Build the tree node for a single non-leaf child, dispatching on its kind. Null when its control is missing. */
+    private buildChildNode;
+    /** Synthetic group over a case's normalized fields, so a case body builds like any group. */
+    private caseAsGroup;
+    /** A node's display label: its schema `label`, else its record key. */
+    private labelOf;
+    /** Join a parent path and a segment; the root's path is the empty string. */
+    private join;
+    /**
+     * Escape a path segment: `/` is the id separator, and map entry keys are
+     * arbitrary runtime data that may contain it. Labels stay unescaped — only
+     * node identities encode.
+     */
+    private escapeSeg;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConfigEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConfigEditorComponent, "nff-config-editor", never, { "schema": { "alias": "schema"; "required": true; "isSignal": true; }; "formGroup": { "alias": "formGroup"; "required": true; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-declare class LeafRendererComponent implements OnInit {
+declare class LeafRendererComponent implements AfterViewInit {
+    private readonly elementRef;
     leaf_: Leaf | AnonLeaf;
     control: FormControl;
-    initialValue?: any;
     removable: boolean;
     editable: boolean;
-    remove: EventEmitter<number>;
-    ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LeafRendererComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LeafRendererComponent, "nff-leaf-renderer", never, { "leaf_": { "alias": "leaf_"; "required": false; }; "control": { "alias": "control"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
+    /** Focus the field once rendered — for fields the user just added (e.g. an enabled presence leaf). */
+    autofocus: boolean;
+    /** Emitted when the user removes this field (e.g. an optional presence leaf). */
+    readonly remove: _angular_core.OutputEmitterRef<void>;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    /** Whether this field accepts input: the form is editable and the leaf is not `readOnly`. */
+    get fieldEditable(): boolean;
+    /**
+     * A human-readable message for the control's active validation error, or `''`
+     * when valid. `mat-form-field` only shows it once the field is in an error
+     * state (invalid and touched), so it can be bound unconditionally.
+     */
+    get errorText(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LeafRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LeafRendererComponent, "nff-leaf-renderer", never, { "leaf_": { "alias": "leaf_"; "required": false; }; "control": { "alias": "control"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
 }
 
 declare class LeafListRendererComponent implements OnInit {
@@ -267,8 +643,8 @@ declare class LeafListRendererComponent implements OnInit {
     ngOnInit(): void;
     removeItem($index: number): void;
     addItem(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LeafListRendererComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LeafListRendererComponent, "nff-leaf-list-renderer", never, { "leaf_": { "alias": "leaf_"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "formArray": { "alias": "formArray"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "minItems": { "alias": "minItems"; "required": false; }; }, { "message": "message"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LeafListRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LeafListRendererComponent, "nff-leaf-list-renderer", never, { "leaf_": { "alias": "leaf_"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "formArray": { "alias": "formArray"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "minItems": { "alias": "minItems"; "required": false; }; }, { "message": "message"; }, never, never, true, never>;
 }
 
 declare class LeafEnumRendererComponent {
@@ -278,8 +654,8 @@ declare class LeafEnumRendererComponent {
     removable: boolean;
     remove: any;
     editable: boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LeafEnumRendererComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LeafEnumRendererComponent, "nff-leaf-enum-renderer", never, { "leafEnum": { "alias": "leafEnum"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "control": { "alias": "control"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "remove": { "alias": "remove"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LeafEnumRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LeafEnumRendererComponent, "nff-leaf-enum-renderer", never, { "leafEnum": { "alias": "leafEnum"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "control": { "alias": "control"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "remove": { "alias": "remove"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 declare class NodeGroupListRendererComponent implements OnInit, AfterViewInit {
@@ -299,9 +675,45 @@ declare class NodeGroupListRendererComponent implements OnInit, AfterViewInit {
     setLastEditable(): void;
     asFormGroup(group: any): FormGroup;
     getTitle($index: number): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NodeGroupListRendererComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NodeGroupListRendererComponent, "nff-node-group-list-renderer", never, { "nodeGroupList": { "alias": "nodeGroupList"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "formArray": { "alias": "formArray"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "minItems": { "alias": "minItems"; "required": false; }; "maxItems": { "alias": "maxItems"; "required": false; }; }, { "message": "message"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NodeGroupListRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NodeGroupListRendererComponent, "nff-node-group-list-renderer", never, { "nodeGroupList": { "alias": "nodeGroupList"; "required": false; }; "initialValue": { "alias": "initialValue"; "required": false; }; "formArray": { "alias": "formArray"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "minItems": { "alias": "minItems"; "required": false; }; "maxItems": { "alias": "maxItems"; "required": false; }; }, { "message": "message"; }, never, never, true, never>;
+}
+
+/**
+ * Renders a {@link NodeMap}: an open, arbitrary-keyed record. Each entry is a row
+ * with an editable key and the shared value schema's control; the user can add,
+ * remove, and rename entries. The map's control is a `FormGroup` whose control
+ * names are the entry keys, so the key is edited as a *rename* (remove + re-add
+ * the same control) committed on blur — see {@link renameEntry}.
+ */
+declare class NodeMapRendererComponent implements OnChanges {
+    nodeMap: NodeMap;
+    formGroup: FormGroup<any>;
+    editable: boolean;
+    /** Ordered view of entry keys, kept stable across renames (`addControl` appends). */
+    entryKeys: string[];
+    ngOnChanges(changes: SimpleChanges): void;
+    /** The value schema as a leaf (used when `value.kind === 'leaf'`). */
+    get valueLeaf(): Leaf;
+    /** The value schema as a group (used when `value.kind === 'nodeGroup'`). */
+    get valueGroup(): NodeGroup;
+    get atMax(): boolean;
+    get atMin(): boolean;
+    /** Append a new entry under a unique placeholder key. Delegates to {@link addMapEntry}. */
+    addEntry(): void;
+    /** Drop an entry (its control leaves the group, so it drops from the value). Delegates to {@link removeMapEntry}. */
+    removeEntry(key: string): void;
+    /**
+     * Commit an edited key by renaming its control once (the value is preserved).
+     * An empty, unchanged, duplicate, or `keyPattern`-violating key is a no-op,
+     * leaving the entry under its current name. Delegates to {@link renameMapEntry}.
+     */
+    renameEntry(oldKey: string, rawKey: string): void;
+    protected readonly asFormControl: typeof asFormControl;
+    protected readonly asFormGroup: typeof asFormGroup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NodeMapRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NodeMapRendererComponent, "nff-node-map-renderer", never, { "nodeMap": { "alias": "nodeMap"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; }, {}, never, never, true, never>;
 }
 
-export { CASE_KEY, ConfigEditorComponent, DynamicRecursiveFormComponent, LeafEnumRendererComponent, LeafListRendererComponent, LeafRendererComponent, NodeGroupListRendererComponent, buildControl, buildFormFromSchema, defineSchema };
-export type { AnonLeaf, Appearance, DFormControl, DFormGroup, FormGroupType, Leaf, LeafBase, LeafBoolean, LeafEnum, LeafList, LeafNumber, LeafRuntimeType, LeafString, NodeChoice, NodeGroup, NodeGroupList, NodeType };
+export { CASE_KEY, ConfigEditorComponent, DynamicRecursiveFormComponent, LeafEnumRendererComponent, LeafListRendererComponent, LeafRendererComponent, NodeGroupListRendererComponent, NodeMapRendererComponent, addMapEntry, buildControl, buildFormFromSchema, caseFields, defineSchema, removeMapEntry, renameMapEntry, resolveChoiceCase, switchChoiceCase };
+export type { AnonLeaf, Appearance, ChoiceCase, DFormControl, DFormGroup, FormGroupType, Leaf, LeafBase, LeafBoolean, LeafEnum, LeafList, LeafNumber, LeafRuntimeType, LeafString, NodeChoice, NodeGroup, NodeGroupList, NodeMap, NodeType };